Upload 81 files

.audit_report.json

@@ -0,0 +1,219 @@
+{
+  "duplicate_keys": {},
+  "widgets_without_key": {
+    ".\\app.py": {
+      "button_no_key": [
+        445
+      ]
+    },
+    ".\\app_outlook.py": {
+      "download_no_key": [
+        24,
+        36,
+        82
+      ]
+    },
+    ".\\auditoria.py": {
+      "download_no_key": [
+        91
+      ]
+    },
+    ".\\auditoria_cleanup.py": {
+      "button_no_key": [
+        65
+      ]
+    },
+    ".\\consulta.py": {
+      "download_no_key": [
+        171
+      ]
+    },
+    ".\\db_admin.py": {
+      "button_no_key": [
+        213,
+        241,
+        263,
+        316,
+        360
+      ]
+    },
+    ".\\db_export_import.py": {
+      "button_no_key": [
+        273,
+        285,
+        301,
+        320,
+        333
+      ],
+      "download_no_key": [
+        277,
+        289,
+        305
+      ]
+    },
+    ".\\db_monitor.py": {
+      "button_no_key": [
+        261,
+        265
+      ]
+    },
+    ".\\db_tools.py": {
+      "button_no_key": [
+        57
+      ]
+    },
+    ".\\importar_excel.py": {
+      "download_no_key": [
+        77
+      ]
+    },
+    ".\\jogos.py": {
+      "button_no_key": [
+        104,
+        256,
+        356
+      ]
+    },
+    ".\\login.py": {
+      "button_no_key": [
+        83
+      ]
+    },
+    ".\\operacao.py": {
+      "button_no_key": [
+        1444,
+        1452,
+        1471,
+        1487
+      ],
+      "download_no_key": [
+        1543,
+        1547
+      ]
+    },
+    ".\\outlook_relatorio.py": {
+      "download_no_key": [
+        30,
+        42,
+        79
+      ]
+    },
+    ".\\Produtividade_Especialista.py": {
+      "button_no_key": [
+        52
+      ],
+      "download_no_key": [
+        506,
+        518
+      ]
+    },
+    ".\\quiz.py": {
+      "button_no_key": [
+        107
+      ]
+    },
+    ".\\quiz_admin.py": {
+      "button_no_key": [
+        57
+      ]
+    },
+    ".\\ranking.py": {
+      "download_no_key": [
+        109
+      ]
+    },
+    ".\\repositorio_load.py": {
+      "download_no_key": [
+        251,
+        344
+      ]
+    },
+    ".\\videos.py": {
+      "button_no_key": [
+        65,
+        85
+      ]
+    }
+  },
+  "missing_imports_in_app": [],
+  "routing_vs_modules": {
+    "routes_without_modules_entry": [],
+    "modules_entry_without_route": [
+      "administracao",
+      "auditoria",
+      "auditoria_cleanup",
+      "backload_consulta",
+      "calendario",
+      "calendario_mensal",
+      "consulta",
+      "db_admin",
+      "db_export_import",
+      "db_monitor",
+      "formulario",
+      "importacao",
+      "indicadores",
+      "jogos",
+      "operacao",
+      "outlook_relatorio",
+      "produtividade_especialista",
+      "quiz",
+      "quiz_admin",
+      "ranking",
+      "relatorio",
+      "repositorio_load",
+      "resposta",
+      "sugestoes_ioirun",
+      "terceiros_gestao",
+      "usuarios",
+      "videos"
+    ]
+  },
+  "module_files_missing": [],
+  "modules_without_main": [],
+  "unused_imports": {
+    ".\\auto_capture.py": [
+      "TimeoutError"
+    ],
+    ".\\calendario_mensal.py": [
+      "formatar_data_br"
+    ],
+    ".\\db_admin.py": [
+      "SessionLocal"
+    ],
+    ".\\db_export_import.py": [
+      "SessionLocal"
+    ],
+    ".\\db_monitor.py": [
+      "time",
+      "SessionLocal",
+      "verificar_permissao"
+    ],
+    ".\\env_audit.py": [
+      "Tuple"
+    ],
+    ".\\init_db.py": [
+      "models"
+    ],
+    ".\\modules_map.py": [
+      "calendario",
+      "calendario_mensal"
+    ],
+    ".\\utils_auditoria.py": [
+      "db_info"
+    ],
+    ".\\utils_campos.py": [
+      "Equipamento"
+    ],
+    ".\\utils_datas.py": [
+      "date"
+    ],
+    ".\\utils_lembretes.py": [
+      "date"
+    ],
+    ".\\utils_operacao.py": [
+      "annotations",
+      "st"
+    ]
+  },
+  "import_cycles": []
+}

.env

@@ -0,0 +1,79 @@
+
+# --- Mayasuite API (Operação) ---
+OP_ACCESS_TOKEN=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJmcmVzaCI6ZmFsc2UsImlhdCI6MTc2ODQ4NjI5NywianRpIjoiNTQ1NjdkYmUtZGUxZi00ZDAxLTkzYzktZGRiYzk4MGJmYWNlIiwidHlwZSI6ImFjY2VzcyIsInN1YiI6IjgzNDAxM2QzLWJhNTMtNDQ1MC1hZmJlLTc4ODZhZjQ5MjJiNCIsIm5iZiI6MTc2ODQ4NjI5NywiY3NyZiI6IjQ3OGNjM2RiLTU5ZGItNDU5NS04ZjdjLWQzM2RhMDAzMjZhMCIsImV4cCI6MTc2ODUyOTQ5N30.R3Bi6c9uxjv8ehvT6JqIshgQqiTJIP8Lm4XlmY-bStg
+# Alternativas (opcionais, usadas só se a primária falhar)
+OP_LOGIN_EMAIL_ALT=api@armmatriz.com.br
+OP_LOGIN_PASSWORD_ALT=Arm@2025
+
+# Ativa logs de corpo de erro (apenas DIAGNÓSTICO TEMPORÁRIO)
+OP_LOGIN_DEBUG=true
+# Configurações de requisição
+OP_READ_TIMEOUT=60         # p.ex., 60s (alguns endpoints demoram mais)
+OP_RATE_DELAY_SEC=0.5      # atraso menor entre páginas
+OP_MAX_PAGES=1             # padrão apenas 1 página (você controla na UI)
+OP_MAX_RETRIES_5XX=3       # menos tentativas para 5xx
+OP_5XX_BACKOFF_BASE=2      # backoff mais curto
+OP_RETRY_TIMEOUT_TOTAL=90  # timeout total menor para retries
+# --- Fim Mayasuite API (Operação) ---
+
+
+# ================================
+# 🔀 Bancos (Multi‑ambiente SQLite)
+# ================================
+# Utilize estes URLs caso deseje ler os caminhos pelo .env.
+# Para ativar no db_router.py, DESCOMENTE o bloco de dotenv nele.
+DB1_PROD_URL=sqlite:///C:/Users/rodrigo.silva/OneDrive - ARM ARMAZENS GERAIS & LOGISTICA LTDA/Load/LoadApp/Load.db
+DB2_TEST_URL=sqlite:///C:/Users/rodrigo.silva/OneDrive - ARM ARMAZENS GERAIS & LOGISTICA LTDA/Load/LoadApp/Load_teste.db
+DB3_TREINAMENTO_URL=sqlite:///C:/Users/rodrigo.silva/OneDrive - ARM ARMAZENS GERAIS & LOGISTICA LTDA/Load/LoadApp/Load_treinamento.db
+
+# (Opcional) rótulos amigáveis por ambiente (se quiser ler via .env)
+DB1_LABEL=Banco 1 (📗 Produção)
+DB2_LABEL=Banco 2 (📕 Teste)
+DB3_LABEL=Banco 3 (📘 Treinamento)
+
+
+# ==================================
+# 🤖 Automação de captura/apresentação
+# ==================================
+# Usado pelo script auto_capture.py (Playwright + python-pptx)
+APP_URL=http://localhost:8501
+
+# Usuário/senha para login automático (recomendado perfil admin em Teste/Treinamento)
+LOGIN_USER=admin
+LOGIN_PASS=admin123
+
+# Ambiente alvo para captura: prod | test | treinamento
+BANK_CHOICE=prod
+
+# Saídas de captura e apresentação
+SCREEN_DIR=./screenshots
+OUTPUT_PPTX=./demo_funcionalidades.pptx
+
+# (Opcional) parâmetros da captura
+AUTOCAPTURE_HEADLESS=false       # true = sem abrir janela; false = visível
+AUTOCAPTURE_VIEWPORT_W=1440
+AUTOCAPTURE_VIEWPORT_H=900
+
+# (Opcional) pular quiz durante captura (se seu login exigir quiz)
+AUTOCAPTURE_SKIP_QUIZ=true
+
+
+# ==========================
+# 🧰 Monitor/Backup do banco
+# ==========================
+# Diretório padrão de backups (db_monitor.py)
+BACKUP_DIR=./backups
+BACKUP_RETAIN=10              # manter N arquivos mais recentes
+BACKUP_FREQ_DAYS=7            # frequência "prevista" em dias
+
+# (Opcional) mostrar URL do engine na sidebar (se usar no app.py)
+SHOW_ENGINE_URL_IN_SIDEBAR=true
+
+
+# ==========================
+# 🔧 Streamlit (opcional)
+# ==========================
+# STREAMLIT_SERVER_ADDRESS=0.0.0.0
+# STREAMLIT_SERVER_PORT=8501
+# STREAMLIT_BROWSER_GATHER_USAGE_STATS=false
+# STREAMLIT_THEME_BASE="light"

.gitattributes

@@ -32,3 +32,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Load.db filter=lfs diff=lfs merge=lfs -text
+Load.db.bak filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,132 +1,42 @@
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-*$py.class
-# *.html
-private/
-.vscode/
-
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-pip-wheel-metadata/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-#  Usually these files are written by a python script from a template
-#  before PyInstaller builds the exe, so as to inject date/other infos into it.
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.py,cover
-.hypothesis/
-.pytest_cache/
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-db.sqlite3-journal
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# pyenv
-.python-version
-
-# pipenv
-#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
-#   However, in case of collaboration, if having platform-specific dependencies or dependencies
-#   having no cross-platform support, pipenv may install dependencies that don't work, or not
-#   install all needed dependencies.
-#Pipfile.lock
-
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow
-__pypackages__/
-
-# Celery stuff
-celerybeat-schedule
-celerybeat.pid
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
-.env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Pyre type checker
-.pyre/
+# ========================
+# Python
+# ========================
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+
+# ========================
+# Ambiente virtual
+# ========================
+venv/
+env/
+.venv/
+
+# ========================
+# Variáveis de ambiente
+# ========================
+.env
+
+# ========================
+# Banco de dados
+# ========================
+*.db
+*.sqlite
+*.sqlite3
+
+# ========================
+# Streamlit
+# ========================
+.streamlit/
+
+# ========================
+# Logs
+# ========================
+*.log
+
+# ========================
+# Sistema operacional
+# ========================
+.DS_Store
+Thumbs.db

.txt

@@ -0,0 +1,2 @@
+DATABASE_URL=postgresql://...
+SENHA_ADMIN=admin123

20260129_add_po_alt_pn_lot_batch.py

@@ -0,0 +1,40 @@
+"""add po_alt, pn, lot_batch to recebimento_registros
+
+Revision ID: 8f7c3e5a9b21
+Revises: <COLOQUE_AQUI_O_REVISION_ID_ANTERIOR>
+Create Date: 2026-01-29 13:20:00.000000
+"""
+
+from alembic import op
+import sqlalchemy as sa
+
+# Revisão atual e anterior
+revision = '8f7c3e5a9b21'
+down_revision = '<COLOQUE_AQUI_O_REVISION_ID_ANTERIOR>'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # Usamos batch_alter_table p/ compatibilidade (SQLite etc.)
+    with op.batch_alter_table('recebimento_registros', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('po_alt', sa.String(length=60), nullable=True))
+        batch_op.add_column(sa.Column('pn', sa.String(length=120), nullable=True))
+        batch_op.add_column(sa.Column('lot_batch', sa.String(length=120), nullable=True))
+
+        # Se desejar índices (opcionais), descomente:
+        # batch_op.create_index('ix_receb_po_alt', ['po_alt'])
+        # batch_op.create_index('ix_receb_pn', ['pn'])
+        # batch_op.create_index('ix_receb_lot_batch', ['lot_batch'])
+
+
+def downgrade():
+    with op.batch_alter_table('recebimento_registros', schema=None) as batch_op:
+        # Se criou índices acima, primeiro drope-os:
+        # batch_op.drop_index('ix_receb_lot_batch')
+        # batch_op.drop_index('ix_receb_pn')
+        # batch_op.drop_index('ix_receb_po_alt')
+
+        batch_op.drop_column('lot_batch')
+        batch_op.drop_column('pn')
+        batch_op.drop_column('po_alt')

Inbox_Admin.py

@@ -0,0 +1,197 @@
+
+# pages/Inbox_Admin.py
+# -*- coding: utf-8 -*-
+import streamlit as st
+from datetime import datetime
+from sqlalchemy import func
+
+# Model
+from models import IOIRunSugestao
+
+# (Opcional) auditoria
+try:
+    from utils_auditoria import registrar_log
+except Exception:
+    registrar_log = None
+
+# ------------- CONFIG BÁSICA -------------
+st.set_page_config(page_title="📬 Inbox Admin • IOI-RUN", layout="wide")
+
+STATUS_PENDENTE = "pendente"
+STATUS_RESPONDIDA = "respondida"
+
+
+# ------------- Sessão de banco ciente do ambiente -------------
+def _get_db_session():
+    """
+    Retorna uma sessão de banco consistente com o ambiente atual.
+    Tenta usar o db_router (se presente); senão, cai para SessionLocal().
+    """
+    try:
+        from db_router import get_session_for_current_db
+        return get_session_for_current_db()
+    except Exception:
+        pass
+    try:
+        from banco import SessionLocal
+        return SessionLocal()
+    except Exception as e:
+        st.error(f"Banco indisponível: {e}")
+        raise
+
+
+def _debug_banco_caption():
+    """Mostra em qual banco estamos (Produção/Teste/Treinamento)."""
+    try:
+        from db_router import current_db_choice, bank_label
+        choice = current_db_choice()
+        label = bank_label(choice)
+        st.caption(f"🗄️ Banco ativo: **{label}**")
+    except Exception:
+        st.caption("🗄️ Banco ativo: **default**")
+
+
+# ------------- Guarda de rota (somente admin) -------------
+def _ensure_admin():
+    perfil = (st.session_state.get("perfil") or "").strip().lower()
+    if perfil != "admin":
+        st.error("Acesso negado. Esta página é restrita a administradores.")
+        st.stop()
+
+
+# ------------- Página -------------
+def main():
+    _ensure_admin()
+
+    st.title("📬 Caixa de Entrada • IOI‑RUN (Admin)")
+    st.caption("Responda sugestões dos usuários em uma página separada, sem interferência do app principal.")
+    _debug_banco_caption()
+
+    # Estados persistentes exclusivos desta página (prefixo 'adm_inbox_')
+    st.session_state.setdefault("adm_inbox_area", "todos")
+    st.session_state.setdefault("adm_inbox_status", STATUS_PENDENTE)
+    st.session_state.setdefault("adm_inbox_usuario", "")
+    st.session_state.setdefault("adm_inbox_nonce", 0)
+
+    AREAS = ["todos", "WMS", "FPSO", "UI/UX", "Relatórios", "Integrações", "Performance", "Segurança", "Outros"]
+    STATUS = [STATUS_PENDENTE, STATUS_RESPONDIDA, "todos"]
+
+    # ------------- Filtros -------------
+    col_f1, col_f2, col_f3, col_f4 = st.columns([1, 1, 1, 0.6])
+    col_f1.selectbox(
+        "Área/Tema",
+        AREAS,
+        key="adm_inbox_area",
+        index=AREAS.index(st.session_state["adm_inbox_area"]) if st.session_state["adm_inbox_area"] in AREAS else 0
+    )
+    col_f2.selectbox(
+        "Status",
+        STATUS,
+        key="adm_inbox_status",
+        index=STATUS.index(st.session_state["adm_inbox_status"]) if st.session_state["adm_inbox_status"] in STATUS else 0
+    )
+    col_f3.text_input(
+        "Filtrar por usuário (login exato)",
+        key="adm_inbox_usuario",
+        value=st.session_state["adm_inbox_usuario"]
+    )
+
+    if col_f4.button("🔄 Atualizar lista"):
+        st.session_state["adm_inbox_nonce"] += 1
+        st.rerun()
+
+    # ------------- Consulta -------------
+    db = _get_db_session()
+    try:
+        q = db.query(IOIRunSugestao)
+        if st.session_state["adm_inbox_area"] != "todos":
+            q = q.filter(IOIRunSugestao.area == st.session_state["adm_inbox_area"])
+        if st.session_state["adm_inbox_status"] != "todos":
+            q = q.filter(func.lower(IOIRunSugestao.status) == st.session_state["adm_inbox_status"])
+        if (st.session_state["adm_inbox_usuario"] or "").strip():
+            q = q.filter(IOIRunSugestao.usuario == (st.session_state["adm_inbox_usuario"] or "").strip())
+
+        sugestoes = q.order_by(IOIRunSugestao.data_envio.desc()).all()
+    except Exception as e:
+        st.error(f"Erro ao consultar sugestões: {e}")
+        sugestoes = []
+
+    # ------------- Lista / Edição -------------
+    if not sugestoes:
+        st.info("Nenhuma sugestão encontrada para os filtros aplicados.")
+    else:
+        for s in sugestoes:
+            dt_envio = s.data_envio.strftime("%d/%m/%Y %H:%M") if s.data_envio else "—"
+            titulo = f"📩 {dt_envio} — {s.usuario} — Status: {s.status or '—'}"
+            if s.area:
+                titulo += f" — Área: {s.area}"
+
+            with st.expander(titulo, expanded=False):
+                st.markdown("**Sugestão:**")
+                st.write(s.mensagem or "—")
+
+                with st.form(key=f"adm_inbox_form_{s.id}", clear_on_submit=False):
+                    resposta_txt = st.text_area(
+                        f"Responder ao usuário ({s.usuario}) — ID {s.id}",
+                        value=s.resposta or "",
+                        key=f"adm_inbox_resposta_{s.id}",
+                        placeholder="Digite sua resposta para este usuário…",
+                        height=140
+                    )
+                    col_a1, col_a2 = st.columns([1, 1])
+                    enviar = col_a1.form_submit_button("📤 Enviar resposta")
+                    pendenciar = col_a2.form_submit_button("⏳ Marcar como pendente")
+
+                    if enviar:
+                        try:
+                            s.resposta = (resposta_txt or "").strip()
+                            s.status = STATUS_RESPONDIDA if s.resposta else STATUS_PENDENTE
+                            s.data_resposta = datetime.now() if s.resposta else None
+                            s.responsavel = st.session_state.get("usuario")
+
+                            db.add(s)
+                            db.commit()
+
+                            # Auditoria (opcional)
+                            if registrar_log and s.resposta:
+                                try:
+                                    registrar_log(
+                                        usuario=st.session_state.get("usuario"),
+                                        acao=f"Respondeu sugestão IOI‑RUN (ID {s.id}) para {s.usuario}",
+                                        tabela="ioirun_sugestao",
+                                        registro_id=s.id
+                                    )
+                                except Exception:
+                                    pass
+
+                            st.success("Resposta registrada com sucesso! (Agora em 'respondida')")
+                            st.rerun()
+                        except Exception as e:
+                            db.rollback()
+                            st.error(f"Erro ao salvar resposta: {e}")
+
+                    if pendenciar:
+                        try:
+                            s.status = STATUS_PENDENTE
+                            s.resposta = None
+                            s.data_resposta = None
+                            s.responsavel = None
+                            db.add(s)
+                            db.commit()
+                            st.info("Sugestão marcada como pendente novamente.")
+                            st.rerun()
+                        except Exception as e:
+                            db.rollback()
+                            st.error(f"Erro ao alterar status: {e}")
+
+    st.markdown("---")
+    st.caption("Use o **menu lateral** para navegar para outros módulos.")
+
+    try:
+        db.close()
+    except Exception:
+        pass
+
+
+if __name__ == "__main__":
+    main()

Info.txt

@@ -0,0 +1,20 @@
+LoadApp/
+│
+├── app.py                 # Arquivo principal
+├── login.py               # Login
+├── administracao.py       # Área admin
+├── formulario.py          # Inclusão
+├── consulta.py            # Consulta
+├── relatorios.py          # Relatórios
+│
+├── banco.py               # Conexão com banco
+├── models.py              # Modelos SQLAlchemy
+├── utils_fpso.py
+├── utils_permissoes.py
+│
+├── assets/
+│   └── logo.png           # Logo do sistema
+│
+├── requirements.txt
+├── .gitignore
+└── README.md

Load.db

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

Load.db.bak

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

Produtividade_Especialista.py

@@ -0,0 +1,778 @@
+
+# -*- coding: utf-8 -*-
+import streamlit as st
+import pandas as pd
+from io import BytesIO
+from banco import SessionLocal
+from models import Equipamento
+
+# Auto-refresh
+from streamlit_autorefresh import st_autorefresh
+from datetime import datetime, timedelta
+
+# SQL util
+from sqlalchemy import text
+
+# ====== Gráficos: Altair (preferência) + fallback Matplotlib ======
+ALT_AVAILABLE = True
+try:
+    import altair as alt
+    try:
+        alt.data_transformers.disable_max_rows()
+    except Exception:
+        pass
+except Exception:
+    ALT_AVAILABLE = False
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+# NumPy para cálculos numéricos robustos
+import numpy as np
+
+
+# ===============================
+# Fotos de Responsáveis — Helpers (DB)
+# ===============================
+def _ensure_foto_table(db) -> None:
+    """Cria a tabela responsavel_foto se não existir (SQLite/PostgreSQL/MySQL)."""
+    dialect = db.bind.dialect.name
+
+    if dialect == "sqlite":
+        sql = """
+        CREATE TABLE IF NOT EXISTS responsavel_foto (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            tipo TEXT NOT NULL,              -- 'especialista' | 'conferente'
+            nome TEXT NOT NULL,
+            imagem BLOB NOT NULL,            -- bytes
+            mimetype TEXT,
+            updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+            UNIQUE (tipo, nome)
+        )
+        """
+    elif dialect in ("postgresql", "postgres"):
+        sql = """
+        CREATE TABLE IF NOT EXISTS responsavel_foto (
+            id SERIAL PRIMARY KEY,
+            tipo TEXT NOT NULL,              -- 'especialista' | 'conferente'
+            nome TEXT NOT NULL,
+            imagem BYTEA NOT NULL,           -- bytes
+            mimetype TEXT,
+            updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+            UNIQUE (tipo, nome)
+        )
+        """
+    else:  # mysql/mariadb
+        sql = """
+        CREATE TABLE IF NOT EXISTS responsavel_foto (
+            id INT AUTO_INCREMENT PRIMARY KEY,
+            tipo VARCHAR(32) NOT NULL,
+            nome VARCHAR(255) NOT NULL,
+            imagem LONGBLOB NOT NULL,
+            mimetype VARCHAR(64),
+            updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+            UNIQUE KEY uq_tipo_nome (tipo, nome)
+        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
+        """
+    db.execute(text(sql))
+    db.commit()
+
+
+def _get_foto(db, tipo: str, nome: str):
+    """Retorna (bytes_imagem, mimetype, updated_at) ou (None, None, None)."""
+    if not (tipo and nome):
+        return None, None, None
+    _ensure_foto_table(db)
+    row = db.execute(
+        text(
+            "SELECT imagem, mimetype, updated_at "
+            "FROM responsavel_foto WHERE tipo = :t AND nome = :n LIMIT 1"
+        ),
+        {"t": tipo, "n": nome},
+    ).fetchone()
+    if row:
+        return row[0], (row[1] or "image/jpeg"), row[2]
+    return None, None, None
+
+
+def _set_foto(db, tipo: str, nome: str, content: bytes, mimetype: str) -> None:
+    """Upsert simples por (tipo, nome)."""
+    if not (tipo and nome and content):
+        return
+    _ensure_foto_table(db)
+    upd = db.execute(
+        text(
+            "UPDATE responsavel_foto "
+            "SET imagem=:img, mimetype=:mt, updated_at=CURRENT_TIMESTAMP "
+            "WHERE tipo=:t AND nome=:n"
+        ),
+        {"img": content, "mt": mimetype or "image/jpeg", "t": tipo, "n": nome},
+    )
+    if upd.rowcount == 0:
+        db.execute(
+            text(
+                "INSERT INTO responsavel_foto (tipo, nome, imagem, mimetype) "
+                "VALUES (:t, :n, :img, :mt)"
+            ),
+            {"t": tipo, "n": nome, "img": content, "mt": mimetype or "image/jpeg"},
+        )
+    db.commit()
+
+
+def _del_foto(db, tipo: str, nome: str) -> None:
+    if not (tipo and nome):
+        return
+    _ensure_foto_table(db)
+    db.execute(text("DELETE FROM responsavel_foto WHERE tipo=:t AND nome=:n"), {"t": tipo, "n": nome})
+    db.commit()
+
+
+# ===============================
+# Estado
+# ===============================
+def limpar_estado_prod_esp():
+    """Remove do session_state qualquer dado do módulo Produtividade_Especialista."""
+    for key in list(st.session_state.keys()):
+        if key.startswith("prod_esp_"):
+            del st.session_state[key]
+
+
+# ===============================
+# UI – Gerenciar fotos de responsáveis
+# ===============================
+def _ui_fotos_responsaveis(df: pd.DataFrame):
+    """Bloco para cadastrar/atualizar/remover fotos de Especialistas e Conferentes."""
+    st.subheader("📸 Fotos dos Responsáveis")
+
+    especialistas = sorted([x for x in df["Especialista"].dropna().astype(str).unique() if x.strip()])
+    conferentes   = sorted([x for x in df["Conferente"].dropna().astype(str).unique() if x.strip()])
+
+    tab_esp, tab_conf = st.tabs(["Especialista", "Conferente"])
+
+    # ---------- Especialista ----------
+    with tab_esp:
+        col_e1, col_e2 = st.columns([1, 2])
+        with col_e1:
+            nome_esp = st.selectbox("Especialista", options=["(selecione)"] + especialistas, index=0, key="prod_esp_foto_esp_sel")
+            file_esp = st.file_uploader(
+                "Carregar foto (PNG/JPG/JPEG/GIF/WEBP) — Especialista",
+                type=["png", "jpg", "jpeg", "gif", "webp"],
+                key="prod_esp_foto_esp_up"
+            )
+            salvar_esp = st.button("💾 Salvar/Atualizar foto (Especialista)", key="prod_esp_foto_esp_salvar")
+            remover_esp = st.button("🗑️ Remover foto (Especialista)", key="prod_esp_foto_esp_remover")
+
+        with col_e2:
+            db = SessionLocal()
+            try:
+                if nome_esp and nome_esp != "(selecione)":
+                    img_bytes, mt, updt = _get_foto(db, "especialista", nome_esp)
+                    if img_bytes:
+                        st.caption(f"Foto atual de **{nome_esp}** (atualizada em {updt})")
+                        st.image(img_bytes, caption=nome_esp, use_container_width=False, width=220)
+                    else:
+                        st.info("Nenhuma foto cadastrada para este Especialista.")
+            finally:
+                db.close()
+
+        if salvar_esp:
+            if not (nome_esp and nome_esp != "(selecione)"):
+                st.warning("Selecione um Especialista.")
+            elif not file_esp:
+                st.warning("Escolha um arquivo de imagem para enviar.")
+            else:
+                content = file_esp.read()
+                mt = file_esp.type or "image/jpeg"
+                db = SessionLocal()
+                try:
+                    _set_foto(db, "especialista", nome_esp, content, mt)
+                    st.success("Foto salva/atualizada com sucesso!")
+                    st.rerun()
+                except Exception as e:
+                    db.rollback()
+                    st.error(f"Erro ao salvar foto: {e}")
+                finally:
+                    db.close()
+
+        if remover_esp:
+            if not (nome_esp and nome_esp != "(selecione)"):
+                st.warning("Selecione um Especialista.")
+            else:
+                db = SessionLocal()
+                try:
+                    _del_foto(db, "especialista", nome_esp)
+                    st.info("Foto removida.")
+                    st.rerun()
+                except Exception as e:
+                    db.rollback()
+                    st.error(f"Erro ao remover foto: {e}")
+                finally:
+                    db.close()
+
+    # ---------- Conferente ----------
+    with tab_conf:
+        col_c1, col_c2 = st.columns([1, 2])
+        with col_c1:
+            nome_conf = st.selectbox("Conferente", options=["(selecione)"] + conferentes, index=0, key="prod_esp_foto_conf_sel")
+            file_conf = st.file_uploader(
+                "Carregar foto (PNG/JPG/JPEG/GIF/WEBP) — Conferente",
+                type=["png", "jpg", "jpeg", "gif", "webp"],
+                key="prod_esp_foto_conf_up"
+            )
+            salvar_conf = st.button("💾 Salvar/Atualizar foto (Conferente)", key="prod_esp_foto_conf_salvar")
+            remover_conf = st.button("🗑️ Remover foto (Conferente)", key="prod_esp_foto_conf_remover")
+
+        with col_c2:
+            db = SessionLocal()
+            try:
+                if nome_conf and nome_conf != "(selecione)":
+                    img_bytes, mt, updt = _get_foto(db, "conferente", nome_conf)
+                    if img_bytes:
+                        st.caption(f"Foto atual de **{nome_conf}** (atualizada em {updt})")
+                        st.image(img_bytes, caption=nome_conf, use_container_width=False, width=220)
+                    else:
+                        st.info("Nenhuma foto cadastrada para este Conferente.")
+            finally:
+                db.close()
+
+        if salvar_conf:
+            if not (nome_conf and nome_conf != "(selecione)"):
+                st.warning("Selecione um Conferente.")
+            elif not file_conf:
+                st.warning("Escolha um arquivo de imagem para enviar.")
+            else:
+                content = file_conf.read()
+                mt = file_conf.type or "image/jpeg"
+                db = SessionLocal()
+                try:
+                    _set_foto(db, "conferente", nome_conf, content, mt)
+                    st.success("Foto salva/atualizada com sucesso!")
+                    st.rerun()
+                except Exception as e:
+                    db.rollback()
+                    st.error(f"Erro ao salvar foto: {e}")
+                finally:
+                    db.close()
+
+        if remover_conf:
+            if not (nome_conf and nome_conf != "(selecione)"):
+                st.warning("Selecione um Conferente.")
+            else:
+                db = SessionLocal()
+                try:
+                    _del_foto(db, "conferente", nome_conf)
+                    st.info("Foto removida.")
+                    st.rerun()
+                except Exception as e:
+                    db.rollback()
+                    st.error(f"Erro ao remover foto: {e}")
+                finally:
+                    db.close()
+
+
+# ===============================
+# Mini-gráfico mensal (% acertos) — Helpers
+# ===============================
+def _normalize_responsaveis(df: pd.DataFrame) -> pd.DataFrame:
+    """Normaliza nomes (remove espaços/None) para evitar falhas de comparação."""
+    for col in ["Especialista", "Conferente"]:
+        df[col] = df[col].astype(str).fillna("").str.strip()
+        df[col] = df[col].replace({"None": ""})
+    return df
+
+def _month_labels_last_n(n: int) -> pd.DataFrame:
+    """Retorna DataFrame com os últimos n meses e rótulos MES/AA, em ordem cronológica."""
+    base = pd.Timestamp(datetime.now().replace(day=1))
+    months = [base - pd.DateOffset(months=i) for i in range(n-1, -1, -1)]
+    return pd.DataFrame({
+        "YM": [pd.Period(m, freq="M") for m in months],
+        "mes": [m.strftime("%b/%y").upper() for m in months]
+    })
+
+def _serie_pct_mensal(df: pd.DataFrame, resp_col: str, nome: str, months: int = 6) -> pd.DataFrame:
+    """
+    Série mensal (últimos 'months' meses) de % acertos (MROB) para um responsável.
+    Retorna DataFrame com ['mes', 'pct', 'MROB', 'ERROS'] (meses sem dados => 0).
+    Corrige dtype para evitar TypeError: Expected numeric dtype, got object instead.
+    """
+    if not (nome and resp_col in df.columns and "Data Coleta (dt)" in df.columns):
+        return pd.DataFrame(columns=["mes", "pct", "MROB", "ERROS"])
+
+    nome = str(nome).strip()
+    d = df[df[resp_col].astype(str).str.strip() == nome].copy()
+    d = d.dropna(subset=["Data Coleta (dt)"])
+
+    # Linha do tempo alvo (sempre haverá N meses)
+    base = _month_labels_last_n(months)
+
+    # Se não há dados, devolve zeros
+    if d.empty:
+        base["MROB"] = 0.0
+        base["ERROS"] = 0.0
+        base["pct"] = 0.0
+        return base[["mes", "pct", "MROB", "ERROS"]]
+
+    d["YM"] = d["Data Coleta (dt)"].dt.to_period("M")
+
+    g = (
+        d.groupby("YM", as_index=False)
+         .agg(MROB=("Linhas MROB", "sum"), ERROS=("Linhas Erros MROB", "sum"))
+    )
+
+    # Merge garante a linha do tempo completa — aqui o dtype pode virar 'object'
+    m = base.merge(g, on="YM", how="left")
+
+    # Coerção numérica robusta pós-merge (evita object -> round error)
+    m["MROB"] = pd.to_numeric(m["MROB"], errors="coerce").fillna(0).astype("float64")
+    m["ERROS"] = pd.to_numeric(m["ERROS"], errors="coerce").fillna(0).astype("float64")
+
+    # % acertos (evita divisão por zero, resultado sempre float)
+    m["pct"] = np.where(
+        m["MROB"] > 0,
+        ((m["MROB"] - m["ERROS"]) / m["MROB"]) * 100.0,
+        0.0
+    )
+    m["pct"] = pd.to_numeric(m["pct"], errors="coerce").fillna(0).astype("float64").round(2)
+
+    # Seleciona e ordena colunas finais
+    out = m[["mes", "pct", "MROB", "ERROS"]].copy()
+
+    # Garantia de dtype correto (evita regressões futuras)
+    out["MROB"] = out["MROB"].astype("float64")
+    out["ERROS"] = out["ERROS"].astype("float64")
+    out["pct"]  = out["pct"].astype("float64")
+
+    return out
+
+def _mini_grafico_pct_mensal(df_m: pd.DataFrame, meta: float, chart_type: str = "Linha", show_meta: bool = True, titulo: str = "% Acertos por mês"):
+    """
+    Renderiza mini‑gráfico compacto (% acertos | 0–100) com fallback:
+      1) Altair (linha/barras + meta)  2) Matplotlib  3) Tabela
+    """
+    if df_m.empty:
+        st.caption("Sem dados mensais para o período/seleção atual.")
+        return
+
+    # 1) ALTair
+    if ALT_AVAILABLE:
+        try:
+            base = alt.Chart(df_m).encode(
+                x=alt.X("mes:N", title="Mês"),
+                y=alt.Y("pct:Q", title="% Acertos", scale=alt.Scale(domain=[0, 100])),
+                tooltip=[
+                    alt.Tooltip("mes:N", title="Mês"),
+                    alt.Tooltip("pct:Q", title="% Acertos (%)"),
+                    alt.Tooltip("MROB:Q", title="MROB (Σ)"),
+                    alt.Tooltip("ERROS:Q", title="Erros MROB (Σ)")
+                ]
+            )
+            chart = base.mark_line(point=True, interpolate="monotone", color="#0d6efd") if chart_type == "Linha" \
+                    else base.mark_bar(size=18, color="#0d6efd")
+
+            final = chart.properties(width=260, height=150, title=titulo)
+
+            if show_meta:
+                meta_df = pd.DataFrame({"y": [meta]})
+                meta_rule = alt.Chart(meta_df).mark_rule(color="#16a34a", strokeDash=[6, 4]).encode(y="y:Q")
+                final = final + meta_rule
+
+            st.altair_chart(final, use_container_width=False)
+            return
+        except Exception as e:
+            st.info(f"Render ALTair indisponível, usando fallback (detalhe: {e})")
+
+    # 2) Matplotlib fallback
+    try:
+        fig, ax = plt.subplots(figsize=(3.2, 1.6), dpi=150)
+        x = list(range(len(df_m["mes"])))
+        if chart_type == "Linha":
+            ax.plot(x, df_m["pct"].values, marker="o", color="#0d6efd", linewidth=1.5)
+        else:
+            ax.bar(x, df_m["pct"].values, color="#0d6efd", width=0.6)
+        if show_meta:
+            ax.axhline(y=meta, color="#16a34a", linestyle="--", linewidth=1)
+
+        ax.set_ylim(0, 100)
+        ax.set_xticks(x)
+        ax.set_xticklabels(df_m["mes"].tolist(), rotation=0, fontsize=7)
+        ax.set_yticks([0, 20, 40, 60, 80, 100])
+        ax.set_title(titulo, fontsize=9)
+        ax.grid(alpha=0.15, axis="y")
+
+        plt.tight_layout()
+        st.pyplot(fig, use_container_width=False)
+        plt.close(fig)
+        return
+    except Exception as e:
+        st.warning(f"Não foi possível renderizar o mini‑gráfico (fallback MPL): {e}")
+
+    # 3) Último recurso
+    st.caption("Exibindo dados da série por impossibilidade de gráfico:")
+    st.dataframe(df_m, use_container_width=True)
+
+
+# ===============================
+# MAIN
+# ===============================
+def main():
+
+    # 🧹 LIMPA ESTADO AO ENTRAR
+    if not st.session_state.get("_prod_esp_inicializado"):
+        limpar_estado_prod_esp()
+        st.session_state["_prod_esp_inicializado"] = True
+
+    st.title("🏆 Produtividade por Especialista e Conferente")
+
+    # 🔧 CONTROLES NA SIDEBAR
+    with st.sidebar:
+        st.markdown("### 🔄 Atualização automática")
+        auto_on = st.checkbox("Ativar atualização automática", value=True, key="prod_esp_auto_on")
+        auto_interval_s = st.slider("Intervalo (segundos)", min_value=10, max_value=300, value=30, step=5, key="prod_esp_auto_int")
+
+        if "prod_esp_auto_int_effective" not in st.session_state:
+            st.session_state["prod_esp_auto_int_effective"] = auto_interval_s
+
+        if st.button("✅ Aplicar intervalo"):
+            st.session_state["prod_esp_auto_int_effective"] = auto_interval_s
+            st.success(f"Intervalo atualizado para {auto_interval_s}s")
+            st.rerun()
+
+        intervalo_efetivo = st.session_state.get("prod_esp_auto_int_effective", auto_interval_s)
+        st.caption(f"⏲️ Intervalo atual: **{intervalo_efetivo}s**")
+
+        st.markdown("---")
+        st.markdown("### 🎯 Metas e Série")
+        meta_pct_especialistas = st.number_input("Meta (% MROB/Geral) — Especialistas", min_value=0.0, max_value=100.0, value=98.8, step=0.5, key="prod_esp_meta_pct_esp")
+        meta_pct_conferentes  = st.number_input("Meta (% MROB/Geral) — Conferentes",  min_value=0.0, max_value=100.0, value=98.8, step=0.5, key="prod_esp_meta_pct_conf")
+        serie_meses           = st.slider("Meses no mini‑gráfico", min_value=3, max_value=12, value=6, step=1, key="prod_esp_serie_meses")
+        tipo_grafico          = st.selectbox("Tipo do mini‑gráfico", ["Linha", "Barras"], index=0, key="prod_esp_tipo_grafico")
+        linha_meta            = st.checkbox("Mostrar linha de meta", value=True, key="prod_esp_show_meta")
+
+        st.markdown("---")
+        last_dt = st.session_state.get("prod_esp_last_update_dt")
+        if last_dt:
+            last_str = last_dt.strftime("%d/%m/%Y %H:%M:%S")
+            st.caption(f"🕒 Última atualização: **{last_str}**")
+            delta = datetime.now() - last_dt
+            if delta < timedelta(minutes=1):
+                ago_str = f"{delta.seconds}s"
+            elif delta < timedelta(hours=1):
+                mins = delta.seconds // 60
+                secs = delta.seconds % 60
+                ago_str = f"{mins}min {secs}s"
+            else:
+                hours = delta.seconds // 3600
+                mins = (delta.seconds % 3600) // 60
+                ago_str = f"{hours}h {mins}min"
+            st.caption(f"⏱️ Atualizado há **{ago_str}**")
+            if auto_on:
+                try:
+                    nxt = (datetime.now() + timedelta(seconds=intervalo_efetivo)).strftime("%d/%m/%Y %H:%M:%S")
+                    st.caption(f"🔁 Próximo refresh: **{nxt}**")
+                except Exception:
+                    pass
+        else:
+            st.caption("🕒 Última atualização: **—**")
+
+    if auto_on:
+        st_autorefresh(interval=intervalo_efetivo * 1000, limit=None, key="prod_esp_autorefresh")
+
+    db = SessionLocal()
+    try:
+        registros = db.query(Equipamento).all()
+        st.session_state["prod_esp_last_update_dt"] = datetime.now()
+
+        if not registros:
+            st.info("Nenhum registro encontrado.")
+            return
+
+        # ========== BASE DF ==========
+        df = pd.DataFrame([{
+            "FPSO": getattr(r, "fpso", None),
+            "Data Coleta": getattr(r, "data_coleta", None),
+            "Modal": getattr(r, "modal", None),
+            "Especialista": getattr(r, "especialista", None),
+            "Conferente": getattr(r, "conferente", None),
+            "Linhas OSM": getattr(r, "linhas_osm", 0),
+            "Linhas MROB": getattr(r, "linhas_mrob", 0),
+            "Linhas Erros MROB": getattr(r, "linhas_erros_mrob", None),
+            "Linhas Erros (Genérico)": getattr(r, "linhas_erros", None),
+        } for r in registros])
+
+        # Conversão robusta de datas
+        df["Data Coleta (dt)"] = pd.to_datetime(df["Data Coleta"], errors="coerce", dayfirst=True)
+        if df["Data Coleta (dt)"].isna().all():
+            # tenta novamente sem dayfirst
+            df["Data Coleta (dt)"] = pd.to_datetime(df["Data Coleta"], errors="coerce", dayfirst=False)
+
+        # Tipos numéricos
+        for col in ["Linhas OSM", "Linhas MROB", "Linhas Erros MROB", "Linhas Erros (Genérico)"]:
+            if col in df.columns:
+                df[col] = pd.to_numeric(df[col], errors="coerce").fillna(0).astype("int64")
+
+        # Fallback de erros MROB
+        if ("Linhas Erros MROB" not in df.columns) or (df["Linhas Erros MROB"].sum() == 0 and df["Linhas Erros (Genérico)"].sum() > 0):
+            df["Linhas Erros MROB"] = df.get("Linhas Erros (Genérico)", pd.Series([0] * len(df)))
+
+        # Normaliza nomes
+        df = _normalize_responsaveis(df)
+
+        # ======== Fotos (cadastro/visualização) ========
+        _ui_fotos_responsaveis(df)
+
+        # ========== FILTROS ==========
+        st.subheader("🔎 Filtros")
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            filtro_fpso = st.multiselect("FPSO", sorted(df["FPSO"].dropna().unique()), key="prod_esp_fpso")
+        with col2:
+            filtro_modal = st.multiselect("Modal", sorted(df["Modal"].dropna().unique()), key="prod_esp_modal")
+        with col3:
+            periodo = st.date_input("Período de Coleta", value=None, key="prod_esp_periodo")
+
+        df_filt = df.copy()
+        if filtro_fpso:
+            df_filt = df_filt[df_filt["FPSO"].isin(filtro_fpso)]
+        if filtro_modal:
+            df_filt = df_filt[df_filt["Modal"].isin(filtro_modal)]
+        if isinstance(periodo, (list, tuple)) and len(periodo) == 2:
+            data_inicio, data_fim = periodo
+            if pd.notna(data_inicio):
+                df_filt = df_filt[df_filt["Data Coleta (dt)"] >= pd.to_datetime(data_inicio)]
+            if pd.notna(data_fim):
+                df_filt = df_filt[df_filt["Data Coleta (dt)"] <= pd.to_datetime(data_fim) + pd.Timedelta(days=1) - pd.Timedelta(seconds=1)]
+
+        # ======== Mapeamentos por responsável ========
+        fpsos_por_especialista = (
+            df_filt.groupby("Especialista", dropna=False)["FPSO"]
+                  .apply(lambda x: ", ".join(sorted(set(x.dropna()))))
+                  .to_dict()
+        )
+        fpsos_por_conferente = (
+            df_filt.groupby("Conferente", dropna=False)["FPSO"]
+                  .apply(lambda x: ", ".join(sorted(set(x.dropna()))))
+                  .to_dict()
+        )
+
+        # ======== Agregações ========
+        grp_esp = (df_filt.groupby("Especialista", dropna=False)
+                         .agg({"Linhas OSM":"sum","Linhas MROB":"sum","Linhas Erros MROB":"sum"})
+                         .reset_index())
+        grp_esp["FPSO Responsável"] = grp_esp["Especialista"].map(lambda e: fpsos_por_especialista.get(e, ""))
+        grp_esp["Especialista (FPSO)"] = grp_esp.apply(
+            lambda r: f"{r['Especialista']} ({r['FPSO Responsável']})" if r["FPSO Responsável"] else str(r["Especialista"]), axis=1)
+        grp_esp["Total de Erros (MROB - Erros MROB)"] = (grp_esp["Linhas MROB"] - grp_esp["Linhas Erros MROB"]).clip(lower=0)
+
+        # ✅ Denominador numérico (float) para evitar dtype object
+        denom_mrob_esp = pd.to_numeric(grp_esp["Linhas MROB"], errors="coerce").replace(0, np.nan).astype("float64")
+        num_acertos_esp = pd.to_numeric(grp_esp["Linhas MROB"], errors="coerce") - pd.to_numeric(grp_esp["Linhas Erros MROB"], errors="coerce")
+        num_erros_esp   = pd.to_numeric(grp_esp["Linhas Erros MROB"], errors="coerce")
+
+        grp_esp["% Acertos (MROB)"] = (num_acertos_esp / denom_mrob_esp * 100.0).round(2)
+        grp_esp["% Erros (MROB)"]   = (num_erros_esp   / denom_mrob_esp * 100.0).round(2)
+
+        grp_esp = grp_esp.sort_values(by="Linhas OSM", ascending=False)
+        grp_esp = grp_esp[[
+            "Especialista (FPSO)","Especialista","FPSO Responsável",
+            "Linhas OSM","Linhas MROB","Linhas Erros MROB",
+            "Total de Erros (MROB - Erros MROB)","% Acertos (MROB)","% Erros (MROB)"
+        ]]
+
+        grp_conf = (df_filt.groupby("Conferente", dropna=False)
+                         .agg({"Linhas OSM":"sum","Linhas MROB":"sum","Linhas Erros MROB":"sum"})
+                         .reset_index())
+        grp_conf["FPSO Responsável"] = grp_conf["Conferente"].map(lambda c: fpsos_por_conferente.get(c, ""))
+        grp_conf["Conferente (FPSO)"] = grp_conf.apply(
+            lambda r: f"{r['Conferente']} ({r['FPSO Responsável']})" if r["FPSO Responsável"] else str(r["Conferente"]), axis=1)
+        grp_conf["Total de Erros (MROB - Erros MROB)"] = (grp_conf["Linhas MROB"] - grp_conf["Linhas Erros MROB"]).clip(lower=0)
+
+        # ✅ Denominador numérico (float) para evitar dtype object
+        denom_mrob_conf = pd.to_numeric(grp_conf["Linhas MROB"], errors="coerce").replace(0, np.nan).astype("float64")
+        num_acertos_conf = pd.to_numeric(grp_conf["Linhas MROB"], errors="coerce") - pd.to_numeric(grp_conf["Linhas Erros MROB"], errors="coerce")
+        num_erros_conf   = pd.to_numeric(grp_conf["Linhas Erros MROB"], errors="coerce")
+
+        grp_conf["% Acertos (MROB)"] = (num_acertos_conf / denom_mrob_conf * 100.0).round(2)
+        grp_conf["% Erros (MROB)"]   = (num_erros_conf   / denom_mrob_conf * 100.0).round(2)
+
+        grp_conf = grp_conf.sort_values(by="Linhas OSM", ascending=False)
+        grp_conf = grp_conf[[
+            "Conferente (FPSO)","Conferente","FPSO Responsável",
+            "Linhas OSM","Linhas MROB","Linhas Erros MROB",
+            "Total de Erros (MROB - Erros MROB)","% Acertos (MROB)","% Erros (MROB)"
+        ]]
+
+        # ======== KPIs Gerais ========
+        st.subheader("📈 KPIs (dados filtrados) — Geral (Todos)")
+        total_especialistas = grp_esp["Especialista"].nunique()
+        total_conferentes  = grp_conf["Conferente"].nunique()
+        total_osm_geral = int(df_filt["Linhas OSM"].sum())
+        total_mrob_geral = int(df_filt["Linhas MROB"].sum())
+        total_erros_mrob_geral = int(df_filt["Linhas Erros MROB"].sum())
+        total_acertos_mrob_geral = (total_mrob_geral - total_erros_mrob_geral)
+        pct_acertos_geral = round((total_acertos_mrob_geral / total_mrob_geral * 100), 2) if total_mrob_geral > 0 else 0.0
+        pct_erros_geral   = round((total_erros_mrob_geral   / total_mrob_geral * 100), 2) if total_mrob_geral   > 0 else 0.0
+
+        k1,k2,k3,k4,k5 = st.columns(5)
+        k1.metric("Especialistas", f"{total_especialistas}")
+        k2.metric("Conferentes", f"{total_conferentes}")
+        k3.metric("Linhas OSM (Σ)", f"{total_osm_geral:,}".replace(",", "."))
+        k4.metric("Linhas MROB (Σ)", f"{total_mrob_geral:,}".replace(",", "."))
+        color_geral = "#198754" if pct_acertos_geral >= meta_pct_especialistas else "#dc3545"
+        k5.metric("% Acertos (MROB/Geral)", f"{pct_acertos_geral}%")
+        # 🔧 HTML deve usar <span>...<span>, não entidades &lt;&gt;
+        st.markdown(
+            f"<span style='color:{color_geral}'>Meta (Especialistas): {meta_pct_especialistas}% • "
+            f"{'✅ Dentro da meta' if pct_acertos_geral >= meta_pct_especialistas else '⚠️ Abaixo da meta'}</span>",
+            unsafe_allow_html=True
+        )
+        st.markdown(f"<span style='color:#dc3545'>% Erros (MROB/Geral): {pct_erros_geral}%</span>", unsafe_allow_html=True)
+        st.divider()
+
+        # ======== KPIs por Especialista (foto + mini‑gráfico) ========
+        st.subheader("🎯 KPIs por Especialista")
+        especialistas_lista = ["(selecione)"] + list(grp_esp["Especialista"].astype(str).unique())
+        esp_sel = st.selectbox("Especialista:", especialistas_lista, index=0, key="prod_esp_kpi_esp")
+
+        if esp_sel and esp_sel != "(selecione)":
+            linha_esp = grp_esp[grp_esp["Especialista"] == esp_sel]
+            if not linha_esp.empty:
+                le_osm = int(linha_esp["Linhas OSM"].iloc[0])
+                le_mrob = int(linha_esp["Linhas MROB"].iloc[0])
+                le_err_mrob = int(linha_esp["Linhas Erros MROB"].iloc[0])
+                le_total_err = int(linha_esp["Total de Erros (MROB - Erros MROB)"].iloc[0])
+                le_pct_acertos = float(linha_esp["% Acertos (MROB)"].iloc[0]) if pd.notna(linha_esp["% Acertos (MROB)"].iloc[0]) else 0.0
+                le_pct_erros   = float(linha_esp["% Erros (MROB)"].iloc[0]) if pd.notna(linha_esp["% Erros (MROB)"].iloc[0]) else 0.0
+
+                col_pic, col_chart, col_metrics = st.columns([1, 1.4, 3])
+                with col_pic:
+                    dbp = SessionLocal()
+                    try:
+                        img_b, mt, updt = _get_foto(dbp, "especialista", esp_sel)
+                        if img_b:
+                            st.image(img_b, caption=f"{esp_sel}", use_container_width=False, width=220)
+                        else:
+                            st.caption("Sem foto cadastrada.")
+                    finally:
+                        dbp.close()
+                with col_chart:
+                    serie = _serie_pct_mensal(df_filt, "Especialista", esp_sel, months=serie_meses)
+                    _mini_grafico_pct_mensal(serie, meta=meta_pct_especialistas, chart_type=tipo_grafico, show_meta=linha_meta)
+                    with st.expander("🔧 Diagnóstico da série (Especialista)", expanded=False):
+                        st.dataframe(serie, use_container_width=True)
+                with col_metrics:
+                    s1,s2,s3,s4,s5 = st.columns(5)
+                    s1.metric("Linhas OSM", f"{le_osm:,}".replace(",", "."))
+                    s2.metric("Linhas MROB", f"{le_mrob:,}".replace(",", "."))
+                    s3.metric("Erros MROB", f"{le_err_mrob:,}".replace(",", "."))
+                    s4.metric("Total Erros (MROB−Erros)", f"{le_total_err:,}".replace(",", "."))
+                    s5.metric("% Acertos (MROB)", f"{le_pct_acertos}%")
+                    # 🔧 HTML deve usar <span>...<span>, não entidades &lt;&gt;
+                    st.markdown(f"<span style='color:#dc3545'>% Erros (MROB): {le_pct_erros}%</span>", unsafe_allow_html=True)
+        st.divider()
+
+        # ======== KPIs por Conferente (foto + mini‑gráfico) ========
+        st.subheader("🎯 KPIs por Conferente")
+        conferentes_lista = ["(selecione)"] + list(grp_conf["Conferente"].astype(str).unique())
+        conf_sel = st.selectbox("Conferente:", conferentes_lista, index=0, key="prod_esp_kpi_conf")
+
+        if conf_sel and conf_sel != "(selecione)":
+            linha_conf = grp_conf[grp_conf["Conferente"] == conf_sel]
+            if not linha_conf.empty:
+                lc_osm = int(linha_conf["Linhas OSM"].iloc[0])
+                lc_mrob = int(linha_conf["Linhas MROB"].iloc[0])
+                lc_err_mrob = int(linha_conf["Linhas Erros MROB"].iloc[0])
+                lc_total_err = int(linha_conf["Total de Erros (MROB - Erros MROB)"].iloc[0])
+                lc_pct_acertos = float(linha_conf["% Acertos (MROB)"].iloc[0]) if pd.notna(linha_conf["% Acertos (MROB)"].iloc[0]) else 0.0
+                lc_pct_erros   = float(linha_conf["% Erros (MROB)"].iloc[0]) if pd.notna(linha_conf["% Erros (MROB)"].iloc[0]) else 0.0
+
+                col_pic2, col_chart2, col_metrics2 = st.columns([1, 1.4, 3])
+                with col_pic2:
+                    dbp = SessionLocal()
+                    try:
+                        img_b, mt, updt = _get_foto(dbp, "conferente", conf_sel)
+                        if img_b:
+                            st.image(img_b, caption=f"{conf_sel}", use_container_width=False, width=220)
+                        else:
+                            st.caption("Sem foto cadastrada.")
+                    finally:
+                        dbp.close()
+                with col_chart2:
+                    serie2 = _serie_pct_mensal(df_filt, "Conferente", conf_sel, months=serie_meses)
+                    _mini_grafico_pct_mensal(serie2, meta=meta_pct_conferentes, chart_type=tipo_grafico, show_meta=linha_meta)
+                    with st.expander("🔧 Diagnóstico da série (Conferente)", expanded=False):
+                        st.dataframe(serie2, use_container_width=True)
+                with col_metrics2:
+                    d1,d2,d3,d4,d5 = st.columns(5)
+                    d1.metric("Linhas OSM", f"{lc_osm:,}".replace(",", "."))
+                    d2.metric("Linhas MROB", f"{lc_mrob:,}".replace(",", "."))
+                    d3.metric("Erros MROB", f"{lc_err_mrob:,}".replace(",", "."))
+                    d4.metric("Total Erros (MROB−Erros)", f"{lc_total_err:,}".replace(",", "."))
+                    d5.metric("% Acertos (MROB)", f"{lc_pct_acertos}%")
+                    # 🔧 HTML deve usar <span>...<span>, não entidades &lt;&gt;
+                    st.markdown(f"<span style='color:#dc3545'>% Erros (MROB): {lc_pct_erros}%</span>", unsafe_allow_html=True)
+
+        st.divider()
+
+        # ======== Listas e Gráficos maiores ========
+        st.subheader("🧾 Lista por Especialista (com métricas)")
+        st.dataframe(grp_esp, use_container_width=True)
+
+        st.subheader("🧾 Lista por Conferente (com métricas)")
+        st.dataframe(grp_conf, use_container_width=True)
+
+        st.subheader("📊 Gráficos")
+        try:
+            st.caption("Linhas OSM por Especialista (FPSO)")
+            st.bar_chart(data=grp_esp.set_index("Especialista (FPSO)")["Linhas OSM"])
+            st.caption("Linhas MROB por Especialista (FPSO)")
+            st.bar_chart(data=grp_esp.set_index("Especialista (FPSO)")["Linhas MROB"])
+            st.caption("Linhas de Erros MROB por Especialista (FPSO)")
+            st.bar_chart(data=grp_esp.set_index("Especialista (FPSO)")["Linhas Erros MROB"])
+            st.caption("Linhas OSM por Conferente (FPSO)")
+            st.bar_chart(data=grp_conf.set_index("Conferente (FPSO)")["Linhas OSM"])
+            st.caption("Linhas MROB por Conferente (FPSO)")
+            st.bar_chart(data=grp_conf.set_index("Conferente (FPSO)")["Linhas MROB"])
+            st.caption("Linhas de Erros MROB por Conferente (FPSO)")
+            st.bar_chart(data=grp_conf.set_index("Conferente (FPSO)")["Linhas Erros MROB"])
+        except Exception as e:
+            st.warning(f"Não foi possível renderizar alguns gráficos: {e}")
+
+        st.divider()
+
+        # ======== Exportação ========
+        st.subheader("⬇️ Exportar")
+        buffer_esp = BytesIO()
+        with pd.ExcelWriter(buffer_esp, engine="openpyxl") as writer:
+            grp_esp.to_excel(writer, index=False, sheet_name="Prod_Especialista")
+        buffer_esp.seek(0)
+        st.download_button(
+            label="⬇️ Exportar produtividade por Especialista (Excel)",
+            data=buffer_esp,
+            file_name="produtividade_especialista.xlsx",
+            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            key="prod_esp_export"
+        )
+
+        buffer_conf = BytesIO()
+        with pd.ExcelWriter(buffer_conf, engine="openpyxl") as writer:
+            grp_conf.to_excel(writer, index=False, sheet_name="Prod_Conferente")
+        buffer_conf.seek(0)
+        st.download_button(
+            label="⬇️ Exportar produtividade por Conferente (Excel)",
+            data=buffer_conf,
+            file_name="produtividade_conferente.xlsx",
+            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            key="prod_conf_export"
+        )
+
+    finally:
+        db.close()
+
+
+
+
+
+
+
+

add_pergunta.py

@@ -0,0 +1,129 @@
+from banco import SessionLocal
+from models import QuizPergunta, QuizResposta
+
+def adicionar_pergunta(pergunta_texto, respostas, correta_index):
+    db = SessionLocal()
+    try:
+        # Cria a pergunta
+        pergunta = QuizPergunta(pergunta=pergunta_texto)
+        db.add(pergunta)
+        db.commit()  # Gera o ID da pergunta para usar nas respostas
+        db.refresh(pergunta)  # Atualiza o objeto com o ID do banco
+
+        # Cria as respostas vinculadas à pergunta
+        for i, texto in enumerate(respostas):
+            resposta = QuizResposta(
+                pergunta_id=pergunta.id,
+                texto=texto,
+                correta=(i == correta_index)
+            )
+            db.add(resposta)
+
+        db.commit()
+        print(f"Pergunta '{pergunta_texto}' adicionada com sucesso.")
+    except Exception as e:
+        db.rollback()
+        print(f"Erro ao adicionar pergunta: {e}")
+    finally:
+        db.close()
+
+if __name__ == "__main__":
+    adicionar_pergunta(
+        "O que significa FPSO?",
+        [
+            "Floating Production Storage and Offloading",
+            "Fixed Production Storage Offshore",
+            "Floating Processing Supply Operation"
+        ],
+        0
+    )
+
+    adicionar_pergunta(
+        "Qual é a principal função de um FPSO?",
+        [
+            "Armazenar contêineres",
+            "Produzir, armazenar e transferir petróleo",
+            "Transporte de passageiros"
+        ],
+        1
+    )
+
+    adicionar_pergunta(
+        "Onde normalmente um FPSO opera?",
+        [
+            "Em portos comerciais",
+            "Em rios navegáveis",
+            "Em águas profundas e ultraprofundas"
+        ],
+        2
+    )
+
+    adicionar_pergunta(
+        "Qual produto NÃO é normalmente processado em um FPSO?",
+        [
+            "Petróleo",
+            "Gás natural",
+            "Carvão mineral"
+        ],
+        2
+    )
+
+    adicionar_pergunta(
+        "Qual etapa vem após a produção do petróleo em um FPSO?",
+        [
+            "Refino completo",
+            "Armazenamento e offloading",
+            "Transporte rodoviário"
+        ],
+        1
+    )
+
+    adicionar_pergunta(
+        "O que significa o termo 'offloading'?",
+        [
+            "Processo de perfuração",
+            "Transferência de petróleo para navios aliviadores",
+            "Separação de óleo e gás"
+        ],
+        1
+    )
+
+    adicionar_pergunta(
+        "Qual profissional é mais associado à operação diária de um FPSO?",
+        [
+            "Piloto de avião",
+            "Operador de produção offshore",
+            "Motorista de caminhão"
+        ],
+        1
+    )
+
+    adicionar_pergunta(
+        "Qual risco é mais comum em operações offshore?",
+        [
+            "Congestionamento urbano",
+            "Derramamento de óleo",
+            "Falta de energia elétrica urbana"
+        ],
+        1
+    )
+
+    adicionar_pergunta(
+        "Por que FPSOs são preferidos em campos distantes da costa?",
+        [
+            "Menor custo de construção",
+            "Dispensam oleodutos longos",
+            "Exigem menos tripulação"
+        ],
+        1
+    )
+
+    adicionar_pergunta(
+        "Qual é um requisito essencial de segurança em FPSOs?",
+        [
+            "Plano de evacuação e emergência",
+            "Seguro veicular",
+            "Licença rodoviária"
+        ],
+        0
+    )

administracao.py

@@ -0,0 +1,883 @@
+
+# -*- coding: utf-8 -*-
+import streamlit as st
+from datetime import datetime, date
+from banco import SessionLocal
+from models import Equipamento
+from log import registrar_log
+from utils_fpso import campo_fpso
+from utils_permissoes import verificar_permissao
+
+# 🔎 Utilitários SQLAlchemy para diagnóstico e migração simples
+from sqlalchemy import inspect, text
+
+# ⬇️ Import seguro do modelo AvisoGlobal (não quebra se ainda não existir)
+try:
+    from models import AvisoGlobal
+    _HAS_AVISO_GLOBAL = True
+except Exception:
+    _HAS_AVISO_GLOBAL = False
+
+# =====================================================
+# LISTAS FIXAS
+# =====================================================
+MODAL_LISTA = ["", "AÉREO", "MARÍTIMO", "EXPRESSO"]
+
+
+# =====================================================
+# MENU INFO (DOCUMENTAÇÃO INTERNA DO SISTEMA)
+# =====================================================
+def menu_info():
+
+    # ✅ Apêndice de documentação: novas funcionalidades e módulos (adicional)
+    doc_appendix()
+
+    st.info("📌 Documentação interna do sistema. Acesso restrito a administradores.")
+
+
+
+# =====================================================
+# APÊNDICE DE DOCUMENTAÇÃO (NOVAS FUNCIONALIDADES)
+# =====================================================
+def doc_appendix():
+    """
+    Adendo de documentação profissional que descreve
+    as novas funcionalidades, módulos e diretrizes sem
+    alterar o comportamento existente.
+    """
+    st.divider()
+    st.subheader("📘 Atualizações e Diretrizes Profissionais")
+
+    # ✅ NOVO: documentação padronizada do Módulo Formulário dentro do apêndice
+    with st.expander("🧾 Módulo Formulário (padrão)", expanded=False):
+        st.markdown("""
+**Objetivo**  
+Registrar, de forma padronizada, os dados operacionais de equipamentos (FPSO, Modal, OSM, MROB, métricas e administrativos), garantindo rastreabilidade e qualidade das informações.
+
+**Funcionalidades**
+- Sugestões para **FPSO** e **FPSO1** via `campo_fpso`
+- Campo controlado **“Outro”** quando aplicável
+- Validação de **campos obrigatórios** (ex.: FPSO, Modal, OSM, MROB)
+- Registro automático de **data/hora** (`data_hora_input`)
+- Persistência completa em **banco de dados** (tabela `equipamentos`)
+- **Auditoria**: ações de criação/edição/exclusão registradas
+
+**Campos Principais (Operacionais)**
+- **FPSO / FPSO1**: identificação  
+- **Data de Coleta**  
+- **Especialista / Conferente / OSM**  
+- **Modal / Quantidade de Equipamentos / MROB**  
+- **Métricas**: Linhas OSM, Linhas MROB, Linhas com Erro  
+- **Erros**: Storekeeper, Operação WH, Especialista WH, Outros  
+- **Inclusão / Exclusão** (D1, D2, D3)
+
+**Dados Administrativos**
+- **PO**, **Part Number**, **Material**, **Nota Fiscal**
+- **Solicitante / Requisitante**
+- **Impacto / Dimensão**
+- **Motivo** (Inclusão/Exclusão)
+- **Observações** (campo livre)
+
+**Validações**
+- Checagem de obrigatoriedade em campos críticos
+- Tratamento de valores ausentes (fallback seguro)
+- Índices/sugestões pré-carregados (FPSO/Modal/OSM)
+
+**Fluxo de Dados**
+1. Usuário preenche o formulário com apoio de listas/sugestões  
+2. Sistema valida campos e persiste em `equipamentos`  
+3. Ação administrativa é registrada em **auditoria** (`log_acesso`)  
+4. Registros editáveis posteriormente via **Administração de Registros**
+
+**Perfis / Permissões**
+- Acesso controlado por **perfil** (admin / usuario / consulta) via `verificar_permissao`
+
+**Impacto**
+- **Padronização** dos cadastros  
+- **Redução de erros** operacionais  
+- **Rastreabilidade** completa (auditoria + carimbo de data/hora)
+""")
+
+    with st.expander("📚 Estrutura de Módulos e Grupos (modules_map.py)", expanded=False):
+        st.markdown("""
+- **Grupos suportados**: Operação Load, Backload, Operação, Terceiros, BI.
+- Cada módulo deve ter: `key`, `label`, `descricao`, `perfis`, `grupo`.
+- O **menu lateral** exibe: `Pesquisar módulo` → `Selecione a operação (grupo)` → `Selecione o módulo`.
+- Grupos **sem módulos** (ou sem permissão) exibem: _“Em desenvolvimento”_.
+- **Boas práticas**: labels padronizados, `key` único (sem acentos e espaços), controle de acesso via `perfis`.
+""")
+
+    with st.expander("🧭 Navegação e UI (menu lateral)", expanded=False):
+        st.markdown("""
+- **Pesquisa**: filtra módulos pelo `label`.
+- **Selectbox de Operação**: lista grupos disponíveis.
+- **Selectbox de Módulo**: exibe módulos filtrados por grupo e permissões.
+- **Rodapé da sidebar**: apresenta **e-mail do usuário logado** (badge alinhado) e bloco de **versão + desenvolvedor**.
+- **Layout**: `st.set_page_config(layout="wide")` habilitado, área de conteúdo responsiva.
+""")
+
+    with st.expander("📧 E-mail do Usuário Logado (login + sidebar)", expanded=False):
+        st.markdown("""
+- `login.py` grava na sessão: `st.session_state.email` e `st.session_state.nome` (se disponíveis).
+- Rodapé da sidebar exibe o e-mail em **formato badge** com ícone e alinhamento (`inline-flex`).
+- Caso o e-mail não apareça: verifique se o usuário possui e-mail cadastrado e/ou revalide o login.
+""")
+
+    with st.expander("🧾 Auditoria com E-mail", expanded=False):
+        st.markdown("""
+- O módulo de auditoria realiza **JOIN** com `Usuario` e agora inclui **E-mail** na consulta.
+- Exportação para Excel também leva a coluna **E-mail**.
+- Observação: `JOIN` padrão é interno; para logs órfãos, use `outerjoin` (se necessário).
+""")
+
+    with st.expander("🛠️ Banco de Dados e Ferramentas (db_tools)", expanded=False):
+        st.markdown("""
+- Em **SQLite** e **PostgreSQL**, as alterações (ex.: adicionar `nome` e `email` em `usuarios`) podem ser aplicadas via módulo **`db_tools`** com `ALTER TABLE` e criação de índice único (`email`).
+- **Atenção**: `Base.metadata.create_all()` **não migra** tabelas existentes; para mudanças de esquema use `ALTER TABLE`, **Alembic** (recomendado) ou recrie o banco (backup antes).
+- **Verificação de colunas**: `PRAGMA table_info(usuarios)` (SQLite) ou `information_schema.columns` (Postgres/MySQL).
+""")
+
+    with st.expander("🎮 Jogos / Treinamento (módulo jogos)", expanded=False):
+        st.markdown("""
+- **Jogo da Forca (Treinamento)**: perguntas por categoria, avanço de nível, contagem de tentativas.
+- **Caça ao Tesouro (Níveis)**: pistas Sim/Não com feedback visual e avanço até o limite de perguntas.
+- **Dado (Curiosidades)**: número de lados configurável, curiosidades de FPSO/Estoque/Óleo e Gás.
+- **Pontuação e balões**: opção de efeitos visuais e pontuação acumulada.
+""")
+
+    with st.expander("🧠 Quiz e Ranking", expanded=False):
+        st.markdown("""
+- **Quiz**: perguntas dinâmicas via banco; fluxo ajustável (sem limitadores) e com opção de **Voltar ao sistema**.
+- **Ranking**: consolida pontuação por rodada/período e oferece exportação.
+""")
+
+    with st.expander("🎨 Diretrizes de Layout e Acessibilidade", expanded=False):
+        st.markdown("""
+- **Responsividade**: usar `use_container_width=True` em tabelas/gráficos.
+- **Colunas fluidas**: `st.columns()` para KPIs (ajuste automático em telas menores).
+- **Expansores**: `st.expander()` para reduzir poluição visual.
+- **Temas**: arquivo `.streamlit/config.toml` pode definir `primaryColor`, `secondaryBackgroundColor`, etc.
+""")
+
+    with st.expander("🔐 Segurança e Boas Práticas", expanded=False):
+        st.markdown("""
+- **Senhas**: sempre criptografadas (ex.: `utils_seguranca`), nunca armazenar em texto claro.
+        - **Perfis**: `verificar_permissao(mod_id)` controla acesso; mantenha perfis atualizados.
+- **Auditoria**: registrar ações administrativas via `registrar_log(...)`.
+""")
+
+    with st.expander("📦 Versionamento e Suporte", expanded=False):
+        st.markdown("""
+- **Versão atual**: exibida no rodapé da sidebar.
+- **Desenvolvedor**: contato visível na sidebar | Rodrigo Silva.
+- **Próximos passos**: documentação dos novos grupos/módulos, criação de migrations com Alembic, e manuais por equipe (Operação, Backload, Terceiros, BI).
+""")
+
+
+# =====================================================
+# 🔔 Aviso Global — helpers
+# =====================================================
+def _get_db_session_admin():
+    """
+    Sessão ciente do ambiente atual (via db_router, quando disponível).
+    Fallback para SessionLocal().
+    """
+    try:
+        from db_router import get_session_for_current_db  # ajuste o nome se necessário
+        return get_session_for_current_db()
+    except Exception:
+        return SessionLocal()
+
+def _sanitize_largura(largura_raw: str) -> str:
+    val = (largura_raw or "").strip()
+    if not val:
+        return "100%"
+    if val.endswith("%") or val.endswith("px"):
+        return val
+    if val.isdigit():
+        return f"{val}px"
+    return "100%"
+
+def _obter_aviso_ativo_admin():
+    if not _HAS_AVISO_GLOBAL:
+        return None
+    db = _get_db_session_admin()
+    try:
+        return (
+            db.query(AvisoGlobal)
+            .filter(AvisoGlobal.ativo == True)
+            .order_by(AvisoGlobal.updated_at.desc(), AvisoGlobal.created_at.desc())
+            .first()
+        )
+    except Exception:
+        return None
+    finally:
+        try:
+            db.close()
+        except Exception:
+            pass
+
+# 🔧 Diagnóstico e correção de schema (colunas) da tabela aviso_global
+def _verificar_schema_aviso_global(show_ui: bool = True) -> bool:
+    """
+    Retorna True se o schema está OK (inclui font_size).
+    Se show_ui=True, exibe UI com botão para criar coluna ausente.
+    """
+    if not _HAS_AVISO_GLOBAL:
+        if show_ui:
+            st.error("Modelo AvisoGlobal não encontrado.")
+        return False
+
+    db = _get_db_session_admin()
+    try:
+        insp = inspect(db.bind)
+        cols = [c["name"] for c in insp.get_columns("aviso_global")]
+        falta_font = "font_size" not in cols
+
+        if show_ui:
+            with st.expander("🧪 Diagnóstico do schema (aviso_global)", expanded=False):
+                st.caption("Colunas atuais: " + (", ".join(cols) if cols else "—"))
+                if falta_font:
+                    st.warning("A coluna **font_size** não existe neste banco/ambiente.")
+                    col_btn1, col_btn2 = st.columns([1, 3])
+                    if col_btn1.button("⚙️ Criar coluna font_size (DEFAULT 14)"):
+                        try:
+                            dialect = db.bind.dialect.name
+                            if dialect == "sqlite":
+                                sql = "ALTER TABLE aviso_global ADD COLUMN font_size INTEGER DEFAULT 14"
+                            elif dialect == "postgresql":
+                                sql = "ALTER TABLE aviso_global ADD COLUMN font_size integer DEFAULT 14"
+                            elif dialect in ("mysql", "mariadb"):
+                                sql = "ALTER TABLE aviso_global ADD COLUMN font_size INT DEFAULT 14"
+                            else:
+                                st.error(f"Dialeto não suportado para criação automática: {dialect}")
+                                return False
+                            db.execute(text(sql))
+                            db.commit()
+                            st.success("Coluna 'font_size' criada com sucesso. Recarregando...")
+                            st.rerun()
+                        except Exception as e:
+                            db.rollback()
+                            st.error(f"Erro ao criar coluna: {e}")
+                else:
+                    st.success("Schema OK ✔ (coluna 'font_size' presente).")
+        return not falta_font
+
+    except Exception as e:
+        if show_ui:
+            st.error(f"Falha ao inspecionar o schema: {e}")
+        return False
+    finally:
+        try:
+            db.close()
+        except Exception:
+            pass
+
+def _publicar_aviso_admin(mensagem, bg_color, text_color, largura, efeito, velocidade, font_size) -> bool:
+    if not _HAS_AVISO_GLOBAL:
+        return False
+    db = _get_db_session_admin()
+    try:
+        # desativa os ativos
+        db.query(AvisoGlobal).filter(AvisoGlobal.ativo == True).update({AvisoGlobal.ativo: False})
+        novo = AvisoGlobal(
+            mensagem=(mensagem or "").strip(),
+            bg_color=(bg_color or "#FFF3CD").strip(),
+            text_color=(text_color or "#664D03").strip(),
+            largura=_sanitize_largura(largura),
+            efeito=efeito if efeito in ("marquee", "fixo") else "marquee",
+            velocidade=max(5, min(int(velocidade or 20), 120)),
+            ativo=True,
+            updated_at=datetime.now(),
+        )
+        # salva font_size quando o atributo/coluna existir (fallback seguro)
+        try:
+            setattr(novo, "font_size", max(10, min(int(font_size or 14), 48)))
+        except Exception:
+            pass
+
+        db.add(novo)
+        db.commit()
+        db.expire_all()
+        return True
+    except Exception as e:
+        db.rollback()
+        # Diagnóstico visível para o admin
+        st.error(f"Falha ao publicar o aviso: {e}")
+        try:
+            insp = inspect(db.bind)
+            cols = [c["name"] for c in insp.get_columns("aviso_global")]
+            st.caption("Colunas em aviso_global: " + ", ".join(cols))
+        except Exception:
+            pass
+        return False
+    finally:
+        try:
+            db.close()
+        except Exception:
+            pass
+
+def _desativar_aviso_admin() -> bool:
+    if not _HAS_AVISO_GLOBAL:
+        return False
+    db = _get_db_session_admin()
+    try:
+        db.query(AvisoGlobal).filter(AvisoGlobal.ativo == True)\
+          .update({AvisoGlobal.ativo: False, AvisoGlobal.updated_at: datetime.now()})
+        db.commit()
+        db.expire_all()
+        return True
+    except Exception:
+        db.rollback()
+        return False
+    finally:
+        try:
+            db.close()
+        except Exception:
+            pass
+
+
+# ===============================
+# 🔎 Pré-visualização do Aviso Global (somente render local)
+# ===============================
+def _render_preview_aviso_topbar(mensagem: str, bg_color: str, text_color: str, largura: str, efeito: str, velocidade: int, font_size: int):
+    largura = _sanitize_largura(largura)
+    bg = (bg_color or "#FFF3CD").strip()
+    fg = (text_color or "#664D03").strip()
+    efeito = (efeito or "marquee").lower()
+    try:
+        velocidade = int(velocidade or 20)
+    except Exception:
+        velocidade = 20
+    try:
+        font_size = max(10, min(int(font_size or 14), 48))
+    except Exception:
+        font_size = 14
+
+    st.markdown(
+        f"""
+        <style>
+        .ag-topbar-wrap-preview {{
+            position: relative; /* preview não fixa no topo global */
+            width: {largura};
+            margin: 8px auto 10px auto;
+            z-index: 10;
+            background: {bg}; color: {fg};
+            border: 1px solid rgba(0,0,0,.08);
+            box-shadow: 0 2px 6px rgba(0,0,0,.06);
+            border-radius: 10px;
+        }}
+        .ag-topbar-inner-preview {{
+            display: flex; align-items: center;
+            min-height: 44px; padding: 8px 14px; overflow: hidden;
+            font-weight: 700; font-size: {font_size}px; letter-spacing: .2px;
+            white-space: nowrap;
+        }}
+        .ag-topbar-marquee-preview > span {{
+            display: inline-block; padding-left: 100%;
+            animation: ag-marquee-preview {velocidade}s linear infinite;
+        }}
+        @keyframes ag-marquee-preview {{
+            0% {{ transform: translateX(0); }}
+            100% {{ transform: translateX(-100%); }}
+        }}
+        </style>
+        <div class="ag-topbar-wrap-preview">
+          <div class="ag-topbar-inner-preview {'ag-topbar-marquee-preview' if efeito=='marquee' else ''}">
+            <span>{mensagem}</span>
+          </div>
+        </div>
+        """,
+        unsafe_allow_html=True
+    )
+
+
+# =====================================================
+# 🔔 Menu: Aviso Global (Topo)
+# =====================================================
+def menu_aviso_global():
+    st.subheader("📣 Aviso Global (Topo)")
+    st.caption("Envie um aviso global exibido no topo para todos os usuários.")
+
+    perfil = (st.session_state.get("perfil") or "usuario").strip().lower()
+    if perfil != "admin":
+        st.warning("Apenas administradores podem publicar avisos globais.")
+        return
+
+    if not _HAS_AVISO_GLOBAL:
+        st.error(
+            "O modelo `AvisoGlobal` não foi encontrado em `models.py`."
+        )
+        with st.expander("📄 Modelo necessário (copie para models.py)"):
+            st.code(
+                """from banco import Base
+from sqlalchemy import Column, Integer, String, Boolean, DateTime, Text
+from sqlalchemy.sql import func
+
+class AvisoGlobal(Base):
+    __tablename__ = "aviso_global"
+    id = Column(Integer, primary_key=True, index=True)
+    mensagem = Column(Text, nullable=False)
+    bg_color = Column(String(32), default="#FFF3CD")
+    text_color = Column(String(32), default="#664D03")
+    largura = Column(String(16), default="100%")
+    efeito = Column(String(16), default="marquee")
+    velocidade = Column(Integer, default=20)
+    font_size = Column(Integer, default=14)  # tamanho da fonte (px)
+    ativo = Column(Boolean, default=True, index=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now())""",
+                language="python",
+            )
+        return
+
+    # 🔎 Diagnóstico/migração simples do schema (font_size)
+    _verificar_schema_aviso_global(show_ui=True)
+
+    aviso_atual = _obter_aviso_ativo_admin()
+
+    msg_default = aviso_atual.mensagem if aviso_atual else ""
+    bg_default = aviso_atual.bg_color if aviso_atual else "#FFF3CD"
+    fg_default = aviso_atual.text_color if aviso_atual else "#664D03"
+    w_default  = aviso_atual.largura if aviso_atual else "100%"
+    ef_default = (aviso_atual.efeito if aviso_atual else "marquee")
+    vel_default = int(aviso_atual.velocidade if aviso_atual else 20)
+    fs_default = int(getattr(aviso_atual, "font_size", 14)) if aviso_atual else 14  # ⬅️ NOVO
+
+    mensagem = st.text_input("Mensagem do aviso:", value=msg_default, placeholder="Ex.: Manutenção hoje às 18h...")
+    colc1, colc2 = st.columns(2)
+    bg_color = colc1.color_picker("Cor de fundo", value=bg_default)
+    text_color = colc2.color_picker("Cor do texto", value=fg_default)
+
+    colw1, colw2 = st.columns([2,1])
+    largura = colw1.text_input("Largura (ex.: 100% ou 1200px)", value=w_default)
+    efeito = colw2.selectbox("Efeito", ["marquee", "fixo"], index=(0 if ef_default=="marquee" else 1))
+
+    colv1, colv2 = st.columns(2)
+    velocidade = colv1.slider("Velocidade (segundos por ciclo)", min_value=5, max_value=120, value=vel_default, step=1, help="Usado apenas no modo 'marquee'.")
+    font_size = colv2.slider("Tamanho da fonte (px)", min_value=10, max_value=48, value=fs_default, step=1)  # ⬅️ NOVO
+
+    # --- Pré-visualização ao vivo (sem salvar) ---
+    st.markdown("**Pré-visualização:**")
+    if (mensagem or "").strip():
+        _render_preview_aviso_topbar(mensagem, bg_color, text_color, largura, efeito, velocidade, font_size)
+    else:
+        st.info("Digite a mensagem para ver a pré-visualização aqui.")
+
+    colb1, colb2, colb3 = st.columns(3)
+    publicar = colb1.button("📢 Publicar/Atualizar aviso")
+    desativar = colb2.button("🛑 Desativar aviso atual")
+    atualizar_preview = colb3.button("🔄 Atualizar prévia")
+
+    # Botão opcional de refresh da prévia (não salva nada; rerenderiza a página).
+    if atualizar_preview:
+        st.rerun()
+
+    if publicar:
+        if not (mensagem or "").strip():
+            st.warning("Digite a mensagem do aviso.")
+        else:
+            ok = _publicar_aviso_admin(mensagem, bg_color, text_color, largura, efeito, velocidade, font_size)
+            if ok:
+                try:
+                    registrar_log(
+                        usuario=st.session_state.get("usuario"),
+                        acao="PUBLICAR_AVISO_GLOBAL",
+                        tabela="aviso_global",
+                        registro_id=None
+                    )
+                except Exception:
+                    pass
+                st.success("Aviso publicado/atualizado!")
+                st.rerun()
+            else:
+                st.error("Não foi possível publicar o aviso. Verifique o banco/logs.")
+
+    if desativar:
+        ok = _desativar_aviso_admin()
+        if ok:
+            try:
+                registrar_log(
+                    usuario=st.session_state.get("usuario"),
+                    acao="DESATIVAR_AVISO_GLOBAL",
+                    tabela="aviso_global",
+                    registro_id=None
+                )
+            except Exception:
+                pass
+            st.info("Aviso desativado.")
+            st.rerun()
+        else:
+            st.error("Não foi possível desativar o aviso.")
+
+
+# =====================================================
+# ADMINISTRAÇÃO (variação com abas/tabs)
+# =====================================================
+def main():
+
+    # ✅ Detecta se usuário é admin; abas administrativas aparecem apenas para admin.
+    is_admin = verificar_permissao("administracao")
+
+    # Título conforme perfil
+    if is_admin:
+        st.title("🔒 Administração")
+        # Admin vê todas as abas
+        tab_editar, tab_aviso, tab_info = st.tabs([
+            "✏️ Editar / Excluir Registros",
+            "📣 Aviso Global (Topo)",
+            "📘 Info do Sistema"
+        ])
+    else:
+        st.title("✏️ Edição de Registros")
+        # Não-admin vê apenas a aba de edição
+        (tab_editar,) = st.tabs(["✏️ Editar Registros"])
+
+    # =====================================================
+    # BLOCO: INFO DO SISTEMA (apenas admin)
+    # =====================================================
+    if is_admin:
+        with tab_info:
+            menu_info()
+
+    # =====================================================
+    # BLOCO: AVISO GLOBAL (apenas admin)
+    # =====================================================
+        with tab_aviso:
+            menu_aviso_global()
+
+    # =====================================================
+    # BLOCO: EDIÇÃO / EXCLUSÃO (excluir só admin)
+    # =====================================================
+    with tab_editar:
+
+        # =====================================================
+        # FUNÇÃO UTILITÁRIA
+        # =====================================================
+        def safe_index(lista, valor):
+            """Evita erro quando o valor salvo no banco não existe na lista"""
+            try:
+                return lista.index(valor)
+            except ValueError:
+                return 0
+
+        db = SessionLocal()
+        try:
+            # =====================================================
+            # 🔎 FILTROS OPCIONAIS COM SUGESTÕES DO BANCO
+            # (disponível para todos os perfis)
+            # =====================================================
+            st.subheader("🔎 Filtro de Busca (opcional)")
+
+            # IMPORTANTE: usar .distinct() sobre a coluna, como já estava
+            fpsos = [""] + sorted({r.fpso for r in db.query(Equipamento.fpso).distinct() if r.fpso})
+            modais = [""] + sorted({r.modal for r in db.query(Equipamento.modal).distinct() if r.modal})
+            osms = [""] + sorted({r.osm for r in db.query(Equipamento.osm).distinct() if r.osm})
+            # 🟩 NOVO: lista de Nota Fiscal para multiselect assistido
+            notas_dist = [""] + sorted({str(r.nota_fiscal) for r in db.query(Equipamento.nota_fiscal).distinct() if r.nota_fiscal})
+
+            col1, col2, col3, col4 = st.columns(4)
+
+            with col1:
+                filtro_fpso = st.selectbox("FPSO", fpsos)
+
+            with col2:
+                filtro_modal = st.selectbox("Modal", modais)
+
+            with col3:
+                filtro_osm = st.selectbox("OSM", osms)
+
+            with col4:
+                filtro_data = st.date_input("Data Coleta", value=None)
+
+            # 🟩 NOVO: filtros de Nota Fiscal + opção de ver só duplicadas
+            st.markdown("**🧾 Filtro por Nota Fiscal**")
+            nf_col1, nf_col2, nf_col3 = st.columns([2, 2, 1.2])
+            with nf_col1:
+                filtro_nf_text = st.text_input(
+                    "Digite uma ou mais NFs (separadas por vírgula)",
+                    value=""
+                )
+            with nf_col2:
+                filtro_nf_multi = st.multiselect(
+                    "Ou selecione",
+                    options=[x for x in notas_dist if x != ""]
+                )
+            with nf_col3:
+                mostrar_apenas_nf_duplicadas = st.checkbox(
+                    "Somente duplicadas",
+                    value=False
+                )
+
+            # =====================================================
+            # QUERY BASE (COMPORTAMENTO ORIGINAL) + NOVO FILTRO NF
+            # =====================================================
+            query = db.query(Equipamento)
+
+            if filtro_fpso:
+                query = query.filter(Equipamento.fpso == filtro_fpso)
+
+            if filtro_modal:
+                query = query.filter(Equipamento.modal == filtro_modal)
+
+            if filtro_osm:
+                query = query.filter(Equipamento.osm == filtro_osm)
+
+            if filtro_data:
+                query = query.filter(Equipamento.data_coleta == filtro_data)
+
+            # 🟩 NOVO: aplica filtro de Nota Fiscal (tratando como string)
+            notas_escolhidas = set()
+            if filtro_nf_text.strip():
+                partes = [p.strip() for p in filtro_nf_text.split(",") if p.strip()]
+                notas_escolhidas.update(partes)
+            if filtro_nf_multi:
+                notas_escolhidas.update([str(x).strip() for x in filtro_nf_multi if str(x).strip()])
+
+            if notas_escolhidas:
+                # Como a coluna é do tipo texto no modelo, filtramos por igualdade textual.
+                # Para outros dialetos/formatos numéricos, garantir cast adequado.
+                query = query.filter(Equipamento.nota_fiscal.in_(list(notas_escolhidas)))
+
+            registros = query.order_by(Equipamento.id.desc()).all()
+
+            if not registros:
+                st.info("Nenhum registro encontrado.")
+                return
+
+            # =====================================================
+            # 🧭 SINALIZAÇÃO DE NF DUPLICADA (no conjunto filtrado)
+            # =====================================================
+            # Monta DF auxiliar só com campos relevantes para contagem de NF
+            import pandas as pd
+            df_aux = pd.DataFrame([{
+                "ID": r.id,
+                "Nota Fiscal": ("" if r.nota_fiscal is None else str(r.nota_fiscal).strip())
+            } for r in registros])
+
+            # Contagem de ocorrências por NF (string, ignorando vazias)
+            if not df_aux.empty:
+                contagem = df_aux.loc[df_aux["Nota Fiscal"] != "", "Nota Fiscal"].value_counts()
+                notas_duplicadas = contagem[contagem > 1]
+            else:
+                notas_duplicadas = pd.Series(dtype=int)
+
+            # Aviso e expander com a lista das duplicadas
+            if len(notas_duplicadas.index) > 0:
+                total_ocorrencias = int(notas_duplicadas.sum())
+                st.warning(
+                    f"⚠️ Foram encontradas **{total_ocorrencias}** ocorrências em **{len(notas_duplicadas)}** "
+                    f"números de Nota Fiscal duplicados no resultado filtrado."
+                )
+                with st.expander("Ver lista de notas duplicadas"):
+                    st.dataframe(
+                        notas_duplicadas.rename("Ocorrências").reset_index().rename(columns={"index": "Nota Fiscal"}),
+                        use_container_width=True
+                    )
+
+                # Se marcado: mantém na lista apenas as duplicadas
+                if mostrar_apenas_nf_duplicadas:
+                    set_dup = set(notas_duplicadas.index.tolist())
+                    registros = [r for r in registros if (r.nota_fiscal is not None and str(r.nota_fiscal).strip() in set_dup)]
+
+                    if not registros:
+                        st.info("Nenhum registro duplicado após aplicar o filtro de 'Somente duplicadas'.")
+                        return
+
+            else:
+                if mostrar_apenas_nf_duplicadas:
+                    st.info("Não há notas duplicadas no conjunto filtrado.")
+                    return
+
+            # =====================================================
+            # SELECTBOX DE ESCOLHA E FORMULÁRIO
+            # =====================================================
+            mapa = {
+                f"ID {r.id} | FPSO {r.fpso} | {r.modal} | {r.osm} | {r.data_coleta} | NF: {r.nota_fiscal or '—'}": r.id
+                for r in registros
+            }
+
+            escolha = st.selectbox("Selecione o registro", list(mapa.keys()))
+            registro = db.get(Equipamento, mapa[escolha])
+
+            st.divider()
+            st.subheader("✏️ Editar Registro")
+
+            # =====================================================
+            # FORMULÁRIO COMPLETO (MESMO DO MÓDULO FORMULÁRIO)
+            # =====================================================
+            with st.form("form_edicao"):
+
+                # ================== DADOS OPERACIONAIS ==================
+                st.subheader("📦 Dados Operacionais")
+
+                col1, col2, col3 = st.columns(3)
+
+                with col1:
+                    fpso1 = campo_fpso("FPSO1", registro.fpso1)
+                    fpso = campo_fpso("FPSO", registro.fpso)
+                    data_coleta = st.date_input("Data de Coleta", registro.data_coleta)
+                    especialista = st.text_input("Especialista", registro.especialista or "")
+                    conferente = st.text_input("Conferente", registro.conferente or "")
+                    osm = st.text_input("OSM", registro.osm or "")
+
+                with col2:
+                    modal = st.selectbox(
+                        "Modal",
+                        MODAL_LISTA,
+                        index=safe_index(MODAL_LISTA, registro.modal)
+                    )
+                    quant_equip = st.number_input(
+                        "Quantidade de Equipamentos",
+                        min_value=0,
+                        value=registro.quant_equip or 0
+                    )
+                    mrob = st.text_input("MROB", registro.mrob or "")
+
+                with col3:
+                    linhas_osm = st.number_input("Total de Linhas OSM", value=registro.linhas_osm or 0)
+                    linhas_mrob = st.number_input("Total de Linhas MROB", value=registro.linhas_mrob or 0)
+                    linhas_erros = st.number_input("Total de Linhas com Erro", value=registro.linhas_erros or 0)
+
+                st.divider()
+
+                # ================== ANÁLISE DE ERROS ==================
+                st.subheader("⚠️ Análise de Erros")
+
+                op_sim_nao = ["", "Sim", "Não"]
+
+                col_e1, col_e2, col_e3, col_e4 = st.columns(4)
+
+                with col_e1:
+                    erro_storekeeper = st.selectbox(
+                        "Storekeeper", op_sim_nao,
+                        index=safe_index(op_sim_nao, registro.erro_storekeeper)
+                    )
+
+                with col_e2:
+                    erro_operacao = st.selectbox(
+                        "Operação WH", op_sim_nao,
+                        index=safe_index(op_sim_nao, registro.erro_operacao)
+                    )
+
+                with col_e3:
+                    erro_especialista = st.selectbox(
+                        "Especialista WH", op_sim_nao,
+                        index=safe_index(op_sim_nao, registro.erro_especialista)
+                    )
+
+                with col_e4:
+                    erro_outros = st.selectbox(
+                        "Outros", op_sim_nao,
+                        index=safe_index(op_sim_nao, registro.erro_outros)
+                    )
+
+                op_inc_exc = ["", "INCLUSÃO", "EXCLUSÃO"]
+
+                inclusao_exclusao = st.selectbox(
+                    "Inclusão / Exclusão",
+                    op_inc_exc,
+                    index=safe_index(op_inc_exc, registro.inclusao_exclusao)
+                )
+
+                st.divider()
+
+                # ================== DADOS ADMINISTRATIVOS ==================
+                st.subheader("🧾 Dados Administrativos")
+
+                col_a1, col_a2, col_a3 = st.columns(3)
+
+                with col_a1:
+                    po = st.text_input("PO", registro.po or "")
+                    part_number = st.text_input("Part Number", registro.part_number or "")
+
+                with col_a2:
+                    material = st.text_input("Material", registro.material or "")
+                    nota_fiscal = st.text_input("Nota Fiscal", registro.nota_fiscal or "")
+
+                with col_a3:
+                    solicitante = st.text_input("Solicitante", registro.solicitante or "")
+                    requisitante = st.text_input("Requisitante", registro.requisitante or "")
+
+                impacto = st.text_input("Impacto", registro.impacto or "")
+                dimensao = st.text_input("Dimensão", registro.dimensao or "")
+
+                # ✅ AJUSTE: corrigido para 'motivo'
+                motivo = st.text_input("Motivo da Inclusão / Exclusão", registro.motivo or "")
+
+                observacoes = st.text_area(
+                    "Observações",
+                    registro.observacoes or "",
+                    height=120
+                )
+
+                op_dia = ["", "D1", "D2", "D3"]
+
+                dia_inclusao = st.selectbox(
+                    "Dia de Inclusão (D)",
+                    op_dia,
+                    index=safe_index(op_dia, registro.dia_inclusao)
+                )
+
+                # ================== AÇÃO ==================
+                # 🔐 Apenas admin pode excluir
+                opcoes_acao = ["Salvar Alterações"] + (["Excluir Registro"] if is_admin else [])
+                acao = st.radio(
+                    "Ação",
+                    opcoes_acao,
+                    horizontal=True
+                )
+
+                submit = st.form_submit_button("Confirmar")
+
+            # =====================================================
+            # AÇÕES
+            # =====================================================
+            if submit:
+
+                if acao == "Salvar Alterações":
+                    # Atualiza todos os campos dinamicamente (exceto id)
+                    for campo in registro.__table__.columns.keys():
+                        if campo != "id":
+                            setattr(registro, campo, locals().get(campo, getattr(registro, campo)))
+
+                    registro.data_hora_input = datetime.now()
+                    db.commit()
+
+                    try:
+                        registrar_log(
+                            usuario=st.session_state.get("usuario"),
+                            acao="EDITAR",
+                            tabela="equipamentos",
+                            registro_id=registro.id
+                        )
+                    except Exception:
+                        pass
+
+                    st.success("✅ Registro atualizado com sucesso!")
+                    st.rerun()
+
+                elif acao == "Excluir Registro" and is_admin:
+                    db.delete(registro)
+                    db.commit()
+
+                    try:
+                        registrar_log(
+                            usuario=st.session_state.get("usuario"),
+                            acao="EXCLUIR",
+                            tabela="equipamentos",
+                            registro_id=registro.id
+                        )
+                    except Exception:
+                        pass
+
+                    st.success("🗑️ Registro excluído com sucesso!")
+                    st.rerun()
+
+        finally:
+            try:
+                db.close()
+            except Exception:
+                pass
+
+

app.py

@@ -0,0 +1,1015 @@
+# -*- coding: utf-8 -*-
+import streamlit as st
+from dotenv import load_dotenv
+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")
+
+# Carrega variáveis de ambiente
+load_dotenv()
+
+# ===============================
+# 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
+
+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
+from models import IOIRunSugestao
+from models import AvisoGlobal
+
+# Extras p/ sessões ativas
+from uuid import uuid4
+from sqlalchemy import text, func, or_
+
+# 🗄️ 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"
+    # ❌ REMOVIDO: não chamar nenhuma página ao importar/rodar o app principal
+    # if __name__ == "__main__":
+    #     rnc.pagina()
+
+# ===============================
+# RERUN por querystring (atalho ?rr=1)
+# ===============================
+def _get_query_params():
+    """Compat: retorna query params como dict (Streamlit novo/antigo)."""
+    try:
+        # 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  # Streamlit >= 1.32
+    except Exception:
+        try:
+            st.experimental_set_query_params(**new_params)
+        except Exception:
+            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.
+    """
+    try:
+        if st.session_state.get("__qs_rr_consumed__", False):
+            return
+        # 🔒 Evita rr=1 em módulos sensíveis a rerun/refresh
+        # 🟩 AJUSTE: incluir 'formulario' para não aplicar rr=1 quando o formulário estiver ativo
+        if pagina_atual in ("resposta", "outlook_relatorio", "formulario"):
+            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)
+        if str(rr).lower() in ("1", "true"):
+            new_params = {k: v for k, v in params.items() if k != "rr"}
+            _set_query_params(new_params)
+            st.session_state["__qs_rr_consumed__"] = True
+            st.rerun()
+    except Exception:
+        pass
+
+# =========================================
+# DB helper — sessão ciente do ambiente
+# =========================================
+def _get_db_session():
+    """Retorna uma sessão de banco consistente com o ambiente atual."""
+    try:
+        from db_router import get_session_for_current_db
+        return get_session_for_current_db()
+    except Exception:
+        pass
+
+    try:
+        from db_router import get_engine_for_current_db
+        from sqlalchemy.orm import sessionmaker
+        Eng = get_engine_for_current_db()
+        return sessionmaker(bind=Eng)()
+    except Exception:
+        pass
+
+    return SessionLocal()
+
+# ===============================
+# CONFIGURAÇÃO INICIAL
+# ===============================
+Base.metadata.create_all(bind=engine)
+
+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
+        )
+    finally:
+        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:
+    if "_sid" not in st.session_state:
+        st.session_state["_sid"] = f"{uuid4()}"
+    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("""
+            CREATE TABLE IF NOT EXISTS sessao_web (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                usuario TEXT NOT NULL,
+                session_id TEXT NOT NULL UNIQUE,
+                last_seen TIMESTAMP NOT NULL,
+                ativo INTEGER NOT NULL DEFAULT 1
+            )
+        """))
+    elif dialect in ("postgresql", "postgres"):
+        db.execute(text("""
+            CREATE TABLE IF NOT EXISTS sessao_web (
+                id SERIAL PRIMARY KEY,
+                usuario TEXT NOT NULL,
+                session_id TEXT NOT NULL UNIQUE,
+                last_seen TIMESTAMPTZ NOT NULL,
+                ativo BOOLEAN NOT NULL DEFAULT TRUE
+            )
+        """))
+    else:  # mysql / mariadb
+        db.execute(text("""
+            CREATE TABLE IF NOT EXISTS sessao_web (
+                id INT AUTO_INCREMENT PRIMARY KEY,
+                usuario VARCHAR(255) NOT NULL,
+                session_id VARCHAR(255) NOT NULL UNIQUE,
+                last_seen TIMESTAMP NOT NULL,
+                ativo TINYINT(1) NOT NULL DEFAULT 1
+            )
+        """))
+    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()
+    try:
+        _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}
+        )
+        if upd.rowcount == 0:
+            db.execute(
+                text(f"INSERT INTO sessao_web (usuario, session_id, last_seen, ativo) "
+                     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')"
+        elif dialect == "sqlite":
+            cleanup_sql = f"UPDATE sessao_web SET ativo = 0 WHERE last_seen < datetime(CURRENT_TIMESTAMP, '-{_SESS_TTL_MIN * 2} minutes')"
+        else:
+            cleanup_sql = f"UPDATE sessao_web SET ativo = 0 WHERE last_seen < DATE_SUB(CURRENT_TIMESTAMP, INTERVAL {_SESS_TTL_MIN * 2} MINUTE)"
+        db.execute(text(cleanup_sql))
+        db.commit()
+    except Exception:
+        db.rollback()
+    finally:
+        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)
+        dialect = db.bind.dialect.name
+        if dialect in ("postgresql", "postgres"):
+            threshold = f"(NOW() - INTERVAL '{_SESS_TTL_MIN} minutes')"
+        elif dialect == "sqlite":
+            threshold = f"datetime(CURRENT_TIMESTAMP, '-{_SESS_TTL_MIN} minutes')"
+        else:
+            threshold = f"DATE_SUB(CURRENT_TIMESTAMP, INTERVAL {_SESS_TTL_MIN} MINUTE)"
+        res = db.execute(
+            text(f"SELECT COUNT(DISTINCT usuario) AS c FROM sessao_web WHERE ativo = 1 AND last_seen >= {threshold}")
+        ).fetchone()
+        return int(res[0] if res and res[0] is not None else 0)
+    except Exception:
+        return 0
+    finally:
+        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
+    db = _get_db_session()
+    try:
+        _ensure_sessao_table(db)
+        db.execute(text("UPDATE sessao_web SET ativo = 0 WHERE session_id = :sid"), {"sid": sid})
+        db.commit()
+    except Exception:
+        db.rollback()
+    finally:
+        try:
+            db.close()
+        except Exception:
+            pass
+
+# ===============================
+# Aviso Global — Util (leitura e sanitização)
+# ===============================
+def _sanitize_largura(largura_raw: str) -> str:
+    val = (largura_raw or "").strip()
+    if not val:
+        return "100%"
+    if val.endswith("%") or val.endswith("px"):
+        return val
+    if val.isdigit():
+        return f"{val}px"
+    return "100%"
+
+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()
+        )
+        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)
+    except Exception as e:
+        st.sidebar.warning(f"Aviso desativado: falha ao consultar ({e})")
+        aviso = None
+    finally:
+        try:
+            db.close()
+        except Exception:
+            pass
+
+    if not aviso:
+        return
+
+    try:
+        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"],
+[data-testid="stDecoration"],
+[data-testid="collapsedControl"],
+.stApp [class*="stDialog"] {{
+    z-index: 1 !important;
+}}
+/* Reserva espaço para a barra */
+[data-testid="stAppViewContainer"] {{
+    padding-top: {altura + 8}px !important;
+}}
+
+.ag-topbar-wrap {{
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: {largura};
+    z-index: 2147483647 !important;
+    background: {bg};
+    color: {fg};
+    border-bottom: 1px solid rgba(0,0,0,.12);
+    box-shadow: 0 2px 8px rgba(0,0,0,.15);
+    border-radius: 0 0 10px 10px;
+    pointer-events: none;
+}}
+.ag-topbar-inner {{
+    display: flex;
+    align-items: center;
+    height: {altura}px;
+    padding: 0 14px;
+    overflow: hidden;
+    font-weight: 700;
+    font-size: {font_size}px;
+    letter-spacing: .2px;
+    white-space: nowrap;
+}}
+.ag-topbar-marquee > span {{
+    display: inline-block;
+    padding-left: 100%;
+    animation: ag-marquee {velocidade}s linear infinite;
+}}
+@keyframes ag-marquee {{
+    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;
+    }}
+}}
+@media (max-width: 500px) {{
+    .ag-topbar-inner {{
+        font-size: {max(10, font_size-3)}px;
+        padding: 0 8px;
+        height: 44px;
+    }}
+    [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>{aviso.mensagem}</span>
+  </div>
+</div>
+""",
+            unsafe_allow_html=True
+        )
+    except Exception as e:
+        st.sidebar.warning(f"Aviso desativado: erro de render ({e})")
+        return
+
+# ===============================
+# Logout (utilitário)
+# ===============================
+def logout():
+    """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
+    st.session_state.nome = None
+    st.session_state.email = None
+    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
+        st.markdown(
+            """
+<style>
+.confetti-wrapper { position: relative; width: 100%; height: 0; }
+.confetti-area { position: fixed; top: 0; left: 0; width: 100%; height: 100%;
+                 pointer-events: none; z-index: 9999; }
+.confetti { position: absolute; top: -5%; font-size: 24px; animation-name: confetti-fall;
+            animation-timing-function: linear; animation-iteration-count: 1; }
+@keyframes confetti-fall {
+    0%   { transform: translateY(-5vh) rotate(0deg); opacity: 1; }
+    100% { transform: translateY(105vh) rotate(360deg); opacity: 0; }
+}
+.confetti:nth-child(1)  { left: 5%;  animation-duration: 3.5s; }
+.confetti:nth-child(2)  { left: 12%; animation-duration: 4.0s; }
+.confetti:nth-child(3)  { left: 20%; animation-duration: 3.2s; }
+.confetti:nth-child(4)  { left: 28%; animation-duration: 4.3s; }
+.confetti:nth-child(5)  { left: 36%; animation-duration: 3.8s; }
+.confetti:nth-child(6)  { left: 44%; animation-duration: 4.1s; }
+.confetti:nth-child(7)  { left: 52%; animation-duration: 3.4s; }
+.confetti:nth-child(8)  { left: 60%; animation-duration: 4.4s; }
+.confetti:nth-child(9)  { left: 68%; animation-duration: 3.9s; }
+.confetti:nth-child(10) { left: 76%; animation-duration: 4.2s; }
+.confetti:nth-child(11) { left: 84%; animation-duration: 3.6s; }
+.confetti:nth-child(12) { left: 92%; animation-duration: 4.0s; }
+</style>
+<div class="confetti-wrapper">
+  <div class="confetti-area">
+    <div class="confetti">🎊</div><div class="confetti">🎉</div>
+    <div class="confetti">🎊</div><div class="confetti">🎉</div>
+    <div class="confetti">🎊</div><div class="confetti">🎉</div>
+    <div class="confetti">🎊</div><div class="confetti">🎉</div>
+    <div class="confetti">🎊</div><div class="confetti">🎉</div>
+    <div class="confetti">🎊</div><div class="confetti">🎉</div>
+  </div>
+</div>
+            """,
+            unsafe_allow_html=True
+        )
+        st.balloons()
+        nome = st.session_state.get("nome") or st.session_state.get("usuario") or "Usuário"
+        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>
+            """,
+            unsafe_allow_html=True
+        )
+        COR_FRASE = "#0d6efd"
+        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>
+            """,
+            unsafe_allow_html=True
+        )
+
+# ===============================
+# MAIN
+# ===============================
+def main():
+    # Estados iniciais
+    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(top=True, sidebar=False)
+        login()
+        return
+
+    # 👥 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:
+            online_now = _get_active_users_count()
+        except Exception:
+            online_now = 0
+        st.sidebar.markdown(
+            f"""
+<div style="padding:8px 10px;margin-top:6px;margin-bottom:6px;border-radius:8px;
+            background:#1e293b; color:#e2e8f0; border:1px solid #334155;">
+    <span style="font-size:13px;">🟢 Online (últimos {_SESS_TTL_MIN} min)</span><br>
+    <span style="font-size:22px;font-weight:800;">{online_now}</span>
+</div>
+            """,
+            unsafe_allow_html=True
+        )
+
+    # 🔄 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(
+                "Intervalo (segundos) — 0 desativa",
+                min_value=0, max_value=3600,
+                value=int(st.session_state["__auto_refresh_interval_sec__"]),
+                step=5, key="__auto_refresh_input__"
+            )
+            if st.button("Aplicar intervalo", key="__btn_apply_auto_refresh__"):
+                st.session_state["__auto_refresh_interval_sec__"] = int(new_val)
+                try:
+                    if int(new_val) > 0:
+                        st.toast(f"Autoatualização ajustada para {int(new_val)}s.", icon="⏱️")
+                    else:
+                        st.toast("Autoatualização desativada.", icon="⛔")
+                except Exception:
+                    pass
+                st.rerun()
+    else:
+        with st.sidebar.expander("⏱️ Autoatualização", expanded=False):
+            new_val = st.number_input(
+                "Intervalo (segundos) — 0 desativa",
+                min_value=0, max_value=3600,
+                value=int(st.session_state["__auto_refresh_interval_sec__"]),
+                step=5, key="__auto_refresh_input__"
+            )
+            if st.button("Aplicar intervalo", key="__btn_apply_auto_refresh__"):
+                st.session_state["__auto_refresh_interval_sec__"] = int(new_val)
+                try:
+                    if int(new_val) > 0:
+                        st.toast(f"Autoatualização ajustada para {int(new_val)}s.", icon="⏱️")
+                    else:
+                        st.toast("Autoatualização desativada.", icon="⛔")
+                except Exception:
+                    pass
+                st.rerun()
+
+    usuario = st.session_state.usuario
+    perfil = (st.session_state.get("perfil") or "usuario").strip().lower()
+
+    # QUIZ
+    if not st.session_state.quiz_verificado:
+        if not quiz_respondido_hoje(usuario):
+            exibir_logo(top=True, sidebar=False)
+            quiz.main()
+            return
+        else:
+            st.session_state.quiz_verificado = True
+            st.rerun()
+
+    # SISTEMA LIBERADO
+    exibir_logo(top=True, sidebar=True)
+    _render_aviso_global_topbar()
+    _show_birthday_banner_if_needed()
+
+    st.sidebar.markdown("### Menu | 🎉 Carnaval 🎭 2026!")
+
+    # Banco ativo na sidebar
+    try:
+        banco_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_label}")
+    except Exception:
+        pass
+
+    # =========================
+    # 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:
+        ambiente_atual = current_db_choice() if _HAS_ROUTER else "prod"
+    except Exception:
+        ambiente_atual = "prod"
+
+    grupos_disponiveis = obter_grupos_disponiveis(
+        MODULES,
+        perfil=st.session_state.get("perfil", "usuario"),
+        usuario=st.session_state.get("usuario"),
+        ambiente=ambiente_atual,
+        verificar_permissao=verificar_permissao
+    )
+
+    if not grupos_disponiveis:
+        st.sidebar.selectbox("Selecione a operação:", ["Em desenvolvimento"], index=0)
+        st.warning("Nenhuma operação disponível para seu perfil/ambiente neste momento.")
+        return
+
+    grupo_escolhido = st.sidebar.selectbox("Selecione a operação:", grupos_disponiveis)
+
+    opcoes = obter_modulos_para_grupo(
+        MODULES, grupo_escolhido, termo_busca,
+        perfil=st.session_state.get("perfil", "usuario"),
+        usuario=st.session_state.get("usuario"),
+        ambiente=ambiente_atual,
+        verificar_permissao=verificar_permissao
+    )
+
+    with st.sidebar.expander("🔧 Diagnóstico do menu", expanded=False):
+        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_relatorio
+    try:
+        mod_outlook = MODULES.get("outlook_relatorio")
+        if mod_outlook:
+            mesmo_grupo = (mod_outlook.get("grupo") == grupo_escolhido)
+            perfil_ok = verificar_permissao(
+                perfil=st.session_state.get("perfil", "usuario"),
+                modulo_key="outlook_relatorio",
+                usuario=st.session_state.get("usuario"),
+                ambiente=ambiente_atual
+            )
+            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"))]
+    except Exception:
+        pass
+
+    # Failsafe repositorio_load
+    try:
+        mod_repo = MODULES.get("repositorio_load")
+        if mod_repo:
+            mesmo_grupo_r = (mod_repo.get("grupo") == grupo_escolhido)
+            perfil_ok_r = verificar_permissao(
+                perfil=st.session_state.get("perfil", "usuario"),
+                modulo_key="repositorio_load",
+                usuario=st.session_state.get("usuario"),
+                ambiente=ambiente_atual
+            )
+            ja_nas_opcoes_r = any(mid == "repositorio_load" for mid, _ in (opcoes or []))
+            passa_busca_r = (not termo_busca) or (termo_busca in mod_repo.get("label", "").strip().lower())
+            if mesmo_grupo_r and perfil_ok_r and not ja_nas_opcoes_r and passa_busca_r:
+                opcoes = (opcoes or []) + [("repositorio_load", mod_repo.get("label", "Repositório Load"))]
+    except Exception:
+        pass
+
+    if not opcoes:
+        st.sidebar.selectbox("Selecione o módulo:", ["Em desenvolvimento"], index=0)
+        st.warning(f"A operação '{grupo_escolhido}' está em desenvolvimento.")
+        return
+
+    # ============================================================
+    # 🔒 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:
+            target_label = next(lbl for mid, lbl in opcoes if mid == target)
+            st.session_state["mod_select_label"] = target_label
+        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]
+
+    escolha_label = st.sidebar.selectbox(
+        "Selecione o módulo:",
+        labels,
+        index=labels.index(st.session_state["mod_select_label"]),
+        key="mod_select_label"
+    )
+
+    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 quando em Inbox/Admin/Outlook/Formulário/Recebimento
+    try:
+        from streamlit_autorefresh import st_autorefresh
+        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 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"):
+        if st.sidebar.button("🚪 Sair (Logout)"):
+            logout()
+
+    st.divider()
+
+    # ------------------------- Roteamento -------------------------
+    if pagina_id == "formulario":
+        formulario.main()
+    elif pagina_id == "consulta":
+        consulta.main()
+    elif pagina_id == "relatorio":
+        relatorio.main()
+    elif pagina_id == "ranking":
+        ranking.main()
+    elif pagina_id == "quiz":
+        quiz.main()
+        ranking.main()
+    elif pagina_id == "quiz_admin":
+        quiz_admin.main()
+    elif pagina_id == "usuarios":
+        usuarios_admin.main()
+    elif pagina_id == "administracao":
+        administracao.main()
+    elif pagina_id == "videos":
+        videos.main()
+    elif pagina_id == "auditoria":
+        auditoria.main()
+    elif pagina_id == "auditoria_cleanup":
+        auditoria_cleanup.main()
+    elif pagina_id == "importacao":
+        importar_excel.main()
+    elif pagina_id == "calendario":
+        calendario.main()
+    elif pagina_id == "jogos":
+        st.session_state.setdefault("pontuacao", 0)
+        st.session_state.setdefault("rodadas", 0)
+        st.session_state.setdefault("ultimo_resultado", None)
+        jogos.main()
+    elif pagina_id == "temporario":
+        db_tools.main()
+    elif pagina_id == "db_admin":
+        db_admin.main()
+    elif pagina_id == "db_monitor":
+        db_monitor.main()
+    elif pagina_id == "operacao":
+        operacao.main()
+    elif pagina_id == "resposta":  # 📬 Admin
+        resposta.main()
+    elif pagina_id == "db_export_import":
+        db_export_import.main()
+    elif pagina_id == "produtividade_especialista":
+        produtividade_especialista.main()
+    elif pagina_id == "outlook_relatorio":
+        outlook_relatorio.main()
+    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:
+            sugestoes_usuario.main()
+    elif pagina_id == "repositorio_load":
+        repositorio_load.main()
+    elif pagina_id == "rnc":
+        rnc.pagina()
+    elif pagina_id == "rnc_listagem":
+        rnc_listagem.pagina()
+    elif pagina_id == "rnc_relatorio":
+        rnc_relatorio.pagina()
+    elif pagina_id == "repo_rnc":
+        repo_rnc.pagina()
+    elif pagina_id == "recebimento":
+        recebimento.main()
+
+    # ------------------------------------------------------
+    # ℹ️ 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("""
+**Bem-vindo!**  
+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.
+""")
+        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 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()
+    # -------------------------
+    # Desenvolvedor e versão
+    # -------------------------
+    if st.session_state.get("logado") and st.session_state.get("email"):
+        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
+    )
+
+
+
+
+
+
+
+
+
+
+
+
+

app_outlook.py

@@ -0,0 +1,315 @@
+
+# -*- coding: utf-8 -*-
+import streamlit as st
+import pandas as pd
+from datetime import datetime, timedelta, date
+import io
+import pythoncom  # ✅ necessário para inicializar/finalizar COM em cada operação
+
+st.set_page_config(page_title="Relatório de E-mails • Outlook Desktop", layout="wide")
+
+
+# ==============================
+# Utilitários de exportação/indicadores
+# ==============================
+def build_downloads(df: pd.DataFrame, base_name: str):
+    """Cria botões de download (CSV, Excel e PDF) para o DataFrame."""
+    if df.empty:
+        st.warning("Nenhum dado para exportar.")
+        return
+
+    # CSV
+    csv_buf = io.StringIO()
+    df.to_csv(csv_buf, index=False, encoding="utf-8-sig")
+    st.download_button(
+        "⬇️ Baixar CSV",
+        data=csv_buf.getvalue(),
+        file_name=f"{base_name}.csv",
+        mime="text/csv",
+    )
+
+    # Excel
+    xlsx_buf = io.BytesIO()
+    with pd.ExcelWriter(xlsx_buf, engine="openpyxl") as writer:
+        df.to_excel(writer, index=False, sheet_name="Relatorio")
+    xlsx_buf.seek(0)
+    st.download_button(
+        "⬇️ Baixar Excel",
+        data=xlsx_buf,
+        file_name=f"{base_name}.xlsx",
+        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    )
+
+    # PDF (resumo com até 100 linhas para leitura confortável)
+    try:
+        from reportlab.lib.pagesizes import A4, landscape
+        from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer
+        from reportlab.lib import colors
+        from reportlab.lib.styles import getSampleStyleSheet
+
+        pdf_buf = io.BytesIO()
+        doc = SimpleDocTemplate(
+            pdf_buf,
+            pagesize=landscape(A4),
+            rightMargin=20, leftMargin=20, topMargin=20, bottomMargin=20
+        )
+        styles = getSampleStyleSheet()
+        story = []
+
+        title = Paragraph(f"Relatório de E-mails — {base_name}", styles["Title"])
+        story.append(title)
+        story.append(Spacer(1, 12))
+
+        # Limita tabela para evitar PDFs gigantes
+        df_show = df.copy().head(100)
+        data_table = [list(df_show.columns)] + df_show.astype(str).values.tolist()
+        table = Table(data_table, repeatRows=1)
+        table.setStyle(TableStyle([
+            ("BACKGROUND", (0,0), (-1,0), colors.HexColor("#E9ECEF")),
+            ("TEXTCOLOR", (0,0), (-1,0), colors.HexColor("#212529")),
+            ("GRID", (0,0), (-1,-1), 0.25, colors.HexColor("#ADB5BD")),
+            ("FONTNAME", (0,0), (-1,0), "Helvetica-Bold"),
+            ("FONTNAME", (0,1), (-1,-1), "Helvetica"),
+            ("FONTSIZE", (0,0), (-1,-1), 9),
+            ("ALIGN", (0,0), (-1,-1), "LEFT"),
+            ("VALIGN", (0,0), (-1,-1), "MIDDLE"),
+        ]))
+        story.append(table)
+
+        doc.build(story)
+        pdf_buf.seek(0)
+
+        st.download_button(
+            "⬇️ Baixar PDF",
+            data=pdf_buf,
+            file_name=f"{base_name}.pdf",
+            mime="application/pdf",
+        )
+    except Exception as e:
+        st.info(f"PDF: não foi possível gerar o arquivo (ReportLab). Detalhe: {e}")
+
+
+def render_indicators(df: pd.DataFrame, dt_col_name: str):
+    """Exibe indicadores simples (top remetentes, distribuição por dia)."""
+    if df.empty:
+        return
+    st.subheader("📊 Indicadores")
+    col1, col2 = st.columns(2)
+    with col1:
+        st.write("**Top Remetentes (Top 10)**")
+        st.dataframe(
+            df["Remetente"].value_counts().head(10).rename("Qtd").to_frame(),
+            use_container_width=True,
+        )
+    with col2:
+        st.write("**Mensagens por Dia**")
+        if dt_col_name in df.columns:
+            _dt = pd.to_datetime(df[dt_col_name], errors="coerce")
+            por_dia = _dt.dt.date.value_counts().sort_index().rename("Qtd")
+            st.dataframe(por_dia.to_frame(), use_container_width=True)
+
+
+# ==============================
+# Outlook Desktop (Windows) — COM-safe helpers
+# ==============================
+def _list_folders_desktop(root_folder, prefix=""):
+    """Recursão local (já com root_folder pronto) — retorna caminhos completos de subpastas."""
+    paths = []
+    try:
+        for i in range(1, root_folder.Folders.Count + 1):
+            f = root_folder.Folders.Item(i)
+            full_path = prefix + f.Name
+            paths.append(full_path)
+            # recursão
+            try:
+                paths.extend(_list_folders_desktop(f, prefix=full_path + "\\"))
+            except Exception:
+                pass
+    except Exception:
+        pass
+    return paths
+
+
+def safe_list_all_folders():
+    """
+    ✅ Inicializa COM, conecta no Outlook e retorna TODOS os caminhos de pastas
+    da caixa padrão. Finaliza COM ao terminar. Evita 'CoInitialize não foi chamado'.
+    """
+    try:
+        import win32com.client
+        pythoncom.CoInitialize()  # inicializa COM
+        outlook = win32com.client.Dispatch("Outlook.Application").GetNamespace("MAPI")
+        root_mailbox = outlook.Folders.Item(1)  # índice da caixa de correio padrão
+        return _list_folders_desktop(root_mailbox, prefix="")
+    except Exception as e:
+        st.sidebar.info(f"Não foi possível listar pastas automaticamente ({e}). Informe manualmente abaixo.")
+        return []
+    finally:
+        try:
+            pythoncom.CoUninitialize()  # finaliza COM
+        except Exception:
+            pass
+
+
+def _get_folder_by_path(root_folder, path: str):
+    parts = [p for p in path.split("\\") if p]
+    folder = root_folder.Folders.Item(parts[0])
+    for p in parts[1:]:
+        folder = folder.Folders.Item(p)
+    return folder
+
+
+def _read_folder_items(folder, dias: int, filtro_remetente: str = "") -> pd.DataFrame:
+    """Lê e-mails de uma pasta específica e retorna DataFrame."""
+    items = folder.Items
+    items.Sort("[ReceivedTime]", True)  # decrescente
+    dt_from = (datetime.now() - timedelta(days=dias)).strftime("%m/%d/%Y %H:%M %p")
+    try:
+        items = items.Restrict(f"[ReceivedTime] >= '{dt_from}'")
+    except Exception:
+        # Alguns ambientes podem falhar no Restrict; segue sem filtro temporal
+        pass
+
+    rows = []
+    for mail in items:
+        try:
+            if getattr(mail, "Class", None) != 43:  # 43 = MailItem
+                continue
+            try:
+                sender = mail.SenderEmailAddress or mail.Sender.Name
+            except Exception:
+                sender = getattr(mail, "SenderName", None)
+
+            # Filtro opcional por remetente
+            if filtro_remetente and sender:
+                if filtro_remetente.lower() not in str(sender).lower():
+                    continue
+
+            anexos = mail.Attachments.Count if hasattr(mail, "Attachments") else 0
+            tamanho_kb = round(mail.Size / 1024, 1) if hasattr(mail, "Size") else None
+
+            rows.append({
+                "Pasta": folder.Name,
+                "Assunto": mail.Subject,
+                "Remetente": sender,
+                "RecebidoEm": mail.ReceivedTime.strftime("%Y-%m-%d %H:%M"),
+                "Anexos": anexos,
+                "TamanhoKB": tamanho_kb,
+                "Importancia": str(getattr(mail, "Importance", "")),  # 0 baixa, 1 normal, 2 alta
+                "Categoria": getattr(mail, "Categories", "") or "",
+                "Lido": bool(getattr(mail, "UnRead", False) == False),
+            })
+        except Exception as e:
+            rows.append({
+                "Pasta": folder.Name, "Assunto": f"[ERRO] {e}", "Remetente": "",
+                "RecebidoEm": "", "Anexos": "", "TamanhoKB": "", "Importancia": "", "Categoria": "", "Lido": ""
+            })
+    return pd.DataFrame(rows)
+
+
+def gerar_relatorio_outlook_desktop_multi(pastas: list[str], dias: int, filtro_remetente: str = "") -> pd.DataFrame:
+    """
+    ✅ Envolve toda operação COM: inicializa, lê e finaliza.
+    Evita o erro 'CoInitialize não foi chamado.'
+    """
+    try:
+        import win32com.client
+        pythoncom.CoInitialize()  # inicializa COM
+        outlook = win32com.client.Dispatch("Outlook.Application").GetNamespace("MAPI")
+        root = outlook.Folders.Item(1)  # ajuste o índice se tiver múltiplas caixas
+    except Exception as e:
+        st.error(f"Falha ao conectar ao Outlook/pywin32: {e}")
+        return pd.DataFrame()
+
+    frames = []
+    try:
+        for path in pastas:
+            try:
+                folder = _get_folder_by_path(root, path)
+                df = _read_folder_items(folder, dias, filtro_remetente=filtro_remetente)
+                df["PastaPath"] = path
+                frames.append(df)
+            except Exception as e:
+                st.warning(f"Não foi possível ler a pasta '{path}': {e}")
+        return pd.concat(frames, ignore_index=True) if frames else pd.DataFrame()
+    finally:
+        try:
+            pythoncom.CoUninitialize()  # finaliza COM
+        except Exception:
+            pass
+
+
+# ==============================
+# UI — Streamlit (seleção de múltiplas pastas)
+# ==============================
+st.title("📧 Relatório de E-mails • Outlook Desktop (Windows)")
+st.caption("Escolha **uma ou várias pastas** da sua Caixa de Entrada, defina o período, filtre por remetente (opcional) e gere o relatório.")
+
+st.sidebar.header("Configurações")
+dias = st.sidebar.slider("Período (últimos N dias)", min_value=1, max_value=365, value=30)
+filtro_remetente = st.sidebar.text_input(
+    "Filtrar por remetente (opcional)",
+    value="",
+    placeholder='Ex.: "@fornecedor.com" ou "Fulano"'
+)
+apenas_inbox = st.sidebar.checkbox("Mostrar somente pastas sob Inbox", value=True)
+
+# Tentar listar todas as pastas (COM-safe)
+todas_pastas = safe_list_all_folders()
+
+# Filtrar apenas pastas sob Inbox (Caixa de Entrada), se marcado
+if todas_pastas:
+    if apenas_inbox:
+        opcoes_base = [p for p in todas_pastas if p.lower().startswith("inbox")]
+    else:
+        opcoes_base = todas_pastas
+else:
+    opcoes_base = []
+
+# Busca por nome
+filtro_pasta = st.sidebar.text_input("Pesquisar pasta por nome:", value="")
+if filtro_pasta and opcoes_base:
+    opcoes = [p for p in opcoes_base if filtro_pasta.lower() in p.lower()]
+else:
+    opcoes = opcoes_base or []
+
+# Multiselect de pastas
+pastas_escolhidas = st.sidebar.multiselect(
+    "Selecione uma ou mais pastas:",
+    options=opcoes if opcoes else ["Inbox"],
+    default=(opcoes[:1] if opcoes else ["Inbox"]),
+    help="Use '\\' para subpastas. Ex.: Inbox\\Financeiro\\Notas"
+)
+
+# Campo manual adicional (para quem quer escrever um caminho específico não listado)
+pasta_manual_extra = st.sidebar.text_input(
+    "Adicionar caminho manual (opcional)",
+    value="",
+    placeholder="Inbox\\Financeiro\\Notas"
+)
+if pasta_manual_extra.strip():
+    pastas_escolhidas = list(set(pastas_escolhidas + [pasta_manual_extra.strip()]))
+
+# Botão gerar
+if st.sidebar.button("🔍 Gerar relatório"):
+    if not pastas_escolhidas:
+        st.error("Selecione ao menos uma pasta.")
+    else:
+        with st.spinner("Lendo e-mails do Outlook..."):
+            df = gerar_relatorio_outlook_desktop_multi(
+                pastas_escolhidas,
+                dias,
+                filtro_remetente=filtro_remetente
+            )
+
+        st.success(f"Relatório gerado ({len(df)} registros) a partir de {len(pastas_escolhidas)} pasta(s).")
+
+        st.subheader("📄 Resultado")
+        st.dataframe(df, use_container_width=True)
+        render_indicators(df, dt_col_name="RecebidoEm")
+
+        base_name = f"relatorio_outlook_desktop_{date.today()}"
+        build_downloads(df, base_name=base_name)
+
+st.markdown("---")
+st.caption("Dica: se você tem várias caixas postais, troque o índice em `outlook.Folders.Item(1)` para a caixa correta.")

audit_streamlit_project.py

@@ -0,0 +1,512 @@
+
+# -*- coding: utf-8 -*-
+"""
+Auditor de projeto Streamlit — chaves duplicadas, estrutura e relacionamentos.
+
+Verifica:
+1) Chaves duplicadas em st.form/st.button/st.download_button.
+2) Widgets sem 'key' (risco em loops).
+3) Imports faltantes no app.py para módulos usados no roteamento.
+4) Cobertura MODULES ↔ Roteamento (entries sem rota e rotas sem entry).
+5) Arquivos de módulos inexistentes e módulos sem main().
+6) Imports não usados.
+7) Ciclos de importação entre arquivos .py (somente locais).
+8) Emite relatório em console e JSON.
+
+Uso:
+    python audit_streamlit_project.py
+    python audit_streamlit_project.py --root . --app app.py --modules modules_map.py --exclude venv .venv .git
+
+Saída JSON:
+    .audit_report.json (na raiz especificada)
+"""
+import os
+import re
+import ast
+import json
+import argparse
+from collections import defaultdict
+
+# -----------------------
+# Util — File discovery
+# -----------------------
+def find_python_files(root, exclude_dirs=None):
+    exclude_dirs = set(exclude_dirs or [])
+    for dirpath, dirnames, filenames in os.walk(root):
+        # filtra diretorios ignorados
+        dirnames[:] = [
+            d for d in dirnames
+            if os.path.join(dirpath, d) not in {os.path.join(root, ex) for ex in exclude_dirs}
+            and d not in exclude_dirs
+        ]
+        for fn in filenames:
+            if fn.endswith(".py"):
+                yield os.path.join(dirpath, fn)
+
+def read_text(path):
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            return f.read()
+    except Exception:
+        try:
+            with open(path, "r", encoding="latin-1") as f:
+                return f.read()
+        except Exception:
+            return ""
+
+def parse_ast(path):
+    src = read_text(path)
+    if not src:
+        return None, ""
+    try:
+        tree = ast.parse(src, filename=path)
+        return tree, src
+    except Exception:
+        return None, src
+
+# -----------------------
+# Scan — Streamlit keys
+# -----------------------
+KEY_PATTERNS = {
+    "form_literal": re.compile(r'st\.form\(\s*\'"[\'"]'),
+    "button_key": re.compile(r'st\.button\([^)]*key\s*=\s*\'"[\'"]'),
+    "download_key": re.compile(r'st\.download_button\([^)]*key\s*=\s*\'"[\'"]'),
+}
+# widgets sem key (para alertar)
+MISSING_KEY_PATTERNS = {
+    "button_no_key": re.compile(r'st\.button\((?![^)]*key\s*=)'),
+    "download_no_key": re.compile(r'st\.download_button\((?![^)]*key\s*=)'),
+}
+
+def scan_duplicate_and_missing_keys(file_path):
+    dups = defaultdict(list)
+    missing = defaultdict(list)
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            for i, line in enumerate(f, 1):
+                # dup keys
+                for _, pat in KEY_PATTERNS.items():
+                    for m in pat.finditer(line):
+                        dups[m.group(1)].append(i)
+                # missing key warnings
+                for name, pat in MISSING_KEY_PATTERNS.items():
+                    if pat.search(line):
+                        missing[name].append(i)
+    except Exception:
+        pass
+    dup_filtered = {k: v for k, v in dups.items() if len(v) > 1}
+    return dup_filtered, missing
+
+# -----------------------
+# AST helpers — imports
+# -----------------------
+def extract_imports_defs_calls(tree):
+    """
+    Retorna:
+      imports: { alias_ou_nome -> modulo_base }
+      used_names: set de nomes referenciados
+      defs: set de nomes de funções definidas
+      calls_main: set de nomes/lvalues em chamadas *.main()
+    """
+    imports = {}           # alias -> base_module
+    used_names = set()
+    defs = set()
+    calls_main = set()
+
+    class V(ast.NodeVisitor):
+        def visit_Import(self, node):
+            for alias in node.names:
+                base = alias.name.split(".")[0]
+                asname = alias.asname or alias.name
+                asname = asname.split(".")[0]
+                imports[asname] = base
+
+        def visit_ImportFrom(self, node):
+            if node.module:
+                base = node.module.split(".")[0]
+                for alias in node.names:
+                    asname = alias.asname or alias.name
+                    imports[asname] = base
+
+        def visit_FunctionDef(self, node):
+            defs.add(node.name)
+            self.generic_visit(node)
+
+        def visit_Name(self, node):
+            used_names.add(node.id)
+
+        def visit_Attribute(self, node):
+            # captura padrão X.main(...)
+            if isinstance(node.ctx, ast.Load) and getattr(node, "attr", None) == "main":
+                if isinstance(node.value, ast.Name):
+                    calls_main.add(node.value.id)
+                else:
+                    # pkg.sub.main -> tenta achar o nome raiz
+                    root = node.value
+                    while isinstance(root, ast.Attribute):
+                        root = root.value
+                    if isinstance(root, ast.Name):
+                        calls_main.add(root.id)
+            self.generic_visit(node)
+
+    if tree:
+        V().visit(tree)
+    return imports, used_names, defs, calls_main
+
+# -----------------------
+# modules_map.py — parse
+# -----------------------
+def load_modules_map(modules_map_path):
+    """
+    Extrai:
+      - route_keys: chaves top-level do dict MODULES (ex.: "consulta", "operacao"...)
+      - internal_keys: valores do campo "key" dentro de cada entrada
+    """
+    route_keys = set()
+    internal_keys = set()
+    src = read_text(modules_map_path)
+    if not src:
+        return route_keys, internal_keys
+    # chaves top-level (aproximação): linhas com "  \"nome\": {"
+    for m in re.finditer(r'^[ \t]*"([^"]+)"\s*:\s*\{', src, re.MULTILINE):
+        route_keys.add(m.group(1))
+    # field "key": "valor"
+    for m in re.finditer(r'"key"\s*:\s*"([^"]+)"', src):
+        internal_keys.add(m.group(1))
+    return route_keys, internal_keys
+
+# -----------------------
+# Roteamento em app.py
+# -----------------------
+def extract_routing(app_src):
+    """
+    Busca padrões:
+      if/elif pagina_id == "consulta":
+          consulta.main()
+    Retorna lista de tuplas: (route_key, called_module_name)
+    """
+    routes = []
+
+    # bloco "if" inicial
+    m_if = re.search(
+        r'if\s+pagina_id\s*==\s*\'"[\'"]\s*:\s*(.*?)\n\s*(?:elif|#|$)',
+        app_src, re.DOTALL
+    )
+    if m_if:
+        route = m_if.group(1)
+        block = m_if.group(2)
+        called = None
+        cm = re.search(r'([A-Za-z_][A-Za-z0-9_]*)\s*\.\s*main\s*\(', block)
+        if cm:
+            called = cm.group(1)
+        routes.append((route, called))
+
+    # blocos "elif"
+    for m in re.finditer(
+        r'elif\s+pagina_id\s*==\s*\'"[\'"]\s*:\s*(.*?)\n\s*(?:elif|#|$)',
+        app_src, re.DOTALL
+    ):
+        route = m.group(1)
+        block = m.group(2)
+        called = None
+        cm = re.search(r'([A-Za-z_][A-Za-z0-9_]*)\s*\.\s*main\s*\(', block)
+        if cm:
+            called = cm.group(1)
+        routes.append((route, called))
+
+    return routes
+
+# -----------------------
+# Import graph & cycles
+# -----------------------
+def build_local_import_graph(py_files):
+    """
+    Monta grafo de importações locais: base_name -> { base_names importados }
+    """
+    # mapeia base_name -> arquivo
+    base_to_file = {}
+    for f in py_files:
+        base = os.path.splitext(os.path.basename(f))[0]
+        base_to_file[base] = f
+
+    graph = defaultdict(set)
+    for f in py_files:
+        base = os.path.splitext(os.path.basename(f))[0]
+        tree, _ = parse_ast(f)
+        imports, _, _, _ = extract_imports_defs_calls(tree)
+        for alias, base_mod in imports.items():
+            # se alias ou base_mod mapeia para arquivo local, considera aresta
+            target = None
+            if alias in base_to_file:
+                target = alias
+            elif base_mod in base_to_file:
+                target = base_mod
+            if target and target != base:
+                graph[base].add(target)
+    return graph
+
+def find_cycles(graph):
+    """
+    Detecta ciclos no grafo (lista de ciclos) — sem mutar o dicionário durante a iteração.
+    """
+    # Conjunto estático de nós (origens + destinos)
+    nodes = set(graph.keys())
+    for vs in graph.values():
+        nodes.update(vs)
+
+    visited = set()
+    stack = set()
+    cycles = []
+    path = []
+
+    def dfs(u):
+        visited.add(u)
+        stack.add(u)
+        path.append(u)
+        for v in graph.get(u, set()):  # <- sem criar chaves novas
+            if v not in visited:
+                dfs(v)
+            elif v in stack:
+                # ciclo encontrado — extrai subpath (v até fim) + fecha em v
+                if v in path:
+                    idx = len(path) - 1
+                    while idx >= 0 and path[idx] != v:
+                        idx -= 1
+                    if idx >= 0:
+                        cycle = path[idx:] + [v]
+                        cycles.append(cycle)
+        stack.remove(u)
+        path.pop()
+
+    for node in list(nodes):  # <- lista estática
+        if node not in visited:
+            dfs(node)
+
+    # Deduplicar ciclos por forma canônica (rotação mínima)
+    def canonical(cyc):
+        core = cyc[:-1]  # remove a repetição final
+        if not core:
+            return tuple()
+        rots = [tuple(core[i:] + core[:i]) for i in range(len(core))]
+        return min(rots)
+
+    seen = set()
+    unique = []
+    for cyc in cycles:
+        can = canonical(cyc)
+        if can and can not in seen:
+            seen.add(can)
+            unique.append(cyc)
+    return unique
+
+# -----------------------
+# Unused imports (aprox)
+# -----------------------
+def find_unused_imports(tree, imports, used_names):
+    """
+    Aproximação: se o alias importado não aparece em used_names -> não usado.
+    Não detecta usos por getattr/reflection; serve como guia inicial.
+    """
+    unused = []
+    for alias in imports.keys():
+        if alias not in used_names:
+            unused.append(alias)
+    return unused
+
+# -----------------------
+# Auditor principal
+# -----------------------
+def audit(root, app_path, modules_map_path, exclude_dirs=None, output_json=".audit_report.json"):
+    report = {
+        "duplicate_keys": {},          # file -> {key: [lines]}
+        "widgets_without_key": {},     # file -> {pattern: [lines]}
+        "missing_imports_in_app": [],  # [(route_key, called_module, reason)]
+        "routing_vs_modules": {
+            "routes_without_modules_entry": [],  # [route_key]
+            "modules_entry_without_route": [],   # [modules_map_key]
+        },
+        "module_files_missing": [],    # [module_name]
+        "modules_without_main": [],    # [module_name]
+        "unused_imports": {},          # file -> [alias]
+        "import_cycles": [],           # [[mod_a, mod_b, ..., mod_a]]
+    }
+
+    # 1) varrer arquivos
+    py_files = list(find_python_files(root, exclude_dirs=exclude_dirs))
+    # mapa base_name -> file
+    base_to_file = {os.path.splitext(os.path.basename(f))[0]: f for f in py_files}
+
+    # 2) chaves duplicadas e widgets sem key
+    for f in py_files:
+        dups, missing = scan_duplicate_and_missing_keys(f)
+        if dups:
+            report["duplicate_keys"][f] = dups
+        if any(missing.values()):
+            report["widgets_without_key"][f] = {k: v for k, v in missing.items() if v}
+
+    # 3) carrega app.py e modules_map.py
+    app_full = os.path.join(root, app_path)
+    modules_map_full = os.path.join(root, modules_map_path)
+    app_tree, app_src = parse_ast(app_full)
+    routes = extract_routing(app_src) if app_src else []
+
+    # imports e defs do app
+    app_imports, app_used, app_defs, app_calls_main = extract_imports_defs_calls(app_tree)
+
+    # 4) MODULES
+    route_keys_in_map, internal_keys_in_map = load_modules_map(modules_map_full)
+
+    # 5) checar import para cada rota
+    routes_set = set()
+    for route_key, called_module in routes:
+        routes_set.add(route_key)
+        if not called_module:
+            report["missing_imports_in_app"].append((route_key, None, "Bloco da rota não chama *.main()"))
+            continue
+        # foi importado?
+        imported_aliases = set(app_imports.keys())  # aliases disponíveis
+        if called_module not in imported_aliases:
+            report["missing_imports_in_app"].append((route_key, called_module, "Módulo não importado no app.py"))
+        # arquivo existe?
+        if called_module not in base_to_file:
+            # talvez seja alias de import (base module)
+            base_mod = app_imports.get(called_module)
+            if not (base_mod and base_mod in base_to_file):
+                report["module_files_missing"].append(called_module)
+        else:
+            # checar main()
+            t, _ = parse_ast(base_to_file[called_module])
+            _, _, defs, _ = extract_imports_defs_calls(t)
+            if "main" not in defs:
+                report["modules_without_main"].append(called_module)
+
+    # 6) cobertura rota vs modules_map
+    # - rotas no app que não existem no modules_map
+    for r in routes_set:
+        if r not in route_keys_in_map and r not in internal_keys_in_map:
+            report["routing_vs_modules"]["routes_without_modules_entry"].append(r)
+    # - entries no modules_map que não têm rota no app
+    for m in route_keys_in_map:
+        if m not in routes_set:
+            report["routing_vs_modules"]["modules_entry_without_route"].append(m)
+
+    # 7) unused imports por arquivo
+    for f in py_files:
+        t, _ = parse_ast(f)
+        imp, used, defs, calls_main = extract_imports_defs_calls(t)
+        unused = find_unused_imports(t, imp, used)
+        if unused:
+            report["unused_imports"][f] = unused
+
+    # 8) ciclos de import local
+    graph = build_local_import_graph(py_files)
+    cycles = find_cycles(graph)
+    report["import_cycles"] = cycles
+
+    # 9) remover duplicidades simples nas listas
+    report["missing_imports_in_app"] = list(dict.fromkeys(report["missing_imports_in_app"]))
+    report["module_files_missing"] = sorted(set(report["module_files_missing"]))
+    report["modules_without_main"] = sorted(set(report["modules_without_main"]))
+    report["routing_vs_modules"]["routes_without_modules_entry"] = sorted(
+        set(report["routing_vs_modules"]["routes_without_modules_entry"]))
+    report["routing_vs_modules"]["modules_entry_without_route"] = sorted(
+        set(report["routing_vs_modules"]["modules_entry_without_route"]))
+
+    # 10) saída
+    print("\n=== RELATÓRIO DE AUDITORIA — Streamlit Project ===")
+    # chaves duplicadas
+    print("\n[Chaves duplicadas]")
+    if not report["duplicate_keys"]:
+        print("  ✔ Nenhuma chave duplicada literal encontrada.")
+    else:
+        for file, dups in report["duplicate_keys"].items():
+            print(f"  - {file}")
+            for key, lines in dups.items():
+                print(f"      * key='{key}' duplicada em linhas {lines}")
+
+    # widgets sem key
+    print("\n[Widgets sem 'key' (atenção em loops)]")
+    if not report["widgets_without_key"]:
+        print("  ✔ Nenhum potencial widget sem key encontrado.")
+    else:
+        for file, miss in report["widgets_without_key"].items():
+            print(f"  - {file}")
+            for kind, lines in miss.items():
+                print(f"      * {kind}: linhas {lines}")
+
+    # imports faltantes e módulos
+    print("\n[Imports faltantes no app e módulos]")
+    if not report["missing_imports_in_app"]:
+        print("  ✔ Nenhum import faltante detectado no app.py (para rotas).")
+    else:
+        for route_key, called_module, reason in report["missing_imports_in_app"]:
+            print(f"  - rota='{route_key}' -> módulo='{called_module}' • {reason}")
+    if not report["module_files_missing"]:
+        print("  ✔ Nenhum arquivo de módulo ausente detectado.")
+    else:
+        print("  Arquivos de módulo não encontrados:", report["module_files_missing"])
+    if not report["modules_without_main"]:
+        print("  ✔ Todos os módulos localizados possuem main().")
+    else:
+        print("  Módulos sem main():", report["modules_without_main"])
+
+    # cobertura MODULES ↔ Roteamento
+    print("\n[Consistência: MODULES x Roteamento]")
+    rwm = report["routing_vs_modules"]
+    if not rwm["routes_without_modules_entry"]:
+        print("  ✔ Todas as rotas possuem entrada em modules_map.py (ou 'key' interna).")
+    else:
+        print("  Rotas sem entrada no modules_map.py:", rwm["routes_without_modules_entry"])
+    if not rwm["modules_entry_without_route"]:
+        print("  ✔ Todas as entradas do modules_map.py possuem rota no app.py.")
+    else:
+        print("  Entradas do modules_map.py sem rota no app.py:", rwm["modules_entry_without_route"])
+
+    # imports não usados
+    print("\n[Imports não usados (aprox.)]")
+    if not report["unused_imports"]:
+        print("  ✔ Nenhum import potencialmente não usado encontrado.")
+    else:
+        for file, unused in report["unused_imports"].items():
+            print(f"  - {file}: {unused}")
+
+    # ciclos
+    print("\n[Ciclos de importação]")
+    if not report["import_cycles"]:
+        print("  ✔ Nenhum ciclo de importação detectado.")
+    else:
+        for cyc in report["import_cycles"]:
+            print("  - ciclo:", " -> ".join(cyc))
+
+    # salvar JSON
+    out_path = os.path.join(root, output_json)
+    with open(out_path, "w", encoding="utf-8") as f:
+        json.dump(report, f, ensure_ascii=False, indent=2)
+    print(f"\n📄 Relatório JSON salvo em: {out_path}")
+
+    return report
+
+# -----------------------
+# CLI
+# -----------------------
+def cli():
+    p = argparse.ArgumentParser(description="Auditor de projeto Streamlit")
+    p.add_argument("--root", default=".", help="Raiz do projeto (default: .)")
+    p.add_argument("--app", default="app.py", help="Caminho do app.py (relativo à raiz)")
+    p.add_argument("--modules", default="modules_map.py", help="Caminho do modules_map.py (relativo à raiz)")
+    p.add_argument("--exclude", nargs="*", default=[".git", ".venv", "venv", "__pycache__", ".streamlit"],
+                   help="Pastas a excluir da varredura")
+    p.add_argument("--json", default=".audit_report.json", help="Nome do arquivo JSON de saída")
+    args = p.parse_args()
+
+    audit(
+        root=args.root,
+        app_path=args.app,
+        modules_map_path=args.modules,
+        exclude_dirs=args.exclude,
+        output_json=args.json
+    )
+
+if __name__ == "__main__":
+    cli()
+

auditoria.py

@@ -0,0 +1,100 @@
+
+import streamlit as st
+from banco import SessionLocal
+from models import LogAcesso, Usuario
+import pandas as pd
+from io import BytesIO
+import os
+
+# Debug opcional – confirma o banco em uso
+print("📂 BANCO LIDO NA AUDITORIA:", os.path.abspath("load.db"))
+
+
+def main():
+    st.title("🧾 Auditoria do Sistema Load")
+
+    db = SessionLocal()
+
+    try:
+        # =========================
+        # FILTRO POR PERFIL
+        # =========================
+        perfis = (
+            db.query(Usuario.perfil)
+            .distinct()
+            .order_by(Usuario.perfil)
+            .all()
+        )
+
+        lista_perfis = ["Todos"] + [p[0] for p in perfis]
+
+        perfil_selecionado = st.selectbox(
+            "Filtrar por perfil:",
+            lista_perfis
+        )
+
+        # =========================
+        # CONSULTA COM JOIN
+        # =========================
+        # ✅ Incluímos o e-mail do usuário na seleção
+        query = (
+            db.query(
+                LogAcesso.usuario,
+                Usuario.perfil,
+                Usuario.email,  # <-- novo
+                LogAcesso.acao,
+                LogAcesso.tabela,
+                LogAcesso.registro_id,
+                LogAcesso.data_hora
+            )
+            .join(Usuario, Usuario.usuario == LogAcesso.usuario)
+            .order_by(LogAcesso.data_hora.desc())
+        )
+
+        if perfil_selecionado != "Todos":
+            query = query.filter(Usuario.perfil == perfil_selecionado)
+
+        logs = query.all()
+
+        if not logs:
+            st.info("Nenhum registro encontrado.")
+            return
+
+        # =========================
+        # DATAFRAME FORMATADO
+        # =========================
+        dados = []
+        for l in logs:
+            # l = (usuario, perfil, email, acao, tabela, registro_id, data_hora)
+            dados.append({
+                "Usuário": l[0],
+                "Perfil": l[1],
+                "E-mail": l[2] or "—",  # ✅ e-mail pode ser nulo
+                "Ação": l[3],
+                "Tabela": l[4],
+                "Registro": l[5],
+                "Data": l[6].strftime("%d/%m/%Y"),
+                "Hora": l[6].strftime("%H:%M:%S"),
+            })
+
+        df = pd.DataFrame(dados)
+
+        st.dataframe(df, use_container_width=True)
+
+        # =========================
+        # EXPORTAÇÃO PARA EXCEL
+        # =========================
+        buffer = BytesIO()
+        with pd.ExcelWriter(buffer, engine="openpyxl") as writer:
+            df.to_excel(writer, index=False, sheet_name="Auditoria")
+
+        st.download_button(
+            label="📥 Exportar Auditoria para Excel",
+            data=buffer.getvalue(),
+            file_name="auditoria_sistema.xlsx",
+            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        )
+
+    finally:
+        db.close()
+

auditoria_cleanup.py

@@ -0,0 +1,103 @@
+
+import streamlit as st
+from datetime import datetime, timedelta
+from banco import SessionLocal
+from models import LogAcesso   # ✅ usar a tabela correta
+from utils_auditoria import registrar_log
+
+
+def main():
+    st.title("🧹 Limpeza de Logs de Auditoria")
+
+    st.markdown(
+        """
+        Este módulo permite excluir registros antigos de auditoria
+        para suavizar o banco de dados.
+        """
+    )
+
+    opcoes = {
+        "Último mês": 30,
+        "Últimos 2 meses": 60,
+        "Últimos 6 meses": 180,
+        "Últimos 12 meses": 365,
+        "Personalizado": None,
+    }
+
+    escolha = st.selectbox("📅 Escolha o período:", list(opcoes.keys()))
+
+    data_inicio = None
+    data_fim = datetime.now()
+
+    if escolha != "Personalizado":
+        dias = opcoes[escolha]
+        data_inicio = datetime.now() - timedelta(days=dias)
+    else:
+        col1, col2 = st.columns(2)
+        with col1:
+            data_inicio = st.date_input("Data inicial")
+        with col2:
+            data_fim = st.date_input("Data final")
+        data_inicio = datetime.combine(data_inicio, datetime.min.time())
+        data_fim = datetime.combine(data_fim, datetime.max.time())
+
+    st.info(f"🗓️ Registros de auditoria entre {data_inicio.date()} e {data_fim.date()} serão excluídos.")
+
+    st.divider()
+
+    # ✅ Prévia do total (opcional, ajuda na decisão)
+    with SessionLocal() as db:
+        total_prev = (
+            db.query(LogAcesso)
+            .filter(LogAcesso.data_hora >= data_inicio, LogAcesso.data_hora <= data_fim)
+            .count()
+        )
+    st.info(f"🔎 Prévia: {total_prev} registro(s) serão removidos no período selecionado.")
+
+    # ✅ Etapa de confirmação via caixa de seleção
+    st.warning(
+        "⚠️ **Atenção:** Todos os registros de auditoria no período selecionado serão apagados.\n\n"
+        "Confirme abaixo para prosseguir."
+    )
+    confirmacao = st.selectbox("Confirmar exclusão?", ["Não", "SIM"], index=0)
+
+    # Botão de exclusão (só prossegue se confirmação for SIM)
+    if st.button("❌ Excluir registros de auditoria"):
+        if confirmacao != "SIM":
+            st.error("Operação cancelada. Se desejar prosseguir, selecione **SIM** na confirmação.")
+            return
+
+        with SessionLocal() as db:
+            try:
+                registros = (
+                    db.query(LogAcesso)
+                    .filter(LogAcesso.data_hora >= data_inicio, LogAcesso.data_hora <= data_fim)
+                    .all()
+                )
+
+                total = len(registros)
+
+                if total == 0:
+                    st.warning("Nenhum registro encontrado para exclusão.")
+                    return
+
+                for r in registros:
+                    db.delete(r)
+
+                db.commit()
+
+                registrar_log(
+                    usuario=st.session_state.get("usuario"),
+                    acao=f"Excluiu {total} registros de auditoria entre {data_inicio.date()} e {data_fim.date()}",
+                    tabela="log_acesso",
+                    registro_id=None
+                )
+
+                st.success(f"🎉 {total} registro(s) de auditoria foram excluídos com sucesso!")
+
+            except Exception as e:
+                db.rollback()
+                st.error(f"❌ Erro ao excluir registros: {e}")
+
+
+

auto_capture.py

@@ -0,0 +1,319 @@
+
+# -*- coding: utf-8 -*-
+"""
+auto_capture.py — Captura screenshots de todas as telas do app Streamlit e monta um PPTX.
+
+Recursos:
+• Login automático (usuário/senha + escolha do banco)
+• Bypass do Quiz (clica: “Voltar ao sistema”, “Finalizar”, “Continuar”, se visível)
+• Seletores robustos para st.selectbox (procura pelo label visível)
+• Captura pós-login/pós-quiz, por grupo e por módulo
+• Artefatos de debug (HTML + PNG) quando algo falha
+• Sanitização de nomes de arquivo (compatível com Windows)
+• Geração de PPTX com um slide por módulo capturado
+
+Requisitos:
+pip install playwright python-pptx python-dotenv
+playwright install
+"""
+
+import os
+import re
+import traceback
+from datetime import datetime
+from dotenv import load_dotenv
+
+# Carrega .env
+load_dotenv()
+
+APP_URL      = os.getenv("APP_URL", "http://localhost:8501")
+LOGIN_USER   = os.getenv("LOGIN_USER", "admin")
+LOGIN_PASS   = os.getenv("LOGIN_PASS", "admin123")
+BANK_CHOICE  = os.getenv("BANK_CHOICE", "prod")   # prod | test | treinamento
+
+SCREEN_DIR   = os.getenv("SCREEN_DIR", "./screenshots")
+OUTPUT_PPTX  = os.getenv("OUTPUT_PPTX", "./demo_funcionalidades.pptx")
+
+HEADLESS     = os.getenv("AUTOCAPTURE_HEADLESS", "false").lower() == "true"
+VIEWPORT_W   = int(os.getenv("AUTOCAPTURE_VIEWPORT_W", "1440"))
+VIEWPORT_H   = int(os.getenv("AUTOCAPTURE_VIEWPORT_H", "900"))
+
+# Importa seu mapa de módulos (aproveita rótulos e grupos)
+try:
+    from modules_map import MODULES
+except Exception:
+    MODULES = {}
+    print("⚠️ Não consegui importar modules_map.py. Ele deve estar no mesmo diretório do script.")
+
+# PowerPoint
+from pptx import Presentation
+from pptx.util import Inches, Pt
+from pptx.dml.color import RGBColor
+
+# Playwright
+from playwright.sync_api import sync_playwright
+
+
+# -----------------------------------------------------------------------------
+# Helpers
+# -----------------------------------------------------------------------------
+def ensure_dir(path: str):
+    os.makedirs(path, exist_ok=True)
+
+def sanitize(s: str) -> str:
+    """Remove/normaliza caracteres inválidos de nomes (Windows-safe)."""
+    s = re.sub(r"[\\/:*?\"<>|]", "_", s)       # remove proibidos
+    s = re.sub(r"\s+", "_", s.strip())         # espaços -> _
+    return s
+
+def bank_label(choice: str) -> str:
+    return {
+        "prod": "Banco 1 (📗 Produção)",
+        "test": "Banco 2 (📕 Teste)",
+        "treinamento": "Banco 3 (📘 Treinamento)",
+    }.get(choice, choice)
+
+def save_artifacts_on_fail(page, tag="fail"):
+    """Salva HTML e screenshot quando algo dá errado."""
+    ensure_dir(SCREEN_DIR)
+    tag = sanitize(tag)
+    try:
+        html_path = os.path.join(SCREEN_DIR, f"{tag}_page.html")
+        img_path  = os.path.join(SCREEN_DIR, f"{tag}_page.png")
+        with open(html_path, "w", encoding="utf-8") as f:
+            f.write(page.content())
+        page.screenshot(path=img_path, full_page=True)
+        print(f"📝 Artefatos salvos: {html_path}, {img_path}")
+    except Exception as e:
+        print(f"⚠️ Falha ao salvar artefatos de erro: {e}")
+
+def select_by_label(page, select_label: str, option_text: str):
+    """
+    Seleciona uma opção em um st.selectbox, procurando pelo label (texto visível).
+    • Varre todos os elementos com data-testid="stSelectbox"
+    • Encontra o que contém o label desejado (case-insensitive)
+    • Abre o combobox e clica na opção exata
+    """
+    boxes = page.locator('[data-testid="stSelectbox"]')
+    count = boxes.count()
+    if count == 0:
+        raise RuntimeError("Nenhum stSelectbox encontrado na página.")
+
+    found = False
+    for i in range(count):
+        box = boxes.nth(i)
+        try:
+            txt = box.inner_text().strip()
+        except Exception:
+            continue
+        if select_label.lower() in txt.lower():
+            box.locator('div[role="combobox"]').first.click()
+            page.locator('div[role="listbox"]').get_by_text(option_text, exact=True).click()
+            found = True
+            break
+
+    if not found:
+        raise RuntimeError(f"Selectbox com label '{select_label}' não encontrado.")
+
+def bypass_quiz(page):
+    """
+    Tenta sair da tela de Quiz, caso esteja bloqueando a navegação.
+    Procura ações típicas: 'Voltar ao sistema', 'Finalizar', 'Continuar'.
+    """
+    # 1) Voltar ao sistema
+    try:
+        if page.get_by_text("Voltar ao sistema").count() > 0:
+            page.get_by_text("Voltar ao sistema").click()
+            page.wait_for_timeout(600)
+            return
+    except Exception:
+        pass
+
+    # 2) Finalizar
+    try:
+        if page.get_by_role("button", name="Finalizar").count() > 0:
+            page.get_by_role("button", name="Finalizar").click()
+            page.wait_for_timeout(600)
+            return
+    except Exception:
+        pass
+
+    # 3) Continuar
+    try:
+        if page.get_by_role("button", name="Continuar").count() > 0:
+            page.get_by_role("button", name="Continuar").click()
+            page.wait_for_timeout(600)
+            return
+    except Exception:
+        pass
+
+    # 4) Se nada funcionar, salva artefatos para analisarmos o DOM real
+    save_artifacts_on_fail(page, "quiz_bypass")
+
+
+def do_login(page):
+    page.goto(APP_URL, timeout=60000)
+    page.wait_for_load_state("networkidle")
+    page.wait_for_timeout(800)
+
+    # Seleciona Banco (selectbox "Usar banco:")
+    try:
+        select_by_label(page, "Usar banco:", bank_label(BANK_CHOICE))
+    except Exception as e:
+        print(f"⚠️ Falha ao selecionar banco: {e}")
+        save_artifacts_on_fail(page, "select_bank")
+        # Fallback por texto simples (última tentativa)
+        try:
+            page.get_by_text("Usar banco:").click()
+            page.get_by_text(bank_label(BANK_CHOICE), exact=True).click()
+        except Exception:
+            pass
+
+    # Preenche credenciais
+    try:
+        page.get_by_label("Usuário").fill(LOGIN_USER)
+    except Exception:
+        page.locator('label:has-text("Usuário")').locator("xpath=..").locator('input').fill(LOGIN_USER)
+
+    try:
+        page.get_by_label("Senha").fill(LOGIN_PASS)
+    except Exception:
+        page.locator('label:has-text("Senha")').locator("xpath=..").locator('input').fill(LOGIN_PASS)
+
+    # Entrar
+    try:
+        page.get_by_role("button", name="Entrar").click()
+    except Exception:
+        page.get_by_text("Entrar").click()
+
+    page.wait_for_load_state("networkidle")
+    page.wait_for_timeout(1000)
+
+    # Captura pós-login
+    page.screenshot(path=os.path.join(SCREEN_DIR, "00_pos_login.png"), full_page=True)
+
+    # Bypass do Quiz (se existir)
+    bypass_quiz(page)
+
+    # Captura pós-quiz
+    page.screenshot(path=os.path.join(SCREEN_DIR, "01_pos_quiz.png"), full_page=True)
+
+
+def clear_search(page):
+    """Limpa campo 'Pesquisar módulo:' para não filtrar nada (opcional)."""
+    try:
+        page.get_by_label("Pesquisar módulo:").fill("")
+        page.wait_for_timeout(200)
+    except Exception:
+        # Fallback: tenta input na sidebar
+        try:
+            sb = page.locator('[data-testid="stSidebar"]').first
+            sb.locator('input').first.fill("")
+        except Exception:
+            pass
+
+
+def capture_all_screens():
+    ensure_dir(SCREEN_DIR)
+    screenshots = []
+
+    from playwright.sync_api import TimeoutError
+
+    with sync_playwright() as pw:
+        browser = pw.chromium.launch(headless=HEADLESS)
+        context = browser.new_context(viewport={"width": VIEWPORT_W, "height": VIEWPORT_H})
+        page = context.new_page()
+
+        # Login
+        do_login(page)
+
+        # Grupos
+        grupos = sorted({MODULES[mid].get("grupo", "Outros") for mid in MODULES}) if MODULES else []
+        if not grupos:
+            print("⚠️ MODULES está vazio. Não há módulos para capturar.")
+            save_artifacts_on_fail(page, "no_modules")
+            context.close(); browser.close()
+            return screenshots
+
+        for grupo in grupos:
+            try:
+                clear_search(page)
+                select_by_label(page, "Selecione a operação:", grupo)
+                page.wait_for_timeout(500)
+
+                gshot = os.path.join(SCREEN_DIR, f"{BANK_CHOICE}_grupo_{sanitize(grupo)}.png")
+                page.screenshot(path=gshot, full_page=True)
+                print(f"📸 Grupo: {grupo} → {gshot}")
+            except Exception as e:
+                print(f"⚠️ Falha ao selecionar grupo '{grupo}': {e}")
+                save_artifacts_on_fail(page, f"grupo_{grupo}")
+                continue
+
+            # Módulos do grupo
+            mod_ids = [mid for mid in MODULES if MODULES[mid].get("grupo", "Outros") == grupo]
+            for mid in mod_ids:
+                label = MODULES[mid].get("label", mid)
+                try:
+                    select_by_label(page, "Selecione o módulo:", label)
+                    page.wait_for_load_state("networkidle")
+                    page.wait_for_timeout(800)
+
+                    fname = f"{BANK_CHOICE}_{sanitize(grupo)}_{sanitize(mid)}.png"
+                    fpath = os.path.join(SCREEN_DIR, fname)
+                    page.screenshot(path=fpath, full_page=True)
+                    screenshots.append((mid, label, grupo, fpath))
+                    print(f"📸 Módulo: {label} → {fpath}")
+                except Exception as e:
+                    print(f"❌ Falha ao capturar módulo '{label}': {e}")
+                    save_artifacts_on_fail(page, f"mod_{mid}")
+                    traceback.print_exc()
+                    continue
+
+        context.close()
+        browser.close()
+
+    return screenshots
+
+
+def build_pptx(screens, out_path):
+    prs = Presentation()
+
+    # Slide de título
+    slide = prs.slides.add_slide(prs.slide_layouts[0])
+    slide.shapes.title.text = "Apresentação do Sistema (ARM LoadApp)"
+    subtitle = slide.placeholders[1].text_frame
+    subtitle.clear()
+    p = subtitle.paragraphs[0]
+    p.text = f"Ambiente: {bank_label(BANK_CHOICE)} | Gerado em {datetime.now().strftime('%d/%m/%Y %H:%M:%S')}"
+    p.font.size = Pt(14)
+
+    # Slides por módulo
+    for mid, label, grupo, fpath in screens:
+        layout = prs.slides.add_slide(prs.slide_layouts[5])  # Title Only
+        layout.shapes.title.text = f"{label} • {grupo}"
+        left, top, width = Inches(0.5), Inches(1.2), Inches(9)
+        try:
+            layout.shapes.add_picture(fpath, left, top, width=width)
+        except Exception:
+            tx = layout.shapes.add_textbox(left, top, Inches(9), Inches(1))
+            tf = tx.text_frame
+            tf.text = f"(Falha ao inserir imagem: {os.path.basename(fpath)})"
+            tf.paragraphs[0].font.color.rgb = RGBColor(200, 0, 0)
+
+    prs.save(out_path)
+    print(f"🎉 PPTX gerado: {out_path}")
+
+
+def main():
+    print(f"🚀 Captura em {APP_URL} | Banco: {BANK_CHOICE} ({bank_label(BANK_CHOICE)}) | headless={HEADLESS}")
+    ensure_dir(SCREEN_DIR)
+    screens = capture_all_screens()
+    if not screens:
+        print("⚠️ Nenhuma captura gerada. Veja os artefatos na pasta e revise seletores/menus.")
+        return
+    build_pptx(screens, OUTPUT_PPTX)
+
+
+if __name__ == "__main__":
+    main()
+

banco.py

@@ -0,0 +1,121 @@
+# -*- coding: utf-8 -*-
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, declarative_base
+import os
+from dotenv import load_dotenv
+import importlib
+
+# 🔒 Caminho absoluto do projeto
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+
+# Carrega variáveis de ambiente (.env) antes de ler DATABASE_URL
+load_dotenv()
+
+# ============================================================
+# 🔀 SUPORTE A DOIS BANCOS (Produção/Teste) COM FALLBACK
+# ============================================================
+# Tentamos usar o roteador (db_router.py). Se não existir ainda,
+# caímos no comportamento original usando apenas DATABASE_URL.
+try:
+    from db_router import (
+        get_engine as _router_get_engine,
+        get_session_factory as _router_get_session_factory,
+        SessionLocal as _router_SessionLocal,
+    )
+    _HAS_ROUTER = True
+except Exception:
+    _HAS_ROUTER = False
+
+# 🔧 Fallback: mesma lógica do seu módulo original — um único DATABASE_URL
+DATABASE_URL = os.getenv(
+    "DATABASE_URL",
+    f"sqlite:///{os.path.join(BASE_DIR, 'load.db')}"
+)
+
+engine_args = {
+    "echo": False,
+    "pool_pre_ping": True,
+}
+
+# Parâmetros específicos para SQLite (apenas se o fallback estiver ativo)
+if DATABASE_URL.startswith("sqlite"):
+    engine_args["connect_args"] = {"check_same_thread": False}
+
+# ============================================================
+# Engine / SessionLocal (com ou sem roteador)
+# ============================================================
+if _HAS_ROUTER:
+    # ✅ Usa engine e SessionLocal do banco ATIVO (Produção/Teste), conforme escolha no login
+    def get_engine():
+        return _router_get_engine()
+
+    def _session_factory():
+        return _router_get_session_factory()
+
+    # A SessionLocal do roteador já entrega sessões no banco ativo
+    SessionLocal = _router_SessionLocal
+
+else:
+    # ✅ Fallback: comportamento original com DATABASE_URL único
+    _engine = create_engine(DATABASE_URL, **engine_args)
+
+    def get_engine():
+        return _engine
+
+    _SessionFactory = sessionmaker(
+        autocommit=False,
+        autoflush=False,
+        bind=_engine,
+    )
+
+    def _session_factory():
+        return _SessionFactory
+
+    # Compatível com seu uso atual: SessionLocal() -> sessão
+    SessionLocal = _SessionFactory
+
+# ⚠️ Compatibilidade: expõe 'engine' resolvendo via get_engine()
+# Observação importante:
+# - Se trocar o banco após a importação deste módulo (via login),
+#   prefira sempre chamar get_engine() ou criar sessões com SessionLocal(),
+#   pois 'engine' abaixo é resolvido apenas uma vez (na importação).
+engine = get_engine()
+
+# ORM Base
+Base = declarative_base()
+
+# ============================================================
+# 🛠️ Utilitários (opcionais)
+# ============================================================
+def init_schema():
+    """
+    Cria/atualiza as tabelas no banco ATIVO.
+    • Com roteador: aplica no banco escolhido (Produção/Teste).
+    • Sem roteador: aplica no DATABASE_URL padrão.
+    Use em DEV/TESTE; em produção, prefira migrações (ex.: Alembic).
+    """
+    # Importa 'models' de forma tardia e segura (sem wildcard) para registrar todos os mapeamentos
+    # antes de criar as tabelas. Isso evita import circular no topo.
+    try:
+        importlib.import_module("models")
+    except ModuleNotFoundError:
+        # Se seus modelos estiverem em outro pacote/caminho, ajuste aqui:
+        # importlib.import_module("app.models")  # exemplo
+        raise
+
+    Base.metadata.create_all(bind=get_engine())
+
+def db_info() -> dict:
+    """
+    Retorna informações básicas do banco ativo (para debug/UX).
+    """
+    eng = get_engine()
+    try:
+        url = str(eng.url)
+    except Exception:
+        url = DATABASE_URL
+    return {
+        "url": url,
+        "using_router": _HAS_ROUTER,
+    }
+

bi.py

@@ -0,0 +1,74 @@
+import streamlit as st
+import streamlit.components.v1 as components
+from banco import SessionLocal
+from models import LogAcesso
+from datetime import datetime
+
+
+# =====================================================
+# AUDITORIA
+# =====================================================
+def registrar_auditoria(acao):
+    db = SessionLocal()
+    try:
+        db.add(LogAcesso(
+            usuario=st.session_state.get("usuario", "desconhecido"),
+            acao=acao,
+            tabela="bi",
+            data_hora=datetime.now()
+        ))
+        db.commit()
+    finally:
+        db.close()
+
+
+# =====================================================
+# APP PRINCIPAL
+# =====================================================
+def main():
+    st.title("📊 Business Intelligence")
+
+    st.caption("Indicadores e dashboards oficiais")
+
+    # 🔐 Auditoria de acesso
+    registrar_auditoria("ACESSO_BI")
+
+    # =====================================================
+    # SELEÇÃO DE DASHBOARD
+    # =====================================================
+    dashboards = {
+        "📈 Performance Operacional": {
+            "url": "https://app.powerbi.com/view?r=SEU_LINK_AQUI",
+            "height": 800
+        },
+        "📊 Qualidade e Erros": {
+            "url": "https://app.powerbi.com/view?r=SEU_LINK_AQUI",
+            "height": 800
+        },
+        "📦 Produtividade FPSO": {
+            "url": "https://app.powerbi.com/view?r=SEU_LINK_AQUI",
+            "height": 900
+        }
+    }
+
+    opcao = st.selectbox("Selecione o Dashboard", dashboards.keys())
+
+    dash = dashboards[opcao]
+
+    st.divider()
+
+    # =====================================================
+    # EMBED DO POWER BI
+    # =====================================================
+    components.html(
+        f"""
+        <iframe
+            width="100%"
+            height="{dash['height']}"
+            src="{dash['url']}"
+            frameborder="0"
+            allowfullscreen="true">
+        </iframe>
+        """,
+        height=dash["height"] + 20
+    )

cadastro_py.py

@@ -0,0 +1,28 @@
+from banco import SessionLocal
+from models import FPSO
+
+FPSO_PADRAO = [
+    "CDA", "CDP", "CDM", "ADG",
+    "ESS", "SEP", "CDI", "ATD", "CDS"
+]
+
+def main():
+    db = SessionLocal()
+    try:
+        existentes = {f.nome for f in db.query(FPSO).all()}
+
+        for nome in FPSO_PADRAO:
+            if nome not in existentes:
+                db.add(FPSO(nome=nome))
+
+        db.commit()
+        print("✅ FPSOs padrão inseridos com sucesso!")
+
+    finally:
+        db.close()
+
+
+if __name__ == "__main__":
+    main()
+
+

calendario.py

@@ -0,0 +1,708 @@
+
+# -*- coding: utf-8 -*-
+import streamlit as st
+from datetime import date, datetime, timedelta
+from typing import Dict, List
+from banco import SessionLocal
+from models import EventoCalendario
+from utils_permissoes import verificar_permissao
+from log import registrar_log
+from utils_datas import formatar_data_br
+
+# ⬇️ Componente de calendário
+from streamlit_calendar import calendar
+
+# =====================================================
+# 📅 CALENDÁRIO + CRONOGRAMA ANUAL (D-3 / D-2 / D-1 / D 🚢)
+# =====================================================
+
+# ------------------------------
+# ⚙️ Regras de embarque (fase/seed e passo)
+# ------------------------------
+# seed_day = dia (de Janeiro) usado como "D" inicial para o ano selecionado
+# step     = dias entre embarques (D → próximo D)
+REGRAS_FPSO = {
+    "ATD":  {"seed_day": 1, "step": 5},
+    "ADG":  {"seed_day": 1, "step": 5},
+    "CDM":  {"seed_day": 2, "step": 5},
+    "CDP":  {"seed_day": 2, "step": 5},
+    "CDS":  {"seed_day": 2, "step": 5},
+    "CDI":  {"seed_day": 5, "step": 5},  # (ACDI → CDI)
+    "CDA":  {"seed_day": 5, "step": 5},
+    "SEP":  {"seed_day": 4, "step": 4},  # sem dia vazio
+    "ESS":  {"seed_day": 3, "step": 7},  # blocos com pausa maior
+}
+
+# 🎨 Paleta
+COLOR_MAP = {
+    "D-3": "#00B050",  # verde
+    "D-2": "#FF0000",  # vermelho
+    "D-1": "#C00000",  # vermelho escuro
+    "D":   "#7F7F7F",  # cinza
+}
+
+EMOJI_NAVIO = " 🚢"  # adicionado aos títulos no dia D
+
+
+def _usuario_atual() -> str:
+    return (st.session_state.get("usuario") or "sistema")
+
+
+def _criar_evento_fc(title: str, dt: date, color: str, extra: Dict = None) -> dict:
+    """Monta um evento no formato FullCalendar/streamlit_calendar."""
+    ev = {
+        "id": f"auto::{title}::{dt.isoformat()}",
+        "title": title,
+        "start": dt.isoformat(),
+        "allDay": True,
+        "color": color,
+        "extendedProps": {"gerado_auto": True},
+    }
+    if extra:
+        ev["extendedProps"].update(extra)
+    return ev
+
+
+def _rotulo_antes_de_d(dias: int) -> str:
+    """Converte o deslocamento até D para rótulo: 0->D, 1->D-1, 2->D-2, 3->D-3, outros->''"""
+    if dias == 0:
+        return "D"
+    if dias in (1, 2, 3):
+        return f"D-{dias}"
+    return ""
+
+
+def _gerar_cronograma_ano(
+    ano: int,
+    fpsos_sel: List[str],
+    incluir_anteriores: bool = True,
+    apenas_D: bool = False,
+) -> List[dict]:
+    """
+    Gera eventos 'D-3/D-2/D-1/D 🚢' para TODO o ano.
+    - incluir_anteriores: inclui D-1..D-3 que caem no começo do ano (vindo do D-semente).
+    - apenas_D: se True, somente 'D 🚢'.
+    """
+    events = []
+    dt_ini = date(ano, 1, 1)
+    dt_fim = date(ano, 12, 31)
+
+    for fpso in fpsos_sel:
+        cfg = REGRAS_FPSO.get(fpso)
+        if not cfg:
+            continue
+        seed_day = max(1, min(cfg["seed_day"], 28))  # segurança (fev)
+        seed = date(ano, 1, seed_day)
+        step = int(cfg["step"])
+
+        # Todos os D do ano
+        d = seed
+        while d <= dt_fim:
+            if d >= dt_ini:
+                # D (com emoji) + cor
+                titulo_d = f"{fpso} – D{EMOJI_NAVIO}"
+                events.append(
+                    _criar_evento_fc(
+                        titulo_d, d, COLOR_MAP["D"],
+                        {"tipo": "D", "fpso": fpso}
+                    )
+                )
+                if not apenas_D:
+                    # D-1..D-3
+                    for k in (1, 2, 3):
+                        dk = d - timedelta(days=k)
+                        if dt_ini <= dk <= dt_fim:
+                            label = f"D-{k}"
+                            events.append(
+                                _criar_evento_fc(
+                                    f"{fpso} – {label}",
+                                    dk,
+                                    COLOR_MAP[label],
+                                    {"tipo": label, "fpso": fpso},
+                                )
+                            )
+            d += timedelta(days=step)
+
+        # Cobertura no início do ano (apenas rótulos anteriores ao D-semente)
+        if incluir_anteriores and not apenas_D:
+            for k in (1, 2, 3):
+                dk = seed - timedelta(days=k)
+                if dt_ini <= dk <= dt_fim:
+                    label = f"D-{k}"
+                    events.append(
+                        _criar_evento_fc(
+                            f"{fpso} – {label}",
+                            dk,
+                            COLOR_MAP[label],
+                            {"tipo": label, "fpso": fpso},
+                        )
+                    )
+    return events
+
+
+def _gerar_cronograma_intervalo(
+    ano_ini: int,
+    ano_fim: int,
+    fpsos_sel: List[str],
+    apenas_D: bool = False,
+) -> List[dict]:
+    """Gera eventos para [ano_ini..ano_fim]."""
+    out = []
+    for y in range(ano_ini, ano_fim + 1):
+        out.extend(_gerar_cronograma_ano(y, fpsos_sel, incluir_anteriores=True, apenas_D=apenas_D))
+    return out
+
+
+def _titulo_normalizado(titulo: str) -> str:
+    """Remove o emoji ' 🚢' apenas para comparação/deduplicação."""
+    return titulo.replace(EMOJI_NAVIO, "")
+
+
+def _dedup_chave(titulo: str, data_evt: date) -> str:
+    """Chave de de-duplicação (título normalizado + data)."""
+    return f"{_titulo_normalizado(titulo)}::{data_evt.isoformat()}"
+
+
+def _gravar_cronograma_no_banco(db, eventos_fc: List[dict]) -> int:
+    """
+    Grava no banco eventos 'gerado_auto' evitando duplicados (ignorando emoji).
+    Retorna contagem de inserções.
+    """
+    # Pré-carregar existentes no intervalo abrangido
+    if not eventos_fc:
+        return 0
+    min_day = min(date.fromisoformat(ev["start"][:10]) for ev in eventos_fc)
+    max_day = max(date.fromisoformat(ev["start"][:10]) for ev in eventos_fc)
+
+    existentes = (
+        db.query(EventoCalendario)
+        .filter(EventoCalendario.data_evento >= min_day)
+        .filter(EventoCalendario.data_evento <= max_day)
+        .filter(EventoCalendario.ativo.is_(True))
+        .all()
+    )
+    idx_existentes = {
+        _dedup_chave(e.titulo, e.data_evento): e.id for e in existentes
+    }
+
+    ins = 0
+    for ev in eventos_fc:
+        if not ev.get("extendedProps", {}).get("gerado_auto"):
+            continue
+        titulo = ev["title"]
+        dt = date.fromisoformat(ev["start"][:10])
+        k = _dedup_chave(titulo, dt)
+        if k in idx_existentes:
+            continue
+        novo = EventoCalendario(
+            titulo=titulo,  # mantém o emoji nos D
+            descricao=f"Cronograma automático ({ev['extendedProps'].get('tipo','')})",
+            data_evento=dt,
+            data_lembrete=None,
+            ativo=True,
+            usuario_criacao=_usuario_atual(),
+            data_criacao=datetime.now(),
+        )
+        db.add(novo)
+        try:
+            db.commit()
+            ins += 1
+        except Exception:
+            db.rollback()
+    return ins
+
+
+def _remover_cronograma_do_banco_intervalo(db, fpsos_sel: List[str], ano_ini: int, ano_fim: int) -> int:
+    """
+    Remove do banco os eventos gerados por este módulo, para [ano_ini..ano_fim] e FPSOs.
+    Busca por títulos ('<FPSO> – D' / ' – D 🚢' / ' – D-1/2/3') e data no intervalo.
+    """
+    ini = date(ano_ini, 1, 1)
+    fim = date(ano_fim, 12, 31)
+    total = 0
+    for fpso in fpsos_sel:
+        base = [f"{fpso} – D", f"{fpso} – D-1", f"{fpso} – D-2", f"{fpso} – D-3"]
+        # inclui com emoji para D
+        variantes = base + [f"{fpso} – D{EMOJI_NAVIO}"]
+        to_del = (
+            db.query(EventoCalendario)
+            .filter(EventoCalendario.data_evento >= ini)
+            .filter(EventoCalendario.data_evento <= fim)
+            .filter(EventoCalendario.titulo.in_(variantes))
+            .all()
+        )
+        for e in to_del:
+            db.delete(e)
+            total += 1
+        try:
+            db.commit()
+        except Exception:
+            db.rollback()
+    return total
+
+
+def main():
+
+    # =====================================================
+    # 🔒 PROTEÇÃO POR PERFIL
+    # =====================================================
+    if not verificar_permissao("calendario"):
+        st.error("⛔ Acesso não autorizado.")
+        return
+
+    st.title("📅 Calendário e Lembretes")
+
+    hoje = date.today()
+    db = SessionLocal()
+
+    # Helper: cor por status (eventos do banco)
+    def _cor_evento_db(e: "EventoCalendario") -> str:
+        if not e.ativo:
+            return "#95a5a6"  # Cinza
+        if e.data_evento < hoje:
+            return "#e74c3c"  # Vermelho (passado)
+        if e.data_lembrete and e.data_lembrete == hoje:
+            return "#f39c12"  # Laranja (lembrete hoje)
+        return "#2ecc71"      # Verde (ativo futuro)
+
+    # Converte EventoCalendario do banco → FullCalendar
+    def _to_fc_event_db(e: "EventoCalendario") -> dict:
+        return {
+            "id": str(e.id),
+            "title": e.titulo,
+            "start": e.data_evento.isoformat(),
+            "allDay": True,
+            "color": _cor_evento_db(e),
+            "extendedProps": {
+                "descricao": (e.descricao or ""),
+                "data_evento": e.data_evento.isoformat(),
+                "data_lembrete": e.data_lembrete.isoformat() if e.data_lembrete else None,
+                "ativo": e.ativo,
+                "gerado_auto": False,
+            },
+        }
+
+    try:
+        # =====================================================
+        # 🔔 LEMBRETES DO DIA
+        # =====================================================
+        st.subheader("⏰ Lembretes de Hoje | Adicione o calendário da sua embarcação")
+
+        lembretes = (
+            db.query(EventoCalendario)
+            .filter(EventoCalendario.data_lembrete == hoje)
+            .filter(EventoCalendario.ativo.is_(True))
+            .order_by(EventoCalendario.data_evento)
+            .all()
+        )
+
+        if lembretes:
+            for l in lembretes:
+                st.warning(f"🔔 **{l.titulo}** — Evento em {formatar_data_br(l.data_evento)}")
+        else:
+            st.info("Nenhum lembrete para hoje.")
+
+        st.divider()
+
+        # =====================================================
+        # 🎛️ CONTROLES DO CRONOGRAMA
+        # =====================================================
+        st.subheader("🛠️ Cronograma de Embarques (D-3 / D-2 / D-1 / D 🚢)")
+
+        col_a, col_b, col_c = st.columns([1, 2, 2])
+        with col_a:
+            ano_sel = st.number_input(
+                "Ano",
+                min_value=2000, max_value=2100,
+                value=hoje.year, step=1, key="cal_ano_sel"
+            )
+
+        fpsos_all = list(REGRAS_FPSO.keys())
+        with col_b:
+            fpsos_sel = st.multiselect(
+                "FPSOs",
+                options=fpsos_all,
+                default=fpsos_all,
+                key="cal_fpsos_sel",
+            )
+        if not fpsos_sel:
+            fpsos_sel = fpsos_all
+
+        with col_c:
+            apenas_D = st.checkbox("Exibir apenas dias de Embarque (D)", value=False)
+
+        # Gera cronograma em memória para o ANO selecionado (visualização)
+        eventos_auto = _gerar_cronograma_ano(
+            ano_sel, fpsos_sel, incluir_anteriores=True, apenas_D=apenas_D
+        )
+
+        # 🔁 Ações de banco: ANO
+        col_b1, col_b2, col_b3, col_b4 = st.columns([1.7, 1.7, 2, 2])
+        with col_b1:
+            if st.button("💾 Gravar cronograma (ano) no banco"):
+                qtd = _gravar_cronograma_no_banco(db, eventos_auto)
+                if qtd > 0:
+                    registrar_log(_usuario_atual(), "CRIAR", "eventos_calendario", None)
+                st.success(f"Cronograma do ano {ano_sel} gravado/atualizado. Inserções: {qtd}.")
+                st.rerun()
+        with col_b2:
+            if st.button("🧹 Remover cronograma (ano) do banco"):
+                qtd = _remover_cronograma_do_banco_intervalo(db, fpsos_sel, ano_sel, ano_sel)
+                if qtd > 0:
+                    registrar_log(_usuario_atual(), "EXCLUIR", "eventos_calendario", None)
+                st.warning(f"Eventos removidos do banco (ano {ano_sel}): {qtd}.")
+                st.rerun()
+
+        # 🔁 Ações de banco: INTERVALO ATÉ 2030
+        with col_b3:
+            if st.button("💾 Gravar cronograma até 2030 (banco)"):
+                eventos_lote = _gerar_cronograma_intervalo(
+                    ano_ini=ano_sel, ano_fim=2030, fpsos_sel=fpsos_sel, apenas_D=apenas_D
+                )
+                qtd = _gravar_cronograma_no_banco(db, eventos_lote)
+                if qtd > 0:
+                    registrar_log(_usuario_atual(), "CRIAR", "eventos_calendario", None)
+                st.success(f"Cronogramas {ano_sel}–2030 gravados/atualizados. Inserções: {qtd}.")
+                st.rerun()
+        with col_b4:
+            if st.button("🧹 Remover cronograma até 2030 (banco)"):
+                qtd = _remover_cronograma_do_banco_intervalo(db, fpsos_sel, ano_sel, 2030)
+                if qtd > 0:
+                    registrar_log(_usuario_atual(), "EXCLUIR", "eventos_calendario", None)
+                st.warning(f"Eventos removidos do banco ({ano_sel}–2030): {qtd}.")
+                st.rerun()
+
+        st.caption(
+            "• A geração automática **não** altera seus eventos manuais. "
+            "Use os botões para **gravar** ou **remover** do banco apenas os eventos criados por este módulo. "
+            "Nos dias de **D**, o título inclui o ícone de navio (🚢)."
+        )
+
+        st.divider()
+
+        # =====================================================
+        # ➕ NOVO EVENTO / LEMBRETE (manual)
+        # =====================================================
+        with st.expander("➕ Novo Evento / Lembrete"):
+            with st.form("form_evento"):
+                titulo = st.text_input("Título *")
+                descricao = st.text_area("Descrição")
+                data_evento = st.date_input("Data do Evento", value=hoje, format="DD/MM/YYYY")
+                data_lembrete = st.date_input("Data do Lembrete (opcional)", value=None, format="DD/MM/YYYY")
+                ativo = st.checkbox("Evento ativo", value=True)
+                salvar = st.form_submit_button("💾 Salvar Evento")
+
+            if salvar:
+                if not titulo.strip():
+                    st.error("⚠️ O título é obrigatório.")
+                elif data_lembrete and (data_lembrete > data_evento):
+                    st.error("⚠️ O lembrete não pode ser após a data do evento.")
+                else:
+                    evento = EventoCalendario(
+                        titulo=titulo.strip(),
+                        descricao=(descricao or "").strip(),
+                        data_evento=data_evento,
+                        data_lembrete=data_lembrete,
+                        ativo=ativo,
+                        usuario_criacao=_usuario_atual(),
+                        data_criacao=datetime.now()
+                    )
+                    db.add(evento)
+                    try:
+                        db.commit()
+                    except Exception as e:
+                        db.rollback()
+                        st.error(f"❌ Erro ao salvar evento: {e}")
+                    else:
+                        registrar_log(_usuario_atual(), "CRIAR", "eventos_calendario", evento.id)
+                        st.success("✅ Evento criado com sucesso!")
+                        st.rerun()
+
+        st.divider()
+
+        # =====================================================
+        # 📆 CALENDÁRIO (eventos do banco + cronograma do ANO selecionado)
+        # =====================================================
+        st.subheader("📆 Calendário (clique no dia ou no evento para ver a observação)")
+
+        # Banco (apenas ano selecionado na visualização)
+        ini_year = date(ano_sel, 1, 1)
+        end_year = date(ano_sel, 12, 31)
+        eventos_db = (
+            db.query(EventoCalendario)
+            .filter(EventoCalendario.data_evento >= ini_year)
+            .filter(EventoCalendario.data_evento <= end_year)
+            .order_by(EventoCalendario.data_evento.asc())
+            .all()
+        )
+        eventos_fc_db = [_to_fc_event_db(e) for e in eventos_db]
+
+        # Junta cronograma automático (memória) + banco (para a visualização do ano)
+        eventos_fc = eventos_fc_db + eventos_auto
+
+        options = {
+            "initialView": "dayGridMonth",
+            "locale": "pt-br",
+            "height": 700,
+            "firstDay": 1,
+            "weekNumbers": False,
+            "headerToolbar": {
+                "left": "prev,next today",
+                "center": "title",
+                "right": "dayGridMonth,dayGridWeek,listWeek"
+            },
+            "buttonText": {
+                "today": "Hoje",
+                "month": "Mês",
+                "week": "Semana",
+                "day": "Dia",
+                "list": "Lista"
+            },
+            "dayMaxEventRows": True,
+            "navLinks": True,
+        }
+
+        state = calendar(
+            events=eventos_fc,
+            options=options,
+            custom_css="",
+            key=f"calendario_eventos_{ano_sel}"
+        )
+
+        # Legenda
+        with st.container():
+            cols = st.columns([1.2, 1.2, 1.2, 1.2, 2.2, 3])
+            cols[0].markdown("⬛ **D** (cinza) " + EMOJI_NAVIO)
+            cols[1].markdown("🟥 **D‑1** (vinho)")
+            cols[2].markdown("🟥 **D‑2** (vermelho)")
+            cols[3].markdown("🟩 **D‑3** (verde)")
+            cols[4].markdown("🟧 **Lembrete hoje (eventos do banco)**")
+            cols[5].markdown("🟦 **Outros eventos (banco)**")
+
+        st.divider()
+
+        # =====================================================
+        # 🔎 Detalhe por clique (evento ou dia)
+        # =====================================================
+        clicked_event = None
+        if state and isinstance(state, dict):
+            clicked_event = (state.get("eventClick") or {}).get("event")
+            clicked_date_str = (state.get("dateClick") or {}).get("dateStr")
+        else:
+            clicked_date_str = None
+
+        if clicked_event:
+            ev_id = clicked_event.get("id")
+            ev_title = clicked_event.get("title")
+            ev_start = clicked_event.get("start")
+            ev_ext = clicked_event.get("extendedProps") or {}
+
+            # Se for do banco, traz detalhes atualizados
+            e = None
+            if ev_id and not str(ev_id).startswith("auto::"):
+                try:
+                    e = db.query(EventoCalendario).get(int(ev_id))
+                except Exception:
+                    e = None
+
+            st.subheader(f"📌 {ev_title or 'Evento'}")
+            if e:
+                st.markdown(
+                    f"""
+**Descrição:**  
+{e.descricao or "_Sem descrição_"}
+
+**📅 Data do Evento:** {formatar_data_br(e.data_evento)}  
+**⏰ Data do Lembrete:** {formatar_data_br(e.data_lembrete) if e.data_lembrete else "_Sem lembrete_"}  
+**📌 Status:** {"Ativo ✅" if e.ativo else "Inativo ❌"}
+"""
+                )
+                if verificar_permissao("administracao"):
+                    col1, col2 = st.columns(2)
+                    with col1:
+                        if e.ativo and st.button("🚫 Desativar", key=f"desativar_{e.id}"):
+                            e.ativo = False
+                            try:
+                                db.commit()
+                            except Exception as ex:
+                                db.rollback()
+                                st.error(f"Erro ao desativar: {ex}")
+                            else:
+                                registrar_log(_usuario_atual(), "DESATIVAR",
+                                              "eventos_calendario", e.id)
+                                st.success("Evento desativado.")
+                                st.rerun()
+                    with col2:
+                        if st.button("🗑️ Excluir", key=f"excluir_{e.id}"):
+                            db.delete(e)
+                            try:
+                                db.commit()
+                            except Exception as ex:
+                                db.rollback()
+                                st.error(f"Erro ao excluir: {ex}")
+                            else:
+                                registrar_log(_usuario_atual(), "EXCLUIR",
+                                              "eventos_calendario", e.id)
+                                st.success("Evento excluído.")
+                                st.rerun()
+            else:
+                # Evento do cronograma automático (memória)
+                dt_evt = date.fromisoformat(ev_start[:10])
+                st.markdown(
+                    f"""
+**FPSO:** {ev_title.split(' – ')[0] if ' – ' in (ev_title or '') else '—'}  
+**Tipo:** {ev_ext.get('tipo', '—')}  
+**📅 Data:** {formatar_data_br(dt_evt)}  
+**Origem:** _Cronograma automático (não gravado no banco)_
+"""
+                )
+
+        elif clicked_date_str:
+            try:
+                data_clicada = date.fromisoformat(clicked_date_str)
+            except Exception:
+                data_clicada = None
+
+            if data_clicada:
+                st.subheader(f"🗓️ Eventos em {formatar_data_br(data_clicada)}")
+
+                # Banco
+                eventos_no_dia_db = (
+                    db.query(EventoCalendario)
+                    .filter(EventoCalendario.data_evento == data_clicada)
+                    .order_by(EventoCalendario.id.desc())
+                    .all()
+                )
+                if not eventos_no_dia_db:
+                    st.info("Nenhum evento do banco para este dia.")
+                else:
+                    st.markdown("**📦 Eventos do banco**")
+                    for e in eventos_no_dia_db:
+                        with st.expander(f"📌 {e.titulo}"):
+                            st.markdown(
+                                f"""
+**Descrição:**  
+{e.descricao or "_Sem descrição_"}
+
+**📅 Data do Evento:** {formatar_data_br(e.data_evento)}  
+**⏰ Data do Lembrete:** {formatar_data_br(e.data_lembrete)}  
+**📌 Status:** {"Ativo ✅" if e.ativo else "Inativo ❌"}
+"""
+                            )
+                            if verificar_permissao("administracao"):
+                                c1, c2 = st.columns(2)
+                                with c1:
+                                    if e.ativo and st.button("🚫 Desativar", key=f"desativar_list_{e.id}"):
+                                        e.ativo = False
+                                        try:
+                                            db.commit()
+                                        except Exception as ex:
+                                            db.rollback()
+                                            st.error(f"Erro ao desativar: {ex}")
+                                        else:
+                                            registrar_log(_usuario_atual(), "DESATIVAR",
+                                                          "eventos_calendario", e.id)
+                                            st.success("Evento desativado.")
+                                            st.rerun()
+                                with c2:
+                                    if st.button("🗑️ Excluir", key=f"excluir_list_{e.id}"):
+                                        db.delete(e)
+                                        try:
+                                            db.commit()
+                                        except Exception as ex:
+                                            db.rollback()
+                                            st.error(f"Erro ao excluir: {ex}")
+                                        else:
+                                            registrar_log(_usuario_atual(), "EXCLUIR",
+                                                          "eventos_calendario", e.id)
+                                            st.success("Evento excluído.")
+                                            st.rerun()
+
+                # Cronograma automático (memória) – ano selecionado
+                eventos_auto_no_dia = [
+                    ev for ev in eventos_auto
+                    if ev.get("start", "")[:10] == data_clicada.isoformat()
+                ]
+                if eventos_auto_no_dia:
+                    st.markdown("**🛠️ Eventos gerados automaticamente (cronograma)**")
+                    for ev in sorted(eventos_auto_no_dia, key=lambda x: x.get("title","")):
+                        fps = ev.get("title","").split(" – ")[0] if " – " in ev.get("title","") else "—"
+                        tipo = ev.get("extendedProps", {}).get("tipo", "—")
+                        st.write(f"• **{fps}** — **{tipo}** ({formatar_data_br(data_clicada)})")
+
+        st.divider()
+
+        # =====================================================
+        # 📆 Consultar Eventos por Data (modo antigo) — inclui AUTO
+        # =====================================================
+        with st.expander("📆 Consultar Eventos por Data (modo antigo)"):
+            data_consulta = st.date_input("Selecione uma data",
+                                          value=hoje, format="DD/MM/YYYY",
+                                          key="consulta_antiga")
+
+            # Banco
+            eventos = (
+                db.query(EventoCalendario)
+                .filter(EventoCalendario.data_evento == data_consulta)
+                .order_by(EventoCalendario.id.desc())
+                .all()
+            )
+            if not eventos:
+                st.info("Nenhum evento do banco para esta data.")
+            else:
+                st.markdown("**📦 Eventos do banco**")
+                for e in eventos:
+                    with st.expander(f"📌 {e.titulo}"):
+                        st.markdown(
+                            f"""
+**Descrição:**  
+{e.descricao or "_Sem descrição_"}
+
+**📅 Data do Evento:** {formatar_data_br(e.data_evento)}  
+**⏰ Data do Lembrete:** {formatar_data_br(e.data_lembrete)}  
+**📌 Status:** {"Ativo ✅" if e.ativo else "Inativo ❌"}
+"""
+                        )
+                        if verificar_permissao("administracao"):
+                            col1, col2 = st.columns(2)
+                            with col1:
+                                if e.ativo and st.button("🚫 Desativar", key=f"desativar_old_{e.id}"):
+                                    e.ativo = False
+                                    try:
+                                        db.commit()
+                                    except Exception as ex:
+                                        db.rollback()
+                                        st.error(f"Erro ao desativar: {ex}")
+                                    else:
+                                        registrar_log(_usuario_atual(), "DESATIVAR",
+                                                      "eventos_calendario", e.id)
+                                        st.success("Evento desativado.")
+                                        st.rerun()
+                            with col2:
+                                if st.button("🗑️ Excluir", key=f"excluir_old_{e.id}"):
+                                    db.delete(e)
+                                    try:
+                                        db.commit()
+                                    except Exception as ex:
+                                        db.rollback()
+                                        st.error(f"Erro ao excluir: {ex}")
+                                    else:
+                                        registrar_log(_usuario_atual(), "EXCLUIR",
+                                                      "eventos_calendario", e.id)
+                                        st.success("Evento excluído.")
+                                        st.rerun()
+
+            # AUTO (memória) no ano selecionado
+            eventos_auto_antigo = [
+                ev for ev in eventos_auto
+                if ev.get("start", "")[:10] == data_consulta.isoformat()
+            ]
+            if eventos_auto_antigo:
+                st.markdown("**🛠️ Eventos gerados automaticamente (cronograma)**")
+                for ev in sorted(eventos_auto_antigo, key=lambda x: x.get("title","")):
+                    fps = ev.get("title","").split(" – ")[0] if " – " in ev.get("title","") else "—"
+                    tipo = ev.get("extendedProps", {}).get("tipo", "—")
+                    st.write(f"• **{fps}** — **{tipo}** ({formatar_data_br(data_consulta)})")
+
+    finally:
+        db.close()

calendario_mensal.py

@@ -0,0 +1,70 @@
+import streamlit as st
+import calendar
+from datetime import date
+from banco import SessionLocal
+from models import EventoCalendario
+from utils_permissoes import verificar_permissao
+from utils_datas import formatar_data_br
+
+
+def main():
+
+    if not verificar_permissao("calendario"):
+        st.error("⛔ Acesso não autorizado.")
+        return
+
+    usuario = st.session_state.get("usuario")
+    if not usuario:
+        st.error("Usuário não autenticado.")
+        return
+
+    st.title("📆 Agenda Mensal")
+
+    hoje = date.today()
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        ano = st.selectbox("Ano", range(hoje.year - 2, hoje.year + 3), index=2)
+
+    with col2:
+        mes = st.selectbox("Mês", range(1, 13), index=hoje.month - 1)
+
+    db = SessionLocal()
+    try:
+        eventos = (
+            db.query(EventoCalendario)
+            .filter(EventoCalendario.usuario_criacao == usuario)
+            .filter(EventoCalendario.data_evento.between(
+                date(ano, mes, 1),
+                date(ano, mes, calendar.monthrange(ano, mes)[1])
+            ))
+            .filter(EventoCalendario.ativo.is_(True))
+            .all()
+        )
+    finally:
+        db.close()
+
+    eventos_por_dia = {}
+    for e in eventos:
+        eventos_por_dia.setdefault(e.data_evento.day, []).append(e)
+
+    st.divider()
+
+    semanas = calendar.monthcalendar(ano, mes)
+
+    dias_semana = ["Seg", "Ter", "Qua", "Qui", "Sex", "Sáb", "Dom"]
+    st.columns(7)
+    for d in dias_semana:
+        st.markdown(f"**{d}**")
+
+    for semana in semanas:
+        cols = st.columns(7)
+        for idx, dia in enumerate(semana):
+            with cols[idx]:
+                if dia == 0:
+                    st.write("")
+                else:
+                    st.markdown(f"### {dia}")
+                    for ev in eventos_por_dia.get(dia, []):
+                        st.caption(f"📌 {ev.titulo}")

componentes.py

@@ -0,0 +1,35 @@
+import streamlit as st
+
+
+FPSO_PADRAO = [
+    "CDA",
+    "CDP",
+    "CDM",
+    "ADG",
+    "ESS",
+    "SEP",
+    "CDI",
+    "ATD",
+    "CDS"
+]
+
+
+def campo_fpso(label, key):
+    """
+    Campo FPSO com sugestões + opção de texto livre
+    """
+    opcoes = [""] + FPSO_PADRAO + ["Outro"]
+
+    escolha = st.selectbox(
+        label,
+        opcoes,
+        key=f"{key}_select"
+    )
+
+    if escolha == "Outro":
+        return st.text_input(
+            f"{label} (digite)",
+            key=f"{key}_texto"
+        ).strip()
+
+    return escolha

consulta.py

@@ -0,0 +1,277 @@
+
+import streamlit as st
+import pandas as pd
+from io import BytesIO
+from datetime import date
+from banco import SessionLocal
+from models import Equipamento
+
+
+def limpar_estado_consulta():
+    """
+    Remove do session_state qualquer dado
+    relacionado ao módulo Consulta
+    """
+    for key in list(st.session_state.keys()):
+        if key.startswith("consulta_"):
+            del st.session_state[key]
+
+
+def _coerce_date(x):
+    """Garante que valores sejam datas (date) ou NaT para comparação."""
+    if pd.isna(x):
+        return pd.NaT
+    if isinstance(x, (pd.Timestamp, )):
+        return x.date()
+    if isinstance(x, date):
+        return x
+    try:
+        return pd.to_datetime(x).date()
+    except Exception:
+        return pd.NaT
+
+
+def main():
+
+    # =====================================================
+    # 🧹 LIMPA ESTADO AO ENTRAR NO MÓDULO
+    # =====================================================
+    if not st.session_state.get("_consulta_inicializado"):
+        limpar_estado_consulta()
+        st.session_state["_consulta_inicializado"] = True
+
+    st.title("🔍 Consulta de Registros")
+
+    db = SessionLocal()
+
+    try:
+        registros = db.query(Equipamento).all()
+
+        if not registros:
+            st.info("Nenhum registro encontrado.")
+            return
+
+        # =====================================================
+        # 🔄 CONVERTE REGISTROS EM DATAFRAME (TODOS OS CAMPOS)
+        # =====================================================
+        df = pd.DataFrame([
+            {
+                "ID": r.id,
+
+                # Identificação
+                "FPSO1": r.fpso1,
+                "FPSO": r.fpso,
+                "Data Coleta": r.data_coleta,
+
+                # Responsáveis
+                "Especialista": r.especialista,
+                "Conferente": r.conferente,
+                "OSM": r.osm,
+
+                # Operacional
+                "Modal": r.modal,
+                "Quantidade Equip.": r.quant_equip,
+                "MROB": r.mrob,
+
+                # Métricas
+                "Linhas OSM": r.linhas_osm,
+                "Linhas MROB": r.linhas_mrob,
+                "Linhas Erros": r.linhas_erros,
+
+                # Erros
+                "Erro Storekeeper": r.erro_storekeeper,
+                "Erro Operação": r.erro_operacao,
+                "Erro Especialista": r.erro_especialista,
+                "Erro Outros": r.erro_outros,
+
+                # Dados complementares
+                "Inclusão / Exclusão": r.inclusao_exclusao,
+                "PO": r.po,
+                "Part Number": r.part_number,
+                "Material": r.material,
+
+                "Solicitante": r.solicitante,
+                "Motivo": getattr(r, "motivo", None),
+                "Requisitante": r.requisitante,
+                "Nota Fiscal": r.nota_fiscal,
+                "Impacto": r.impacto,
+                "Dimensão": r.dimensao,
+
+                "Observações": r.observacoes,
+                "Dia Inclusão": r.dia_inclusao,
+
+                # Auditoria
+                "Data/Hora Input": r.data_hora_input,
+            }
+            for r in registros
+        ])
+
+        # Normaliza a coluna de data para comparação correta
+        if "Data Coleta" in df.columns:
+            df["Data Coleta"] = df["Data Coleta"].apply(_coerce_date)
+
+        # =====================================================
+        # 🔎 FILTROS
+        # =====================================================
+        st.subheader("🔎 Filtros")
+
+        col1, col2, col3 = st.columns(3)
+
+        with col1:
+            filtro_fpso = st.multiselect(
+                "FPSO",
+                sorted(df["FPSO"].dropna().unique()),
+                key="consulta_fpso"
+            )
+
+            filtro_dia = st.multiselect(
+                "Dia de Inclusão (D1 / D2 / D3)",
+                sorted(df["Dia Inclusão"].dropna().unique()),
+                key="consulta_dia"
+            )
+
+        with col2:
+            filtro_modal = st.multiselect(
+                "Modal",
+                sorted(df["Modal"].dropna().unique()),
+                key="consulta_modal"
+            )
+
+            filtro_especialista = st.multiselect(
+                "Especialista",
+                sorted(df["Especialista"].dropna().unique()),
+                key="consulta_especialista"
+            )
+
+            # 🔵 FILTRO OSM
+            filtro_osm = st.multiselect(
+                "OSM",
+                sorted(df["OSM"].dropna().unique()),
+                key="consulta_osm"
+            )
+
+        with col3:
+            periodo = st.date_input(
+                "Período de Coleta",
+                value=None,
+                key="consulta_periodo"
+            )
+
+            # 🟩 NOVO: FILTRO DE NOTA FISCAL
+            st.markdown("**Nota Fiscal**")
+            nota_input_text = st.text_input(
+                "Digite um ou mais números (separados por vírgula)",
+                value="",
+                key="consulta_nf_text"
+            )
+            # Alternativamente (opcional) oferecer multiselect pelos valores existentes
+            filtro_nf_multi = st.multiselect(
+                "Ou selecione",
+                sorted([str(x) for x in df["Nota Fiscal"].dropna().unique()]),
+                key="consulta_nf_multi"
+            )
+            mostrar_apenas_duplicadas = st.checkbox(
+                "Mostrar apenas notas duplicadas",
+                value=False,
+                key="consulta_mostrar_dup_nf"
+            )
+
+        # =====================================================
+        # 🔄 APLICA FILTROS
+        # =====================================================
+        # Filtros simples
+        if filtro_fpso:
+            df = df[df["FPSO"].isin(filtro_fpso)]
+
+        if filtro_modal:
+            df = df[df["Modal"].isin(filtro_modal)]
+
+        if filtro_especialista:
+            df = df[df["Especialista"].isin(filtro_especialista)]
+
+        if filtro_dia:
+            df = df[df["Dia Inclusão"].isin(filtro_dia)]
+
+        if filtro_osm:
+            df = df[df["OSM"].isin(filtro_osm)]
+
+        # Filtro de período (intervalo)
+        if isinstance(periodo, (list, tuple)) and len(periodo) == 2 and all(periodo):
+            data_inicio, data_fim = periodo
+            df = df[
+                (df["Data Coleta"] >= data_inicio) &
+                (df["Data Coleta"] <= data_fim)
+            ]
+
+        # -----------------------------------------------------
+        # Filtro de Nota Fiscal (texto e/ou multiselect)
+        # -----------------------------------------------------
+        # Consolida as notas informadas via texto (separadas por vírgula)
+        notas_texto = []
+        if nota_input_text.strip():
+            notas_texto = [x.strip() for x in nota_input_text.split(",") if x.strip()]
+
+        # Concatena com o multiselect (transformando em string)
+        notas_escolhidas = set([str(x) for x in filtro_nf_multi] + [str(x) for x in notas_texto])
+
+        if notas_escolhidas:
+            # Comparar sempre como string para evitar problemas com zeros à esquerda ou tipos heterogêneos
+            df = df[df["Nota Fiscal"].astype(str).isin(notas_escolhidas)]
+
+        # =====================================================
+        # 🧭 SINALIZA DUPLICIDADE DE NOTA FISCAL
+        # =====================================================
+        # Conta ocorrências por número (string) ignorando NaN
+        nf_series = df["Nota Fiscal"].astype(str).fillna("")
+        contagem_nf = nf_series.value_counts(dropna=False)
+        # Duplicadas são as que tem contagem > 1 (e não vazias)
+        notas_duplicadas = contagem_nf[(contagem_nf > 1) & (contagem_nf.index != "")]
+
+        # Coluna booleana marcando duplicidade no DF atual
+        df["Duplicidade Nota"] = df["Nota Fiscal"].astype(str).isin(notas_duplicadas.index)
+
+        # Aviso resumido
+        if len(notas_duplicadas) > 0:
+            st.warning(
+                f"⚠️ Foram encontradas **{int(notas_duplicadas.sum())}** ocorrências em **{len(notas_duplicadas)}** "
+                f"números de Nota Fiscal duplicados no resultado."
+            )
+            with st.expander("Ver lista de notas duplicadas"):
+                dup_df = pd.DataFrame({
+                    "Nota Fiscal": notas_duplicadas.index,
+                    "Ocorrências": notas_duplicadas.values
+                }).sort_values(by="Ocorrências", ascending=False)
+                st.dataframe(dup_df, use_container_width=True)
+
+        # Mostrar apenas duplicadas, caso marcado
+        if mostrar_apenas_duplicadas:
+            df = df[df["Duplicidade Nota"] == True]
+
+        # =====================================================
+        # 📊 RESULTADOS
+        # =====================================================
+        st.subheader("📊 Resultados")
+        st.caption("A coluna **Duplicidade Nota** indica se há mais de um registro com o mesmo número de Nota Fiscal no resultado atual.")
+        st.dataframe(df, use_container_width=True)
+
+        # =====================================================
+        # 📥 EXPORTAÇÃO EXCEL
+        # =====================================================
+        buffer = BytesIO()
+        with pd.ExcelWriter(buffer, engine="openpyxl") as writer:
+            df.to_excel(writer, index=False, sheet_name="Consulta")
+
+        buffer.seek(0)
+
+        st.download_button(
+            label="⬇️ Exportar para Excel",
+            data=buffer,
+            file_name="consulta_equipamentos.xlsx",
+            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        )
+
+    finally:
+        db.close()
+
+
+

db_admin.py

@@ -0,0 +1,387 @@
+
+# db_admin.py
+import streamlit as st
+import os
+import shutil
+from sqlalchemy import text
+from banco import engine, SessionLocal
+from utils_permissoes import verificar_permissao
+from utils_auditoria import registrar_log
+
+# =====================================================
+# MÓDULO GERAL DE ADMINISTRAÇÃO DE BANCO (SCHEMA)
+# =====================================================
+# Objetivo:
+# - Permitir adicionar, renomear, excluir e alterar tipo de colunas via UI
+# - Funciona com SQLite, PostgreSQL e MySQL (com diferenças por dialeto)
+# - Em SQLite, oferece reconstrução assistida quando DDL não é suportado
+#
+# Segurança e boas práticas:
+# - Recomendado fazer backup antes de operações (botão disponível para SQLite)
+# - Operações DDL são críticas: exigir confirmação explícita
+# - Acesso restrito ao perfil "admin"
+#
+# Logs:
+# - registrar_log(...) é chamado em todas as operações
+
+
+# -------------------------
+# Utilitário: Dialeto e versão
+# -------------------------
+def _dialeto():
+    try:
+        return engine.url.get_backend_name()
+    except Exception:
+        return "desconhecido"
+
+def _sqlite_version():
+    if _dialeto() != "sqlite":
+        return None
+    try:
+        with engine.begin() as conn:
+            rv = conn.execute(text("select sqlite_version()")).scalar()
+            return rv
+    except Exception:
+        return None
+
+
+# -------------------------
+# Utilitário: Listar tabelas e colunas
+# -------------------------
+def _listar_tabelas():
+    d = _dialeto()
+    with engine.begin() as conn:
+        if d == "sqlite":
+            rows = conn.execute(text("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")).fetchall()
+            return [r[0] for r in rows]
+        else:
+            q = text("""
+                SELECT table_name
+                FROM information_schema.tables
+                WHERE table_schema NOT IN ('pg_catalog','information_schema')
+                ORDER BY table_name
+            """)
+            rows = conn.execute(q).fetchall()
+            return [r[0] for r in rows]
+
+def _listar_colunas(tabela: str):
+    d = _dialeto()
+    with engine.begin() as conn:
+        if d == "sqlite":
+            rows = conn.execute(text(f"PRAGMA table_info({tabela})")).fetchall()
+            # PRAGMA: (cid, name, type, notnull, dflt_value, pk)
+            return [{"name": r[1], "type": r[2], "notnull": bool(r[3]), "default": r[4], "pk": bool(r[5])} for r in rows]
+        else:
+            q = text("""
+                SELECT column_name, data_type, is_nullable, column_default
+                FROM information_schema.columns
+                WHERE table_name = :tbl
+                ORDER BY ordinal_position
+            """)
+            rows = conn.execute(q, {"tbl": tabela}).fetchall()
+            return [{"name": r[0], "type": r[1], "notnull": (str(r[2]).upper() == "NO"), "default": r[3], "pk": False} for r in rows]
+
+
+# -------------------------
+# Backup rápido (SQLite)
+# -------------------------
+def _sqlite_backup():
+    if _dialeto() != "sqlite":
+        st.info("Backup automático só disponível para SQLite via cópia de arquivo.")
+        return
+    db_path = engine.url.database
+    if not db_path or not os.path.exists(db_path):
+        st.error("Arquivo de banco SQLite não encontrado.")
+        return
+    dest = db_path + ".bak"
+    shutil.copyfile(db_path, dest)
+    st.success(f"Backup criado: {dest}")
+
+
+# -------------------------
+# DDL: Gerar comandos por dialeto
+# -------------------------
+def _ddl_add_column_sql(tabela, col_nome, col_tipo, notnull=False, default=None):
+    d = _dialeto()
+    nn = "NOT NULL" if notnull else "NULL"
+    def_clause = f" DEFAULT {default}" if (default is not None and str(default).strip() != "") else ""
+    if d == "sqlite":
+        # SQLite aceita tipo textual; notnull e default são respeitados no schema
+        return f"ALTER TABLE {tabela} ADD COLUMN {col_nome} {col_tipo} {nn}{def_clause};"
+    elif d in ("postgresql", "postgres"):
+        base = f'ALTER TABLE "{tabela}" ADD COLUMN "{col_nome}" {col_tipo}'
+        if default is not None and str(default).strip() != "":
+            base += f" DEFAULT {default}"
+        if notnull:
+            base += " NOT NULL"
+        return base + ";"
+    elif d in ("mysql", "mariadb"):
+        base = f"ALTER TABLE `{tabela}` ADD COLUMN `{col_nome}` {col_tipo}"
+        if default is not None and str(default).strip() != "":
+            base += f" DEFAULT {default}"
+        base += " NOT NULL" if notnull else " NULL"
+        return base + ";"
+    return None
+
+def _ddl_rename_column_sql(tabela, old, new):
+    d = _dialeto()
+    if d == "sqlite":
+        return f"ALTER TABLE {tabela} RENAME COLUMN {old} TO {new};"
+    elif d in ("postgresql", "postgres"):
+        return f'ALTER TABLE "{tabela}" RENAME COLUMN "{old}" TO "{new}";'
+    elif d in ("mysql", "mariadb"):
+        # MySQL requer tipo na renomeação; esta função não cobre tipo -> usar CHANGE COLUMN via UI de "Alterar tipo/renomear"
+        return None
+    return None
+
+def _ddl_drop_column_sql(tabela, col):
+    d = _dialeto()
+    if d == "sqlite":
+        return f"ALTER TABLE {tabela} DROP COLUMN {col};"
+    elif d in ("postgresql", "postgres"):
+        return f'ALTER TABLE "{tabela}" DROP COLUMN "{col}";'
+    elif d in ("mysql", "mariadb"):
+        return f"ALTER TABLE `{tabela}` DROP COLUMN `{col}`;"
+    return None
+
+def _ddl_alter_type_sql(tabela, col, new_type):
+    d = _dialeto()
+    if d == "sqlite":
+        # SQLite não altera type declarado via ALTER TYPE. Necessário reconstruir tabela.
+        return None
+    elif d in ("postgresql", "postgres"):
+        return f'ALTER TABLE "{tabela}" ALTER COLUMN "{col}" TYPE {new_type};'
+    elif d in ("mysql", "mariadb"):
+        return f"ALTER TABLE `{tabela}` MODIFY COLUMN `{col}` {new_type};"
+    return None
+
+
+# -------------------------
+# Reconstrução assistida (SQLite)
+# -------------------------
+def _sqlite_reconstruir_tabela(tabela, novas_colunas):
+    """
+    Reconstrói tabela SQLite com "novas_colunas" (lista de dicts):
+    [{"name":..., "type":..., "notnull":bool, "default":..., "pk":bool}, ...]
+    - Cria tabela __tmp_<tabela> com o novo schema
+    - Copia dados das colunas compatíveis (mesmos nomes)
+    - Drop da tabela original e rename da temporária
+    """
+    cols_def = []
+    copy_cols = []
+    pk_cols = [c["name"] for c in novas_colunas if c.get("pk")]
+    for c in novas_colunas:
+        nn = "NOT NULL" if c.get("notnull") else ""
+        default = c.get("default")
+        def_clause = f" DEFAULT {default}" if (default is not None and str(default).strip() != "") else ""
+        cols_def.append(f'{c["name"]} {c["type"]} {nn}{def_clause}'.strip())
+        copy_cols.append(c["name"])
+    pk_clause = f", PRIMARY KEY ({', '.join(pk_cols)})" if pk_cols else ""
+
+    create_sql = f"CREATE TABLE __tmp_{tabela} ({', '.join(cols_def)}{pk_clause});"
+    copy_sql = f"INSERT INTO __tmp_{tabela} ({', '.join(copy_cols)}) SELECT {', '.join(copy_cols)} FROM {tabela};"
+    drop_sql  = f"DROP TABLE {tabela};"
+    rename_sql= f"ALTER TABLE __tmp_{tabela} RENAME TO {tabela};"
+
+    with engine.begin() as conn:
+        conn.execute(text(create_sql))
+        conn.execute(text(copy_sql))
+        conn.execute(text(drop_sql))
+        conn.execute(text(rename_sql))
+
+
+# -------------------------
+# UI principal (admin)
+# -------------------------
+def main():
+    st.title("🛠️ Administração de Banco (Schema)")
+
+    # 🔐 Proteção por perfil
+    if not verificar_permissao("db_admin") and st.session_state.get("perfil") != "admin":
+        st.error("⛔ Acesso não autorizado.")
+        return
+
+    # Info do banco
+    dial = _dialeto()
+    st.caption(f"Dialeto: **{dial}**")
+    ver = _sqlite_version()
+    if ver:
+        st.caption(f"SQLite version: **{ver}**")
+
+    # Backup (SQLite)
+    if dial == "sqlite":
+        if st.button("💾 Backup rápido (SQLite)"):
+            _sqlite_backup()
+
+    # Tabelas disponíveis
+    tabelas = _listar_tabelas()
+    if not tabelas:
+        st.warning("Nenhuma tabela encontrada.")
+        return
+
+    tabela = st.selectbox("Tabela alvo:", tabelas, index=0)
+    colunas = _listar_colunas(tabela)
+
+    st.divider()
+    st.subheader("📋 Colunas atuais")
+    st.write(pd.DataFrame(colunas)) if 'pd' in globals() else st.write(colunas)  # mostra estrutura atual
+
+    st.divider()
+    tabs = st.tabs(["➕ Adicionar coluna", "✏️ Renomear coluna", "🗑️ Excluir coluna", "♻️ Alterar tipo"])
+
+    # ----------------- Adicionar coluna -----------------
+    with tabs[0]:
+        st.markdown("**Adicionar uma nova coluna à tabela selecionada**")
+        novo_nome = st.text_input("Nome da nova coluna")
+        novo_tipo = st.text_input("Tipo (ex.: TEXT, INTEGER, VARCHAR(255))")
+        novo_notnull = st.checkbox("NOT NULL", value=False)
+        novo_default = st.text_input("DEFAULT (opcional)")
+
+        confirmar_add = st.checkbox("Confirmo a adição desta coluna (DDL).")
+        if st.button("Executar ADD COLUMN", type="primary") and confirmar_add:
+            sql = _ddl_add_column_sql(tabela, novo_nome, novo_tipo, notnull=novo_notnull, default=novo_default)
+            if not sql:
+                st.error("Dialeto não suportado para ADD COLUMN.")
+            else:
+                try:
+                    with engine.begin() as conn:
+                        conn.execute(text(sql))
+                    registrar_log(st.session_state.get("usuario"), f"ADD COLUMN {novo_nome} {novo_tipo} em {tabela}", "schema", None)
+                    st.success("✅ Coluna adicionada com sucesso.")
+                    st.rerun()
+                except Exception as e:
+                    st.error(f"Erro ao adicionar coluna: {e}")
+
+    # ----------------- Renomear coluna -----------------
+    with tabs[1]:
+        st.markdown("**Renomear uma coluna existente**")
+        col_nomes = [c["name"] for c in colunas]
+        antigo = st.selectbox("Coluna atual:", col_nomes) if col_nomes else ""
+        novo = st.text_input("Novo nome da coluna")
+
+        confirmar_ren = st.checkbox("Confirmo a renomeação desta coluna (DDL).")
+        if st.button("Executar RENAME COLUMN") and confirmar_ren:
+            d = _dialeto()
+            if d == "sqlite":
+                # Verifica suporte na versão
+                ver = _sqlite_version() or "0.0.0"
+                suportado = tuple(map(int, ver.split("."))) >= (3, 25, 0)
+                if suportado:
+                    sql = _ddl_rename_column_sql(tabela, antigo, novo)
+                    try:
+                        with engine.begin() as conn:
+                            conn.execute(text(sql))
+                        registrar_log(st.session_state.get("usuario"), f"RENAME COLUMN {antigo}→{novo} em {tabela}", "schema", None)
+                        st.success("✅ Coluna renomeada com sucesso.")
+                        st.rerun()
+                    except Exception as e:
+                        st.error(f"Erro ao renomear: {e}")
+                else:
+                    st.warning("SQLite < 3.25 não suporta RENAME COLUMN. Oferecendo reconstrução assistida.")
+                    # Reconstrução: atualiza metadados e recria tabela
+                    novas = []
+                    for c in colunas:
+                        nm = novo if c["name"] == antigo else c["name"]
+                        novas.append({"name": nm, "type": c["type"], "notnull": c["notnull"], "default": c["default"], "pk": c["pk"]})
+                    try:
+                        _sqlite_reconstruir_tabela(tabela, novas)
+                        registrar_log(st.session_state.get("usuario"), f"RENAME (rebuild) {antigo}→{novo} em {tabela}", "schema", None)
+                        st.success("✅ Reconstrução concluída com sucesso.")
+                        st.rerun()
+                    except Exception as e:
+                        st.error(f"Erro na reconstrução: {e}")
+            elif d in ("postgresql", "postgres"):
+                sql = _ddl_rename_column_sql(tabela, antigo, novo)
+                if not sql:
+                    st.error("Renomeação não suportada.")
+                else:
+                    try:
+                        with engine.begin() as conn:
+                            conn.execute(text(sql))
+                        registrar_log(st.session_state.get("usuario"), f"RENAME COLUMN {antigo}→{novo} em {tabela}", "schema", None)
+                        st.success("✅ Coluna renomeada com sucesso.")
+                        st.rerun()
+                    except Exception as e:
+                        st.error(f"Erro ao renomear: {e}")
+            elif d in ("mysql", "mariadb"):
+                st.info("MySQL/MariaDB exigem 'CHANGE COLUMN' informando o novo tipo; use a aba 'Alterar tipo' para renomear junto com tipo.")
+
+    # ----------------- Excluir coluna -----------------
+    with tabs[2]:
+        st.markdown("**Excluir uma coluna existente**")
+        col_nomes = [c["name"] for c in colunas]
+        col_drop = st.selectbox("Coluna a excluir:", col_nomes) if col_nomes else ""
+
+        confirmar_drop = st.checkbox("Confirmo a exclusão desta coluna (DDL) e entendo que é irreversível.")
+        if st.button("Executar DROP COLUMN", type="secondary") and confirmar_drop:
+            d = _dialeto()
+            if d == "sqlite":
+                ver = _sqlite_version() or "0.0.0"
+                suportado = tuple(map(int, ver.split("."))) >= (3, 35, 0)
+                if suportado:
+                    sql = _ddl_drop_column_sql(tabela, col_drop)
+                    try:
+                        with engine.begin() as conn:
+                            conn.execute(text(sql))
+                        registrar_log(st.session_state.get("usuario"), f"DROP COLUMN {col_drop} em {tabela}", "schema", None)
+                        st.success("✅ Coluna excluída com sucesso.")
+                        st.rerun()
+                    except Exception as e:
+                        st.error(f"Erro ao excluir: {e}")
+                else:
+                    st.warning("SQLite < 3.35 não suporta DROP COLUMN. Oferecendo reconstrução assistida.")
+                    novas = [c for c in colunas if c["name"] != col_drop]
+                    try:
+                        _sqlite_reconstruir_tabela(tabela, novas)
+                        registrar_log(st.session_state.get("usuario"), f"DROP (rebuild) {col_drop} em {tabela}", "schema", None)
+                        st.success("✅ Reconstrução concluída e coluna removida.")
+                        st.rerun()
+                    except Exception as e:
+                        st.error(f"Erro na reconstrução: {e}")
+            elif d in ("postgresql", "postgres", "mysql", "mariadb"):
+                sql = _ddl_drop_column_sql(tabela, col_drop)
+                try:
+                    with engine.begin() as conn:
+                        conn.execute(text(sql))
+                    registrar_log(st.session_state.get("usuario"), f"DROP COLUMN {col_drop} em {tabela}", "schema", None)
+                    st.success("✅ Coluna excluída com sucesso.")
+                    st.rerun()
+                except Exception as e:
+                    st.error(f"Erro ao excluir: {e}")
+
+    # ----------------- Alterar tipo -----------------
+    with tabs[3]:
+        st.markdown("**Alterar tipo declarado de uma coluna**")
+        col_nomes = [c["name"] for c in colunas]
+        alvo = st.selectbox("Coluna alvo:", col_nomes) if col_nomes else ""
+        novo_tipo = st.text_input("Novo tipo (ex.: TEXT, INTEGER, VARCHAR(255))")
+
+        confirmar_type = st.checkbox("Confirmo a alteração de tipo (DDL).")
+        if st.button("Executar ALTER TYPE") and confirmar_type:
+            d = _dialeto()
+            if d == "sqlite":
+                st.warning("SQLite não suporta ALTER TYPE direto; oferecemos reconstrução assistida.")
+                novas = []
+                for c in colunas:
+                    typ = novo_tipo if c["name"] == alvo else c["type"]
+                    novas.append({"name": c["name"], "type": typ, "notnull": c["notnull"], "default": c["default"], "pk": c["pk"]})
+                try:
+                    _sqlite_reconstruir_tabela(tabela, novas)
+                    registrar_log(st.session_state.get("usuario"), f"ALTER TYPE (rebuild) {alvo}→{novo_tipo} em {tabela}", "schema", None)
+                    st.success("✅ Tipo alterado com sucesso via reconstrução.")
+                    st.rerun()
+                except Exception as e:
+                    st.error(f"Erro na reconstrução: {e}")
+            elif d in ("postgresql", "postgres", "mysql", "mariadb"):
+                sql = _ddl_alter_type_sql(tabela, alvo, novo_tipo)
+                if not sql:
+                    st.error("Dialeto não suportado para ALTER TYPE.")
+                else:
+                    try:
+                        with engine.begin() as conn:
+                            conn.execute(text(sql))
+                        registrar_log(st.session_state.get("usuario"), f"ALTER TYPE {alvo}→{novo_tipo} em {tabela}", "schema", None)
+                        st.success("✅ Tipo alterado com sucesso.")
+                        st.rerun()
+                    except Exception as e:
+                        st.error(f"Erro ao alterar tipo: {e}")

db_export_import.py

@@ -0,0 +1,359 @@
+
+# -*- coding: utf-8 -*-
+"""
+db_export_import.py — Backup & Restore (Export/Import) do banco ATIVO (Produção/Teste)
+
+Recursos:
+• Exibe banco ativo (prod/test) e URL do engine
+• Exporta todas as tabelas para:
+  - ZIP (CSV por tabela + manifest.json)
+  - Excel (.xlsx) (1 aba por tabela + manifest sheet)
+• Importa (upload) de:
+  - ZIP (CSV por tabela)
+  - Excel (.xlsx)
+• Modos de import: APPEND ou REPLACE (cuidado com FK)
+• Snapshot físico para SQLite: cópia do arquivo (.db) — backup/restore rápido
+
+Dependências:
+- pandas, openpyxl, sqlalchemy, zipfile, io, json, datetime
+"""
+
+import os
+import io
+import json
+import zipfile
+from datetime import datetime
+
+import streamlit as st
+import pandas as pd
+from sqlalchemy import inspect, text
+
+from banco import get_engine, db_info, SessionLocal
+from utils_auditoria import registrar_log
+
+# Ambiente (prod/test) — se db_router não existir, fallback para 'prod'
+try:
+    from db_router import current_db_choice
+    _HAS_ROUTER = True
+except Exception:
+    _HAS_ROUTER = False
+
+    def current_db_choice() -> str:
+        return "prod"
+
+
+# =========================
+# Helpers: tabelas e I/O
+# =========================
+def list_tables(engine) -> list[str]:
+    """Retorna nomes de todas as tabelas via SQLAlchemy inspection."""
+    inspector = inspect(engine)
+    return inspector.get_table_names()
+
+
+def _read_table_df(engine, table_name: str) -> pd.DataFrame:
+    """Lê toda a tabela como DataFrame."""
+    try:
+        # pandas + SQLAlchemy: lê tabela diretamente
+        return pd.read_sql_table(table_name, con=engine)
+    except Exception:
+        # fallback: SELECT com aspas (útil para SQLite com nomes case-sensitive)
+        return pd.read_sql(f'SELECT * FROM "{table_name}"', con=engine)
+
+
+def _write_table_df(engine, table_name: str, df: pd.DataFrame, mode: str = "append"):
+    """
+    Escreve DataFrame em tabela.
+    mode: "append" (adiciona) ou "replace" (sobrescreve todos os dados).
+    Observação: nos fluxos de import, quando 'replace' foi selecionado,
+    todas as tabelas são truncadas previamente, e aqui usamos 'append'.
+    """
+    if mode not in ("append", "replace"):
+        mode = "append"
+    df.to_sql(table_name, con=engine, if_exists=mode, index=False)
+
+
+# =========================
+# Export: ZIP (CSV) & Excel
+# =========================
+def export_zip(engine, ambiente: str) -> bytes:
+    """
+    Exporta todas as tabelas para um ZIP:
+    - 1 CSV por tabela (UTF-8-BOM)
+    - manifest.json com metadados (ambiente, timestamp, url, tabelas)
+    """
+    tables = list_tables(engine)
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as z:
+        for t in tables:
+            df = _read_table_df(engine, t)
+            csv_bytes = df.to_csv(index=False, encoding="utf-8-sig").encode("utf-8-sig")
+            z.writestr(f"{t}.csv", csv_bytes)
+
+        manifest = {
+            "ambiente": ambiente,
+            "timestamp": datetime.now().isoformat(),
+            "engine_url": str(engine.url),
+            "tables": tables,
+            "format": "zip/csv",
+            "version": "1.0",
+        }
+        z.writestr("manifest.json", json.dumps(manifest, ensure_ascii=False, indent=2))
+    buf.seek(0)
+    return buf.getvalue()
+
+
+def export_excel(engine, ambiente: str) -> bytes:
+    """
+    Exporta todas as tabelas para um Excel (.xlsx):
+    - 1 aba por tabela (limitada a 31 caracteres)
+    - "manifest" com metadados
+    """
+    tables = list_tables(engine)
+    buf = io.BytesIO()
+    with pd.ExcelWriter(buf, engine="openpyxl") as writer:
+        # manifest
+        manifest = pd.DataFrame([{
+            "ambiente": ambiente,
+            "timestamp": datetime.now().isoformat(),
+            "engine_url": str(engine.url),
+            "tables": ", ".join(tables),
+            "format": "xlsx",
+            "version": "1.0",
+        }])
+        manifest.to_excel(writer, sheet_name="manifest", index=False)
+
+        # tabelas → 1 aba por tabela
+        for t in tables:
+            df = _read_table_df(engine, t)
+            sheet = t[:31] if len(t) > 31 else t
+            df.to_excel(writer, sheet_name=sheet, index=False)
+    buf.seek(0)
+    return buf.getvalue()
+
+
+# =========================
+# Import: ZIP (CSV) & Excel
+# =========================
+def import_zip(engine, file_bytes: bytes, mode: str = "append") -> dict:
+    """
+    Importa dados de um ZIP (CSV por tabela).
+    mode: "append" ou "replace".
+    Retorna um relatório {table: {"rows": int, "mode": str}}.
+    """
+    report = {}
+    zbuf = io.BytesIO(file_bytes)
+    with zipfile.ZipFile(zbuf, "r") as z:
+        # Se replace, limpar tabelas (cuidado com FK)
+        if mode == "replace":
+            _truncate_all(engine)
+
+        for name in z.namelist():
+            if not name.lower().endswith(".csv"):
+                continue
+            table = os.path.splitext(os.path.basename(name))[0]
+            csv_bytes = z.read(name)
+            df = pd.read_csv(io.BytesIO(csv_bytes), dtype=str)  # dtype=str para evitar coercões agressivas
+            # Conversões leves de datetime (best-effort)
+            for col in df.columns:
+                if "data" in col.lower() or "date" in col.lower():
+                    try:
+                        df[col] = pd.to_datetime(df[col], errors="ignore")
+                    except Exception:
+                        pass
+            # replace já truncou; aqui fazemos append
+            _write_table_df(engine, table, df, mode="append")
+            report[table] = {"rows": int(len(df)), "mode": mode}
+    return report
+
+
+def import_excel(engine, file_bytes: bytes, mode: str = "append") -> dict:
+    """
+    Importa dados de um Excel (.xlsx) com múltiplas abas (1 por tabela).
+    mode: "append" ou "replace".
+    """
+    report = {}
+    xbuf = io.BytesIO(file_bytes)
+    xls = pd.ExcelFile(xbuf, engine="openpyxl")
+    sheets = [s for s in xls.sheet_names if s.lower() != "manifest"]
+
+    if mode == "replace":
+        _truncate_all(engine)
+
+    for sheet in sheets:
+        df = xls.parse(sheet_name=sheet, dtype=str)
+        # best-effort para datas
+        for col in df.columns:
+            if "data" in col.lower() or "date" in col.lower():
+                try:
+                    df[col] = pd.to_datetime(df[col], errors="ignore")
+                except Exception:
+                    pass
+        table = sheet
+        _write_table_df(engine, table, df, mode="append")
+        report[table] = {"rows": int(len(df)), "mode": mode}
+    return report
+
+
+# =========================
+# Truncate (REPLACE mode)
+# =========================
+def _truncate_all(engine):
+    """
+    Limpa todas as tabelas do banco ativo (cuidado!).
+    • Para SQLite: desabilita FK temporariamente, apaga, e reabilita.
+    • Para outros bancos: executa DELETE tabela; considere ordem por FK se necessário.
+    """
+    insp = inspect(engine)
+    tables = insp.get_table_names()
+
+    with engine.begin() as conn:
+        url = str(engine.url)
+        is_sqlite = url.startswith("sqlite")
+        if is_sqlite:
+            conn.execute(text("PRAGMA foreign_keys=OFF"))
+
+        # Apaga conteúdo (sem considerar ordem de FK — OK para SQLite com FK OFF)
+        for t in tables:
+            conn.execute(text(f'DELETE FROM "{t}"'))
+
+        if is_sqlite:
+            conn.execute(text("PRAGMA foreign_keys=ON"))
+
+
+# =========================
+# Snapshot físico (SQLite)
+# =========================
+def snapshot_sqlite(engine, ambiente: str) -> bytes:
+    """
+    Cria um snapshot (cópia física) do arquivo SQLite do banco ativo.
+    Retorna o conteúdo do arquivo para download.
+    """
+    url = str(engine.url)
+    if not url.startswith("sqlite:///"):
+        raise RuntimeError("Snapshot físico disponível apenas para SQLite.")
+    db_path = url.replace("sqlite:///", "")
+    if not os.path.isfile(db_path):
+        raise FileNotFoundError(f"Arquivo SQLite não encontrado: {db_path}")
+
+    with open(db_path, "rb") as f:
+        data = f.read()
+
+    # auditoria
+    try:
+        registrar_log(usuario=st.session_state.get("usuario"),
+                      acao=f"Snapshot SQLite ({ambiente})",
+                      tabela="backup",
+                      registro_id=None)
+    except Exception:
+        pass
+
+    return data
+
+
+# =========================
+# UI (Streamlit)
+# =========================
+def main():
+    st.title("🗄️ Backup & Restore | Export/Import de Banco")
+
+    # Banco ativo e info
+    ambiente = current_db_choice()
+    info = db_info()
+    st.caption(f"🧭 Ambiente: {'Produção' if ambiente == 'prod' else 'Teste'}")
+    st.caption(f"🔗 Engine URL: {info.get('url')}")
+
+    engine = get_engine()
+
+    st.divider()
+    st.subheader("⬇️ Exportar dados")
+
+    colA, colB, colC = st.columns(3)
+    with colA:
+        if st.button("Exportar ZIP (CSV por tabela)", type="primary"):
+            try:
+                zip_bytes = export_zip(engine, ambiente)
+                fname = f"backup_{ambiente}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.zip"
+                st.download_button("📥 Baixar ZIP", data=zip_bytes, file_name=fname, mime="application/zip")
+                registrar_log(usuario=st.session_state.get("usuario"),
+                              acao=f"Export ZIP (ambiente={ambiente})",
+                              tabela="backup", registro_id=None)
+            except Exception as e:
+                st.error(f"Falha ao exportar ZIP: {e}")
+
+    with colB:
+        if st.button("Exportar Excel (.xlsx)", type="primary"):
+            try:
+                xlsx_bytes = export_excel(engine, ambiente)
+                fname = f"backup_{ambiente}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
+                st.download_button("📥 Baixar Excel", data=xlsx_bytes, file_name=fname,
+                                   mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
+                registrar_log(usuario=st.session_state.get("usuario"),
+                              acao=f"Export XLSX (ambiente={ambiente})",
+                              tabela="backup", registro_id=None)
+            except Exception as e:
+                st.error(f"Falha ao exportar Excel: {e}")
+
+    with colC:
+        # Snapshot físico apenas para SQLite
+        url = str(engine.url)
+        if url.startswith("sqlite:///"):
+            if st.button("Snapshot físico (SQLite)", type="secondary"):
+                try:
+                    snap_bytes = snapshot_sqlite(engine, ambiente)
+                    fname = f"snapshot_{ambiente}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.db"
+                    st.download_button("📥 Baixar Snapshot (.db)", data=snap_bytes, file_name=fname, mime="application/octet-stream")
+                except Exception as e:
+                    st.error(f"Falha ao criar snapshot: {e}")
+        else:
+            st.caption("ℹ️ Snapshot físico disponível apenas para SQLite.")
+
+    st.divider()
+    st.subheader("⬆️ Importar dados")
+
+    mode = st.radio("Modo de importação:", ["APPEND (adicionar)", "REPLACE (substituir tudo)"], horizontal=True)
+    mode_val = "append" if "APPEND" in mode else "replace"
+
+    up_col1, up_col2 = st.columns(2)
+    with up_col1:
+        zip_file = st.file_uploader("Upload ZIP (CSV por tabela)", type=["zip"])
+        if zip_file is not None and st.button("Importar do ZIP", type="primary"):
+            try:
+                report = import_zip(engine, zip_file.read(), mode=mode_val)
+                st.success(f"Import ZIP concluído ({mode_val}).")
+                st.json(report)
+                registrar_log(usuario=st.session_state.get("usuario"),
+                              acao=f"Import ZIP ({mode_val}, ambiente={ambiente})",
+                              tabela="restore", registro_id=None)
+            except Exception as e:
+                st.error(f"Falha ao importar ZIP: {e}")
+
+    with up_col2:
+        xls_file = st.file_uploader("Upload Excel (.xlsx)", type=["xlsx"])
+        if xls_file is not None and st.button("Importar do Excel", type="primary"):
+            try:
+                report = import_excel(engine, xls_file.read(), mode=mode_val)
+                st.success(f"Import Excel concluído ({mode_val}).")
+                st.json(report)
+                registrar_log(usuario=st.session_state.get("usuario"),
+                              acao=f"Import XLSX ({mode_val}, ambiente={ambiente})",
+                              tabela="restore", registro_id=None)
+            except Exception as e:
+                st.error(f"Falha ao importar Excel: {e}")
+
+    st.divider()
+    st.info("⚠️ Recomendações:\n"
+            "• Para restore completo com integridade referencial, prefira snapshot físico no SQLite, ou migrações controladas em bancos como Postgres/SQL Server.\n"
+            "• O modo REPLACE desabilita FK temporariamente no SQLite para permitir limpeza; use com cautela.\n"
+            "• Em produção, considere gerar backups com versionamento e retenção (ex.: timestamp no nome do arquivo).")
+
+
+def render():
+    # compatível com seu roteador/menu
+    main()
+
+
+if __name__ == "__main__":
+    st.set_page_config(page_title="Backup & Restore | ARM", layout="wide")
+    main()
+

db_monitor.py

@@ -0,0 +1,278 @@
+
+# db_monitor.py
+import streamlit as st
+import os
+import shutil
+import time
+from datetime import datetime, timedelta
+from sqlalchemy import text
+# ✅ Use sempre o engine do BANCO ATIVO (em vez de um engine fixo)
+from banco import get_engine, SessionLocal, db_info
+from utils_permissoes import verificar_permissao
+from utils_auditoria import registrar_log
+
+# ===============================
+# MONITOR & BACKUP DO BANCO
+# ===============================
+# Objetivo:
+# - Mostrar estatísticas do banco (tamanho, páginas, espaço em disco)
+# - Definir limiar/capacidade alvo e exibir ocupação (%)
+# - Planejar backup (frequência em dias) e retenção (N arquivos)
+# - Executar backup e limpar antigos com confirmação
+# - Acesso restrito por perfil admin
+#
+# Observações:
+# - Em SQLite: usa PRAGMA page_count/page_size + arquivo .db
+# - Em outros dialetos: exibe dialeto e recomenda backup externo
+# - Pasta padrão de backup: ./backups (pode alterar na UI)
+# - Auditoria: registrar_log(usuario, acao="BACKUP/CLEAN/MONITOR", tabela="schema")
+
+# (Opcional) rótulo amigável do ambiente atual (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 {"prod": "Banco 1 (Produção)", "test": "Banco 2 (Teste)", "treinamento": "Banco 3 (Treinamento)"}\
+               .get(choice, choice)
+
+# -------------------------
+# Auxiliares de dialeto
+# -------------------------
+def _engine():
+    """Retorna o engine do banco ATIVO (de acordo com a escolha no login)."""
+    return get_engine()
+
+def _dialeto():
+    try:
+        return _engine().url.get_backend_name()
+    except Exception:
+        return "desconhecido"
+
+def _sqlite_version():
+    if _dialeto() != "sqlite":
+        return None
+    try:
+        with _engine().begin() as conn:
+            return conn.execute(text("select sqlite_version()")).scalar()
+    except Exception:
+        return None
+
+# -------------------------
+# Info do banco
+# -------------------------
+def _db_file_path():
+    # Para SQLite, engine.url.database aponta para o arquivo .db
+    try:
+        eng = _engine()
+        return eng.url.database if eng.url.get_backend_name() == "sqlite" else None
+    except Exception:
+        return None
+
+def _sqlite_stats():
+    # Retorna dict com stats do SQLite
+    db_path = _db_file_path()
+    if not db_path or not os.path.exists(db_path):
+        return None
+
+    size_bytes = os.path.getsize(db_path)
+    dir_path = os.path.dirname(os.path.abspath(db_path)) or "."
+    total, used, free = shutil.disk_usage(dir_path)
+
+    with _engine().begin() as conn:
+        page_count = conn.execute(text("PRAGMA page_count")).scalar()
+        page_size  = conn.execute(text("PRAGMA page_size")).scalar()
+
+    return {
+        "db_path": db_path,
+        "size_bytes": size_bytes,
+        "page_count": page_count,
+        "page_size": page_size,
+        "calc_bytes": (page_count or 0) * (page_size or 0),
+        "disk_total": total,
+        "disk_free": free,
+        "disk_used": used,
+        "sqlite_version": _sqlite_version(),
+    }
+
+# -------------------------
+# Backup
+# -------------------------
+def _ensure_dir(path: str):
+    os.makedirs(path, exist_ok=True)
+
+def _fmt_bytes(b: int) -> str:
+    # Formata bytes em unidades legíveis
+    for unit in ["B","KB","MB","GB","TB"]:
+        if b < 1024.0:
+            return f"{b:,.2f} {unit}".replace(",", ".")
+        b /= 1024.0
+    return f"{b:,.2f} PB".replace(",", ".")
+
+def _listar_backups(backup_dir: str, base_name: str):
+    """Lista backups para o banco atual. Formato: base_name-YYYYMMDD-HHMMSS.db (ou .zip futuramente)"""
+    if not os.path.isdir(backup_dir):
+        return []
+    files = []
+    for f in os.listdir(backup_dir):
+        if f.startswith(base_name + "-") and f.endswith(".db"):
+            full = os.path.join(backup_dir, f)
+            files.append((f, full, os.path.getmtime(full)))
+    return sorted(files, key=lambda x: x[2], reverse=True)  # ordem decrescente
+
+def _executar_backup(backup_dir: str):
+    """Copia o .db para backups/ com timestamp. Registra auditoria."""
+    db_path = _db_file_path()
+    if not db_path or not os.path.exists(db_path):
+        st.error("Arquivo de banco SQLite não encontrado.")
+        return False
+
+    _ensure_dir(backup_dir)
+    base_name = os.path.splitext(os.path.basename(db_path))[0]
+    stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+    dest = os.path.join(backup_dir, f"{base_name}-{stamp}.db")
+
+    try:
+        shutil.copyfile(db_path, dest)
+        registrar_log(st.session_state.get("usuario"), f"BACKUP criado: {os.path.basename(dest)}", "schema", None)
+        st.success(f"✅ Backup criado: {dest}")
+        return True
+    except Exception as e:
+        st.error(f"Erro ao criar backup: {e}")
+        return False
+
+def _limpar_antigos(backup_dir: str, base_name: str, manter: int):
+    """Remove backups antigos, mantendo N mais recentes. Registra auditoria."""
+    lst = _listar_backups(backup_dir, base_name)
+    if len(lst) <= manter:
+        st.info("Nada para remover: já dentro da retenção.")
+        return 0
+    remover = lst[manter:]
+    count = 0
+    for _, full, _ in remover:
+        try:
+            os.remove(full)
+            count += 1
+        except Exception as e:
+            st.error(f"Erro ao remover {full}: {e}")
+    if count > 0:
+        registrar_log(st.session_state.get("usuario"), f"CLEAN backups antigos: {count} removidos (retain={manter})", "schema", None)
+        st.success(f"🧹 {count} backup(s) antigo(s) removido(s).")
+    return count
+
+# -------------------------
+# UI principal
+# -------------------------
+def main():
+    st.title("🗄️ Monitor e Backup do Banco")
+
+    # 🔐 Proteção: apenas admin
+    if st.session_state.get("perfil") != "admin":
+        st.error("⛔ Acesso restrito ao administrador.")
+        return
+
+    # Badge/URL do banco ativo (opcional)
+    try:
+        amb = current_db_choice()
+        st.caption(f"🧭 Ambiente: {bank_label(amb)}")
+    except Exception:
+        pass
+    try:
+        info = db_info()
+        st.caption(f"🔗 Engine URL: {info.get('url')}")
+    except Exception:
+        pass
+
+    dial = _dialeto()
+    st.caption(f"Dialeto do banco: **{dial}**")
+
+    # Estatísticas
+    stats = _sqlite_stats() if dial == "sqlite" else None
+
+    # Se não for SQLite, exibe recomendações
+    if dial != "sqlite":
+        st.info("Este monitor está otimizado para SQLite. Para PostgreSQL/MySQL, configure backup via ferramenta da plataforma (pg_dump/mysqldump) e agendamento externo.")
+        st.stop()
+
+    if not stats:
+        st.error("Banco SQLite não encontrado ou inacessível. Verifique o arquivo do banco ativo.")
+        return
+
+    # Painel de estatísticas
+    st.subheader("📊 Estatísticas")
+    colA, colB, colC = st.columns(3)
+    with colA:
+        st.metric("Arquivo", os.path.basename(stats["db_path"]))
+        st.metric("Tamanho do banco (arquivo)", _fmt_bytes(stats["size_bytes"]))
+    with colB:
+        st.metric("Páginas (PRAGMA)", f'{stats["page_count"]} × {stats["page_size"]} B')
+        st.metric("Cálculo (page_count×page_size)", _fmt_bytes(stats["calc_bytes"]))
+    with colC:
+        st.metric("Espaço livre no disco", _fmt_bytes(stats["disk_free"]))
+        st.metric("SQLite version", stats["sqlite_version"] or "—")
+
+    st.divider()
+
+    # Capacidade alvo e ocupação
+    st.subheader("🎯 Capacidade & Ocupação")
+    capacidade_gb = st.number_input("Capacidade alvo (GB) — alerta quando ultrapassar", min_value=0.1, value=1.0, step=0.1)
+    ocupacao_perc = min(100.0, (stats["size_bytes"] / (capacidade_gb * 1024**3)) * 100.0) if capacidade_gb > 0 else 0.0
+
+    st.progress(min(1.0, ocupacao_perc / 100.0))
+    st.caption(f"Ocupação estimada: **{ocupacao_perc:,.2f}%** de {capacidade_gb} GB")
+
+    if ocupacao_perc >= 80.0:
+        st.warning("⚠️ Ocupação acima de 80%. Considere backup/arquivamento.")
+
+    st.divider()
+
+    # Planejamento de backup
+    st.subheader("🗓️ Planejamento de Backup")
+    backup_dir = st.text_input("Pasta de backups", value="backups")
+    _ensure_dir(backup_dir)  # garante a pasta
+    base_name = os.path.splitext(os.path.basename(stats["db_path"]))[0]
+    backups = _listar_backups(backup_dir, base_name)
+
+    # Último e próximo
+    ultimo_backup_dt = datetime.fromtimestamp(backups[0][2]) if backups else None
+    freq_dias = st.number_input("Frequência (dias)", min_value=1, value=7)
+    retencao = st.number_input("Retenção máx. de backups (arquivos)", min_value=1, value=10)
+    proximo_backup_dt = (ultimo_backup_dt + timedelta(days=freq_dias)) if ultimo_backup_dt else (datetime.now() + timedelta(days=freq_dias))
+
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        st.metric("Último backup", ultimo_backup_dt.strftime("%d/%m/%Y %H:%M:%S") if ultimo_backup_dt else "—")
+    with col2:
+        st.metric("Próximo previsto", proximo_backup_dt.strftime("%d/%m/%Y %H:%M:%S"))
+    with col3:
+        st.metric("Backups atuais", len(backups))
+
+    # Aviso se vencido
+    if ultimo_backup_dt and datetime.now() >= proximo_backup_dt:
+        st.warning("⏰ Backup previsto já venceu. Execute agora para manter o plano.")
+
+    # Ações
+    st.subheader("⚙️ Ações")
+    colX, colY, colZ = st.columns(3)
+    with colX:
+        if st.button("💾 Backup agora"):
+            if _executar_backup(backup_dir):
+                st.rerun()
+    with colY:
+        if st.button("🧹 Limpar antigos (manter retenção)"):
+            _limpar_antigos(backup_dir, base_name, int(retencao))
+            st.rerun()
+    with colZ:
+        # Apenas mostra lista dos últimos backups
+        if backups:
+            st.write("Últimos backups:")
+            for f, full, mtime in backups[:5]:
+                dt = datetime.fromtimestamp(mtime).strftime("%d/%m/%Y %H:%M:%S")
+                st.caption(f"• {f} ({dt})")
+
+    # Auditoria de visualização (opcional)
+    registrar_log(st.session_state.get("usuario"), "MONITOR DB", "schema", None)
+

db_router.py

@@ -0,0 +1,152 @@
+
+# -*- coding: utf-8 -*-
+"""
+db_router.py — Roteia Engine/SessionLocal para 'prod' (Load.db), 'test' (Load_teste.db)
+e 'treinamento' (Load_treinamento.db), conforme escolha do usuário (mantida em st.session_state).
+
+• set_db_choice("prod"|"test"|"treinamento")  → define o banco ativo para a sessão do usuário
+• current_db_choice()                         → retorna 'prod' | 'test' | 'treinamento'
+• get_engine()                                → engine do banco ativo (SQLite)
+• get_session_factory()                       → sessionmaker do banco ativo
+• SessionLocal()                              → sessão pronta no banco ativo
+
+Observação:
+- Este arquivo monta os caminhos dos bancos SQLite com base na pasta do projeto
+  (onde está este arquivo), sem depender de .env.
+- Se quiser usar .env futuramente, há uma seção comentada para isso.
+"""
+
+import os
+import streamlit as st
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+# ============================
+# Caminhos dos bancos (SQLite)
+# ============================
+# Pasta base do projeto (onde está este db_router.py)
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+
+# Nomes dos arquivos de banco conforme sua especificação
+PROD_DB_NAME = "Load.db"
+TEST_DB_NAME = "Load_teste.db"
+TREINAMENTO_DB_NAME = "Load_treinamento.db"
+
+# Monta URLs SQLite (formato: sqlite:///C:/.../arquivo.db)
+DB1_PROD_URL = f"sqlite:///{os.path.join(BASE_DIR, PROD_DB_NAME)}"
+DB2_TEST_URL = f"sqlite:///{os.path.join(BASE_DIR, TEST_DB_NAME)}"
+DB3_TREINAMENTO_URL = f"sqlite:///{os.path.join(BASE_DIR, TREINAMENTO_DB_NAME)}"
+
+# ============================
+# (Opcional) Uso de .env
+# ============================
+# Se preferir usar .env futuramente, descomente abaixo e defina:
+#   DB1_PROD_URL=sqlite:///C:/.../Load.db
+#   DB2_TEST_URL=sqlite:///C:/.../Load_teste.db
+#   DB3_TREINAMENTO_URL=sqlite:///C:/.../Load_treinamento.db
+#
+# from dotenv import load_dotenv
+# load_dotenv()
+# DB1_PROD_URL = os.getenv("DB1_PROD_URL", DB1_PROD_URL)
+# DB2_TEST_URL = os.getenv("DB2_TEST_URL", DB2_TEST_URL)
+# DB3_TREINAMENTO_URL = os.getenv("DB3_TREINAMENTO_URL", DB3_TREINAMENTO_URL)
+
+# ============================
+# Catálogo (helpers de UI — opcional)
+# ============================
+DB_URLS = {
+    "prod":        DB1_PROD_URL,
+    "test":        DB2_TEST_URL,
+    "treinamento": DB3_TREINAMENTO_URL,
+}
+
+DB_LABELS = {
+    "prod":        "Banco 1 (Produção)",
+    "test":        "Banco 2 (Teste)",
+    "treinamento": "Banco 3 (Treinamento)",
+}
+
+def list_banks() -> list[str]:
+    """Lista as chaves de bancos disponíveis (opcional para UI)."""
+    return list(DB_URLS.keys())
+
+def bank_label(choice: str) -> str:
+    """Rótulo amigável para a UI (opcional)."""
+    return DB_LABELS.get(choice, choice)
+
+# ============================
+# Chaves de sessão
+# ============================
+SESSION_DB_CHOICE_KEY  = "__db_choice__"          # "prod" | "test" | "treinamento"
+SESSION_DB_ENGINE_KEY  = "__db_engine__"          # cache de engine por escolha
+SESSION_DB_FACTORY_KEY = "__db_session_factory__" # cache de sessionmaker por escolha
+
+def set_db_choice(choice: str):
+    """
+    Define o banco ativo para a sessão do usuário.
+    choice ∈ {"prod", "test", "treinamento"}.
+    """
+    choice = (choice or "").strip().lower()
+    if choice not in DB_URLS:
+        raise ValueError(f"db_choice inválido. Use uma destas chaves: {list(DB_URLS.keys())}")
+    st.session_state[SESSION_DB_CHOICE_KEY] = choice
+    # Ao trocar banco, invalida caches locais
+    st.session_state.pop(SESSION_DB_ENGINE_KEY, None)
+    st.session_state.pop(SESSION_DB_FACTORY_KEY, None)
+
+def current_db_choice() -> str:
+    """Retorna 'prod' | 'test' | 'treinamento'. Default: 'prod'."""
+    return st.session_state.get(SESSION_DB_CHOICE_KEY, "prod")
+
+def _url_for_choice(choice: str) -> str:
+    return DB_URLS[choice]
+
+def get_engine():
+    """
+    Entrega o engine do banco ATIVO (por sessão). Cria se não existir.
+    """
+    choice = current_db_choice()
+    cached = st.session_state.get(SESSION_DB_ENGINE_KEY)
+    if cached and getattr(cached, "__db_choice__", None) == choice:
+        return cached
+
+    url = _url_for_choice(choice)
+    engine_args = {
+        "echo": False,
+        "pool_pre_ping": True,
+        # check_same_thread=False para permitir uso em múltiplas threads do Streamlit
+        "connect_args": {"check_same_thread": False} if url.startswith("sqlite") else {},
+    }
+
+    eng = create_engine(url, **engine_args)
+    setattr(eng, "__db_choice__", choice)
+    st.session_state[SESSION_DB_ENGINE_KEY] = eng
+    return eng
+
+def get_session_factory():
+    """
+    Entrega um sessionmaker vinculado ao engine do banco ATIVO.
+    """
+    choice = current_db_choice()
+    fac = st.session_state.get(SESSION_DB_FACTORY_KEY)
+    if fac and getattr(fac, "__db_choice__", None) == choice:
+        return fac
+
+    fac = sessionmaker(bind=get_engine(), autocommit=False, autoflush=False)
+    setattr(fac, "__db_choice__", choice)
+    st.session_state[SESSION_DB_FACTORY_KEY] = fac
+    return fac
+
+def SessionLocal():
+    """
+    Cria uma sessão (sempre no banco ativo).
+    Uso:
+        db = SessionLocal()
+        try:
+            ...
+        finally:
+            db.close()
+    """
+    return get_session_factory()()
+
+

db_tools.py

@@ -0,0 +1,65 @@
+
+# db_tools.py
+import streamlit as st
+from banco import engine
+from sqlalchemy import text
+
+# Ajuste a sintaxe conforme seu SGDB. Abaixo está para bancos comuns (Postgres, SQLite, MySQL*).
+# *MySQL funciona, mas o CREATE UNIQUE INDEX IF NOT EXISTS pode variar por versão. Ver obs. abaixo.
+SQLS = [
+    "ALTER TABLE usuarios ADD COLUMN nome VARCHAR(255);",
+    "ALTER TABLE usuarios ADD COLUMN email VARCHAR(255);",
+    "CREATE UNIQUE INDEX IF NOT EXISTS ix_usuarios_email ON usuarios (email);"
+]
+
+def aplicar_alteracoes():
+    with engine.begin() as conn:
+        for sql in SQLS:
+            conn.execute(text(sql))
+
+def verificar_colunas():
+    # Tenta listar colunas da tabela usuarios (funciona na maioria dos drivers)
+    try:
+        with engine.begin() as conn:
+            result = conn.execute(text("PRAGMA table_info(usuarios)"))  # SQLite
+            cols = [row[1] for row in result.fetchall()]
+            return cols
+    except:
+        # Fallback genérico usando INFORMATION_SCHEMA (Postgres/MySQL)
+        try:
+            with engine.begin() as conn:
+                result = conn.execute(text("""
+                    SELECT column_name
+                    FROM information_schema.columns
+                    WHERE table_name = 'usuarios'
+                    ORDER BY ordinal_position;
+                """))
+                cols = [row[0] for row in result.fetchall()]
+                return cols
+        except:
+            return None
+
+def main():
+    st.title("🛠️ Ferramentas de Banco")
+
+    if st.session_state.get("perfil") != "admin":
+        st.error("❌ Acesso restrito ao administrador.")
+        return
+
+    st.info("Este utilitário adiciona as colunas **nome** e **email** na tabela **usuarios** e cria o índice único do **email**.")
+
+    cols = verificar_colunas()
+    if cols:
+        st.write("📋 Colunas atuais em `usuarios`:", ", ".join(cols))
+    else:
+        st.warning("Não foi possível listar colunas automaticamente. Ainda é possível aplicar as alterações.")
+
+    if st.button("✅ Aplicar alterações (nome/email + índice)"):
+        try:
+            aplicar_alteracoes()
+            st.success("Alterações aplicadas com sucesso! Reinicie a aplicação se necessário.")
+        except Exception as e:
+            st.error(f"Erro ao aplicar alterações: {e}")
+            st.stop()
+
+    st.caption("Dica: após aplicar, confira o cadastro/edição de usuários e o login para ver email/nome funcionando.")

env_audit.py

@@ -0,0 +1,321 @@
+
+# -*- coding: utf-8 -*-
+"""
+env_audit.py — Auditoria de ambiente (TESTE/Produção) para projetos Streamlit
+Autor: Rodrigo / ARM | 2026
+
+Verifica:
+• Uso de st.set_page_config fora de if __name__ == "__main__"
+• Presença de funções main()/render() em módulos
+• Diferenças entre arquivos .py e modules_map.py (sugestão de "file")
+• Heurística de banco (banco.py apontando para produção)
+• Gera env_audit_report.json + imprime resumo Markdown
+
+Uso:
+  python env_audit.py --env "C:\\...\\ambiente_teste\\LoadApp"
+(ou) comparar pastas:
+  python env_audit.py --prod "C:\\...\\producao\\LoadApp" --test "C:\\...\\ambiente_teste\\LoadApp"
+"""
+
+import os, sys, json, ast, re
+from typing import Dict, List, Tuple, Optional
+
+def list_py(base: str) -> List[str]:
+    files = []
+    for root, _, names in os.walk(base):
+        for n in names:
+            if n.endswith(".py"):
+                files.append(os.path.normpath(os.path.join(root, n)))
+    return files
+
+def relpath_set(base: str) -> set:
+    return set([os.path.relpath(p, base) for p in list_py(base)])
+
+def parse_ast(path: str) -> Optional[ast.AST]:
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            src = f.read()
+        return ast.parse(src, filename=path)
+    except Exception:
+        return None
+
+def has_set_page_config_outside_main(tree: ast.AST) -> bool:
+    """
+    Retorna True se encontrar chamada a set_page_config fora do guard if __name__ == "__main__".
+    Heurística: procura ast.Call para nome/atributo 'set_page_config' e confere se está dentro de um If guard.
+    """
+    if tree is None:
+        return False
+
+    calls = []
+    parents = {}
+
+    class ParentAnnotator(ast.NodeVisitor):
+        def generic_visit(self, node):
+            for child in ast.iter_child_nodes(node):
+                parents[child] = node
+            super().generic_visit(node)
+
+    class CallCollector(ast.NodeVisitor):
+        def visit_Call(self, node):
+            # detecta set_page_config
+            name = None
+            if isinstance(node.func, ast.Name):
+                name = node.func.id
+            elif isinstance(node.func, ast.Attribute):
+                name = node.func.attr
+            if name == "set_page_config":
+                calls.append(node)
+            self.generic_visit(node)
+
+    ParentAnnotator().visit(tree)
+    CallCollector().visit(tree)
+
+    def inside_main_guard(node: ast.AST) -> bool:
+        # sobe na árvore: se estiver dentro de um If com __name__ == "__main__"
+        cur = node
+        while cur in parents:
+            cur = parents[cur]
+            if isinstance(cur, ast.If):
+                # test é __name__ == "__main__"
+                t = cur.test
+                # match Name('__name__') == Constant('__main__')
+                if isinstance(t, ast.Compare):
+                    left = t.left
+                    comparators = t.comparators
+                    if isinstance(left, ast.Name) and left.id == "__name__" and comparators:
+                        comp = comparators[0]
+                        if isinstance(comp, ast.Constant) and comp.value == "__main__":
+                            return True
+        return False
+
+    # Se houver set_page_config e nenhuma estiver dentro do guard, marca True (incorreto)
+    for c in calls:
+        if not inside_main_guard(c):
+            return True
+    return False
+
+def has_function(tree: ast.AST, fn_name: str) -> bool:
+    if tree is None:
+        return False
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef) and node.name == fn_name:
+            return True
+    return False
+
+def guess_module_name(file_path: str, base: str) -> str:
+    """Retorna o nome do módulo sem extensão e sem subdiretórios ('modulos/x.py' -> 'x')."""
+    rel = os.path.relpath(file_path, base)
+    name = os.path.splitext(os.path.basename(rel))[0]
+    return name
+
+def read_modules_map(path: str) -> Dict[str, Dict]:
+    """
+    Lê modules_map.py e tenta extrair o dict MODULES.
+    Método simples: regex para entries de primeiro nível.
+    """
+    modmap = {}
+    mm_path = os.path.join(path, "modules_map.py")
+    if not os.path.isfile(mm_path):
+        return modmap
+    try:
+        with open(mm_path, "r", encoding="utf-8") as f:
+            src = f.read()
+        # encontra blocos de entries "key": { ... }
+        # Simplificação: captura 'MODULES = { ... }' então entradas por aspas + chave.
+        main_match = re.search(r"MODULES\s*=\s*\{(.+?)\}\s*$", src, flags=re.S)
+        if not main_match:
+            return modmap
+        body = main_match.group(1)
+        # Captura nomes de entradas: "nome": { ... }
+        entry_re = re.compile(r'"\'["\']\s*:\s*\{(.*?)\}', re.S)
+        for em in entry_re.finditer(body):
+            key = em.group(1)
+            obj = em.group(2)
+            # captura "file": "xyz" se houver
+            file_m = re.search(r'["\']file["\']\s*:\s*"\'["\']', obj)
+            label_m = re.search(r'["\']label["\']\s*:\s*"\'["\']', obj)
+            perfis_m = re.findall(r'["\']perfis["\']\s*:\s*\[([^\]]+)\]', obj)
+            grupo_m = re.search(r'["\']grupo["\']\s*:\s*"\'["\']', obj)
+            modmap[key] = {
+                "file": file_m.group(1) if file_m else None,
+                "label": label_m.group(1) if label_m else key,
+                "perfis": perfis_m[0] if perfis_m else None,
+                "grupo": grupo_m.group(1) if grupo_m else None,
+            }
+    except Exception:
+        pass
+    return modmap
+
+def audit_env(env_path: str, prod_path: Optional[str] = None) -> Dict:
+    report = {
+        "env_path": env_path,
+        "prod_path": prod_path,
+        "files_total": 0,
+        "issues": {
+            "set_page_config_outside_main": [],  # lista de arquivos
+            "missing_entry_points": [],          # (arquivo, has_main, has_render)
+            "modules_map_mismatches": [],        # (key, file, suggestion)
+            "db_prod_risk": [],                  # banco.py hints
+            "missing_in_test": [],               # se prod_path fornecido
+            "extra_in_test": [],                 # se prod_path fornecido
+        },
+        "summary": {}
+    }
+
+    env_files = list_py(env_path)
+    report["files_total"] = len(env_files)
+
+    # modules_map
+    modmap = read_modules_map(env_path)
+
+    # varredura de .py
+    for f in env_files:
+        tree = parse_ast(f)
+        if has_set_page_config_outside_main(tree):
+            report["issues"]["set_page_config_outside_main"].append(os.path.relpath(f, env_path))
+
+        has_main = has_function(tree, "main")
+        has_render = has_function(tree, "render")
+        if not (has_main or has_render):
+            report["issues"]["missing_entry_points"].append((os.path.relpath(f, env_path), has_main, has_render))
+
+    # banco.py heuristic
+    banco_path = os.path.join(env_path, "banco.py")
+    if os.path.isfile(banco_path):
+        try:
+            with open(banco_path, "r", encoding="utf-8") as bf:
+                bsrc = bf.read().lower()
+            # heurísticas simples (ajuste conforme seu cenário)
+            hints = []
+            if "prod" in bsrc or "production" in bsrc:
+                hints.append("contém 'prod'/'production' no banco.py (pode estar apontando para produção)")
+            if "localhost" in bsrc or "127.0.0.1" in bsrc:
+                hints.append("contém localhost (ok se seu DB de teste for local)")
+            if "ambiente_teste" in bsrc or "test" in bsrc:
+                hints.append("contém 'test'/'ambiente_teste' (bom indício de DB de teste)")
+            if hints:
+                report["issues"]["db_prod_risk"].extend(hints)
+        except Exception:
+            pass
+
+    # Mismatch entre modules_map e arquivos
+    # Constrói um conjunto de nomes de módulo possíveis (arquivo base sem .py)
+    module_name_set = set([guess_module_name(f, env_path) for f in env_files])
+    for key, info in modmap.items():
+        file_hint = info.get("file")
+        target = file_hint or key
+        if target not in module_name_set:
+            # sugere arquivo com nome mais próximo
+            suggestions = [m for m in module_name_set if m.lower() == key.lower()]
+            sug = suggestions[0] if suggestions else None
+            report["issues"]["modules_map_mismatches"].append((key, file_hint, sug))
+
+    # Diferenças entre PRODUÇÃO e TESTE (se prod_path fornecido)
+    if prod_path and os.path.isdir(prod_path):
+        prod_set = relpath_set(prod_path)
+        test_set = relpath_set(env_path)
+        missing = sorted(list(prod_set - test_set))
+        extra   = sorted(list(test_set - prod_set))
+        report["issues"]["missing_in_test"] = missing
+        report["issues"]["extra_in_test"]    = extra
+
+    # resumo
+    report["summary"] = {
+        "files_total": report["files_total"],
+        "set_page_config_outside_main_count": len(report["issues"]["set_page_config_outside_main"]),
+        "missing_entry_points_count": len(report["issues"]["missing_entry_points"]),
+        "modules_map_mismatches_count": len(report["issues"]["modules_map_mismatches"]),
+        "db_risk_flags_count": len(report["issues"]["db_prod_risk"]),
+        "missing_in_test_count": len(report["issues"]["missing_in_test"]),
+        "extra_in_test_count": len(report["issues"]["extra_in_test"]),
+    }
+
+    return report
+
+def print_markdown(report: Dict):
+    env_path = report["env_path"]
+    prod_path = report.get("prod_path") or "—"
+    print(f"# 🧪 Auditoria de Ambiente\n")
+    print(f"- **Pasta auditada (TESTE)**: `{env_path}`")
+    print(f"- **Pasta de PRODUÇÃO (comparação)**: `{prod_path}`\n")
+
+    s = report["summary"]
+    print("## ✅ Resumo")
+    for k, v in s.items():
+        print(f"- {k.replace('_',' ').title()}: {v}")
+    print()
+
+    issues = report["issues"]
+
+    if issues["set_page_config_outside_main"]:
+        print("## ⚠️ `st.set_page_config` fora de `if __name__ == '__main__'`")
+        for f in issues["set_page_config_outside_main"]:
+            print(f"- {f}")
+        print("**Ajuste**: mover `st.set_page_config(...)` para dentro de:\n")
+        print("```python\nif __name__ == \"__main__\":\n    st.set_page_config(...)\n    main()\n```\n")
+
+    if issues["missing_entry_points"]:
+        print("## ⚠️ Módulos sem `main()` e sem `render()`")
+        for f, has_main, has_render in issues["missing_entry_points"]:
+            print(f"- {f} — main={has_main}, render={has_render}")
+        print("**Ajuste**: garantir pelo menos uma função de entrada (`main` ou `render`).\n")
+
+    if issues["modules_map_mismatches"]:
+        print("## ⚠️ Diferenças entre `modules_map.py` e arquivos")
+        for key, file_hint, sug in issues["modules_map_mismatches"]:
+            print(f"- key=`{key}` | file=`{file_hint}` | sugestão de arquivo=`{sug or 'verificar manualmente'}`")
+        print("**Ajuste**: em `modules_map.py`, defina `\"file\": \"nome_do_arquivo\"` quando o nome do arquivo não for igual à key.\n")
+
+    if issues["db_prod_risk"]:
+        print("## ⚠️ Banco (heurística)")
+        for m in issues["db_prod_risk"]:
+            print(f"- {m}")
+        print("**Ajuste**: confirmar que `banco.py` do TESTE aponta para DB de teste (não produção).\n")
+
+    if issues["missing_in_test"]:
+        print("## 🟠 Arquivos que existem na PRODUÇÃO e faltam no TESTE")
+        for f in issues["missing_in_test"]:
+            print(f"- {f}")
+        print()
+
+    if issues["extra_in_test"]:
+        print("## 🔵 Arquivos que existem no TESTE e não existem na PRODUÇÃO")
+        for f in issues["extra_in_test"]:
+            print(f"- {f}")
+        print()
+
+def main():
+    import argparse
+    p = argparse.ArgumentParser()
+    p.add_argument("--env", help="Pasta do ambiente a auditar (ex.: ...\\ambiente_teste\\LoadApp)")
+    p.add_argument("--prod", help="(Opcional) Pasta de PRODUÇÃO para comparação.")
+    p.add_argument("--test", help="(Opcional) Pasta de TESTE para comparação (se usar --prod).")
+    args = p.parse_args()
+
+    if args.env:
+        env_path = os.path.normpath(args.env)
+        report = audit_env(env_path)
+    elif args.prod and args.test:
+        prod = os.path.normpath(args.prod)
+        test = os.path.normpath(args.test)
+        report = audit_env(test, prod_path=prod)
+    else:
+        print("Uso: python env_audit.py --env \"C:\\...\\ambiente_teste\\LoadApp\"\n"
+              "   ou: python env_audit.py --prod \"C:\\...\\producao\\LoadApp\" --test \"C:\\...\\ambiente_teste\\LoadApp\"")
+        sys.exit(2)
+
+    # salva JSON
+    out_json = os.path.join(os.getcwd(), "env_audit_report.json")
+    try:
+        with open(out_json, "w", encoding="utf-8") as f:
+            json.dump(report, f, ensure_ascii=False, indent=2)
+        print(f"\n💾 Relatório salvo em: {out_json}\n")
+    except Exception as e:
+        print(f"Falha ao salvar JSON: {e}")
+
+    # imprime resumo markdown
+    print_markdown(report)
+
+if __name__ == "__main__":
+    main()

fix_schema.py

@@ -0,0 +1,34 @@
+
+# fix_schema.py
+# -*- coding: utf-8 -*-
+"""
+Utilitário rápido para ajustar o schema da tabela 'usuarios' em SQLite:
+- Verifica se a coluna 'data_aniversario' existe.
+- Se não existir, cria com tipo DATE (compatível com datetime.date via SQLAlchemy).
+⚠️ Execute isso no banco ATIVO (Produção/Teste), conforme seu db_router.
+"""
+
+from sqlalchemy import text
+from banco import engine  # usa o mesmo engine do app
+
+def column_exists(conn, table: str, column: str) -> bool:
+    # SQLite: PRAGMA para listar colunas
+    res = conn.execute(text(f"PRAGMA table_info({table});")).fetchall()
+    cols = [row[1] for row in res]  # row[1] = nome da coluna
+    return column in cols
+
+def add_date_column(conn, table: str, column: str):
+    # SQLite aceita ALTER TABLE ADD COLUMN simples
+    conn.execute(text(f"ALTER TABLE {table} ADD COLUMN {column} DATE;"))
+
+def main():
+    with engine.begin() as conn:
+        if column_exists(conn, "usuarios", "data_aniversario"):
+            print("✅ Coluna 'data_aniversario' já existe em 'usuarios'.")
+        else:
+            print("➕ Criando coluna 'data_aniversario' (DATE) em 'usuarios'...")
+            add_date_column(conn, "usuarios", "data_aniversario")
+            print("✅ Coluna criada com sucesso.")
+
+if __name__ == "__main__":
+    main()

form_equipamento.py

@@ -0,0 +1,98 @@
+import streamlit as st
+from utils_fpso import campo_fpso
+
+MODAL_LISTA = ["", "AÉREO", "MARÍTIMO", "EXPRESSO"]
+RESP_ERRO_LISTA = ["", "Sim", "Não"]
+INCLUSAO_EXCLUSAO_LISTA = ["", "INCLUSÃO", "EXCLUSÃO"]
+
+
+def form_equipamento(registro):
+    st.markdown("### 📦 Dados do Equipamento")
+
+    col1, col2, col3 = st.columns(3)
+
+    # =====================
+    # COLUNA 1
+    # =====================
+    with col1:
+        fpso1 = campo_fpso("FPSO1", registro.fpso1)
+        fpso = campo_fpso("FPSO", registro.fpso)
+        data_coleta = st.date_input("Data Coleta", registro.data_coleta)
+        especialista = st.text_input("Especialista", registro.especialista or "")
+        conferente = st.text_input("Conferente", registro.conferente or "")
+        osm = st.text_input("OSM", registro.osm or "")
+
+    # =====================
+    # COLUNA 2
+    # =====================
+    with col2:
+        modal = st.selectbox(
+            "Modal",
+            MODAL_LISTA,
+            index=MODAL_LISTA.index(registro.modal) if registro.modal in MODAL_LISTA else 0
+        )
+
+        quant_equip = st.number_input(
+            "Quantidade Equipamentos",
+            min_value=0,
+            value=registro.quant_equip or 0
+        )
+
+        mrob = st.text_input("MROB", registro.mrob or "")
+        linhas_osm = st.number_input("Linhas OSM", value=registro.linhas_osm or 0)
+        linhas_mrob = st.number_input("Linhas MROB", value=registro.linhas_mrob or 0)
+        linhas_erros = st.number_input("Linhas com Erro", value=registro.linhas_erros or 0)
+
+    # =====================
+    # COLUNA 3
+    # =====================
+    with col3:
+        erro_storekeeper = st.selectbox(
+            "Erro Storekeeper",
+            RESP_ERRO_LISTA,
+            index=RESP_ERRO_LISTA.index(registro.erro_storekeeper)
+            if registro.erro_storekeeper in RESP_ERRO_LISTA else 0
+        )
+
+        erro_operacao = st.selectbox(
+            "Erro Operação WH",
+            RESP_ERRO_LISTA,
+            index=RESP_ERRO_LISTA.index(registro.erro_operacao)
+            if registro.erro_operacao in RESP_ERRO_LISTA else 0
+        )
+
+        erro_especialista = st.selectbox(
+            "Erro Especialista WH",
+            RESP_ERRO_LISTA,
+            index=RESP_ERRO_LISTA.index(registro.erro_especialista)
+            if registro.erro_especialista in RESP_ERRO_LISTA else 0
+        )
+
+        erro_outros = st.selectbox(
+            "Erro Outros",
+            RESP_ERRO_LISTA,
+            index=RESP_ERRO_LISTA.index(registro.erro_outros)
+            if registro.erro_outros in RESP_ERRO_LISTA else 0
+        )
+
+        inclusao_exclusao = st.selectbox(
+            "Inclusão / Exclusão",
+            INCLUSAO_EXCLUSAO_LISTA,
+            index=INCLUSAO_EXCLUSAO_LISTA.index(registro.inclusao_exclusao)
+            if registro.inclusao_exclusao in INCLUSAO_EXCLUSAO_LISTA else 0
+        )
+
+    # =====================
+    # CAMPOS GERAIS
+    # =====================
+    st.markdown("### 📝 Informações Complementares")
+
+    solicitante = st.text_input("Solicitante", registro.solicitante or "")
+    ivo = st.text_input("Motivo Inclusão / Exclusão", registro.ivo or "")
+    requisitante = st.text_input("Requisitante", registro.requisitante or "")
+    nota_fiscal = st.text_input("Nota Fiscal", registro.nota_fiscal or "")
+    impacto = st.text_input("Impacto", registro.impacto or "")
+    dimensao = st.text_input("Dimensão", registro.dimensao or "")
+    observacoes = st.text_area("Observações", registro.observacoes or "", height=120)
+
+    return locals()

formulario.py

@@ -0,0 +1,519 @@
+
+# -*- coding: utf-8 -*-
+import streamlit as st
+from datetime import datetime, date
+from banco import SessionLocal
+from models import Equipamento
+from sqlalchemy import distinct
+from log import registrar_log
+
+# ======================================================
+# LISTAS FIXAS
+# ======================================================
+MODAL_LISTA = ["", "AÉREO", "MARÍTIMO", "EXPRESSO"]
+INCLUSAO_EXCLUSAO_LISTA = ["", "INCLUSÃO", "EXCLUSÃO"]
+RESP_ERRO_LISTA = ["", "Sim", "Não"]
+D_LISTA = ["", "D1", "D2", "D3"]
+
+# ======================================================
+# LAYOUT
+# ======================================================
+def layout_padrao(titulo: str):
+    st.title(titulo)
+    st.divider()
+
+# ======================================================
+# UTILS
+# ======================================================
+def _safe_index(options, value, default=0):
+    try:
+        return options.index(value)
+    except Exception:
+        return default
+
+def _ss_get(key, default=None):
+    return st.session_state.get(key, default)
+
+def _ss_set(key, value):
+    st.session_state[key] = value
+
+# 🟢 Parser de datas robusto (aceita date, datetime e string)
+def _parse_date_any(v):
+    if isinstance(v, date):
+        return v
+    if isinstance(v, datetime):
+        return v.date()
+    if isinstance(v, str):
+        s = v.strip()
+        # ISO: YYYY-MM-DD
+        try:
+            return date.fromisoformat(s)
+        except Exception:
+            pass
+        # BR: DD/MM/YYYY
+        try:
+            return datetime.strptime(s, "%d/%m/%Y").date()
+        except Exception:
+            pass
+        # YYYY/MM/DD (alguns DBs/ETLs geram assim)
+        try:
+            return datetime.strptime(s, "%Y/%m/%d").date()
+        except Exception:
+            pass
+    return None
+
+def _build_prefill_from_record(r: Equipamento) -> dict:
+    # 🟢 Usa parser que converte string->date quando possível
+    dc = _parse_date_any(getattr(r, "data_coleta", None))
+    return {
+        "fpso1": r.fpso1 or "",
+        "fpso": r.fpso or "",
+        "data_coleta": dc,  # 🟢
+        "especialista": r.especialista or "",
+        "conferente": r.conferente or "",
+        "osm": r.osm or "",
+        "modal": r.modal or "",
+        "quant_equip": int(r.quant_equip or 0),
+        "mrob": r.mrob or "",
+        "linhas_osm": int(r.linhas_osm or 0),
+        "linhas_mrob": int(r.linhas_mrob or 0),
+        "linhas_erros": int(r.linhas_erros or 0),
+        "erro_storekeeper": r.erro_storekeeper or "",
+        "erro_operacao": r.erro_operacao or "",
+        "erro_especialista": r.erro_especialista or "",
+        "erro_outros": r.erro_outros or "",
+        "inclusao_exclusao": r.inclusao_exclusao or "",
+        "po": r.po or "",
+        "part_number": r.part_number or "",
+        "material": r.material or "",
+        "solicitante": r.solicitante or "",
+        "requisitante": r.requisitante or "",
+        "nota_fiscal": r.nota_fiscal or "",
+        "impacto": r.impacto or "",
+        "dimensao": r.dimensao or "",
+        "motivo": getattr(r, "motivo", "") or "",
+        "observacoes": r.observacoes or "",
+        "dia_inclusao": r.dia_inclusao or "",
+        "_origem_id": r.id,
+    }
+
+@st.cache_data
+def get_distinct(_campo):
+    db = SessionLocal()
+    try:
+        rows = db.query(distinct(_campo)).filter(_campo.isnot(None)).filter(_campo != "").all()
+        return sorted([r[0] for r in rows])
+    finally:
+        db.close()
+
+def get_fpsos():
+    return [""] + get_distinct(Equipamento.fpso)
+
+def get_fpsos1():
+    return [""] + get_distinct(Equipamento.fpso1)
+
+def get_notas_fiscais():
+    return sorted([str(x) for x in get_distinct(Equipamento.nota_fiscal)])
+
+def _apply_prefill_to_state(prefill: dict, debug=False):
+    """
+    Aplica o prefill uma única vez por origem (ID), antes de criar widgets.
+    Se o valor não existir nas listas, move para o campo '➕ Novo ...' + text_input.
+    """
+    if not prefill:
+        if debug: st.info("DEBUG: prefill vazio. Nada a aplicar.")
+        return
+
+    origem = prefill.get("_origem_id")
+    if _ss_get("__prefill_applied__") == origem:
+        if debug: st.info(f"DEBUG: prefill já aplicado para origem {origem}.")
+        return
+
+    # Carrega todos os campos no session_state como w_*
+    for k, v in prefill.items():
+        _ss_set(f"w_{k}", v)
+
+    # Backups para os inputs de texto dos "➕ Novo ..."
+    _ss_set("w_fpso1_text", prefill.get("fpso1", ""))
+    _ss_set("w_fpso_text", prefill.get("fpso", ""))
+
+    # Normalização para selects fixos
+    def _norm(key, allowed):
+        v = _ss_get(key, "")
+        if v not in allowed:
+            _ss_set(key, allowed[0])
+
+    _norm("w_modal", MODAL_LISTA)
+    _norm("w_erro_storekeeper", RESP_ERRO_LISTA)
+    _norm("w_erro_operacao", RESP_ERRO_LISTA)
+    _norm("w_erro_especialista", RESP_ERRO_LISTA)
+    _norm("w_erro_outros", RESP_ERRO_LISTA)
+    _norm("w_inclusao_exclusao", INCLUSAO_EXCLUSAO_LISTA)
+    _norm("w_dia_inclusao", D_LISTA)
+
+    # 🟢 Tipos/valores coerentes
+    _ss_set("w_quant_equip", int(_ss_get("w_quant_equip", 0) or 0))
+    _ss_set("w_linhas_osm", int(_ss_get("w_linhas_osm", 0) or 0))
+    _ss_set("w_linhas_mrob", int(_ss_get("w_linhas_mrob", 0) or 0))
+    _ss_set("w_linhas_erros", int(_ss_get("w_linhas_erros", 0) or 0))
+
+    # 🟢 NÃO força “hoje” se vier None — mas o widget precisa de um valor (trata na UI)
+    # _ss_set("w_data_coleta", _ss_get("w_data_coleta") or date.today())
+
+    _ss_set("__prefill_applied__", origem)
+    if debug: st.success(f"DEBUG: prefill aplicado. origem={origem}")
+
+# ======================================================
+# APP
+# ======================================================
+def main():
+    layout_padrao(
+        "📋 CONTROLE DE OSM – Inclusões / Exclusões • Visão por linha (D3 a partir das 16h)"
+    )
+
+    debug = st.toggle("🔍 Modo debug", value=False)
+
+    # ======================================================
+    # EXPANDER • Pré-carregar por Nota Fiscal
+    # ======================================================
+    with st.expander("🧾 Pré-carregar via Nota Fiscal (clonar como nova entrada)", expanded=False):
+        col1, col2, col3 = st.columns([2, 2, 1.2])
+        nf_digitado = col1.text_input("Digite a Nota Fiscal", key="nf_lookup")
+        nf_select = col2.selectbox("Ou selecione", [""] + get_notas_fiscais(), key="nf_select")
+        marcar_origem = col3.checkbox("Marcar origem", value=True, key="nf_marcar_origem")
+
+        c1, c2 = st.columns(2)
+        buscar = c1.button("🔎 Buscar NF", key="btn_buscar_nf")
+        limpar = c2.button("🧹 Limpar pré-preenchimento", key="btn_limpar_prefill")
+
+        if limpar:
+            # Limpa apenas os w_* e marcadores de prefill/resultados
+            for k in list(st.session_state.keys()):
+                if k.startswith("w_"):
+                    del st.session_state[k]
+            st.session_state.pop("form_prefill", None)
+            st.session_state.pop("__prefill_applied__", None)
+            st.session_state.pop("__nf_busca_result__", None)
+            st.session_state.pop("__nf_busca_opts__", None)
+            st.session_state.pop("sel_registro_base", None)
+            st.success("Pré-preenchimento limpo.")
+            st.rerun()
+
+        if buscar:
+            nf = (nf_digitado or nf_select or "").strip()
+            if not nf:
+                st.warning("Informe ou selecione uma Nota Fiscal.")
+            else:
+                db = SessionLocal()
+                try:
+                    regs = (
+                        db.query(Equipamento)
+                        .filter(Equipamento.nota_fiscal == nf)
+                        .order_by(Equipamento.id.desc())
+                        .all()
+                    )
+                except Exception as e:
+                    regs = []
+                    st.error(f"Erro ao buscar NF: {e}")
+                finally:
+                    db.close()
+
+                if not regs:
+                    st.info("Nenhum registro encontrado para a NF informada.")
+                    st.session_state.pop("__nf_busca_result__", None)
+                    st.session_state.pop("__nf_busca_opts__", None)
+                else:
+                    # Persistimos APENAS IDs e um resumo textual (não guardamos objetos SQLAlchemy)
+                    result = [
+                        {"id": r.id, "data_coleta": str(r.data_coleta), "fpso": r.fpso or "—", "osm": r.osm or "—"}
+                        for r in regs
+                    ]
+                    opts = [f"ID {x['id']} | {x['data_coleta']} | FPSO {x['fpso']} | OSM {x['osm']}" for x in result]
+
+                    st.session_state["__nf_busca_result__"] = result
+                    st.session_state["__nf_busca_opts__"] = opts
+                    # Reset da seleção anterior
+                    st.session_state["sel_registro_base"] = opts[0] if opts else None
+
+        # ⬇️ Mostrar seleção + botão USAR sempre que houver resultado persistido
+        if st.session_state.get("__nf_busca_opts__"):
+            escolha = st.selectbox(
+                "Selecione o registro base",
+                st.session_state["__nf_busca_opts__"],
+                key="sel_registro_base"
+            )
+
+            if st.button("📥 Usar este registro como base", key="btn_usar_base"):
+                try:
+                    # Extrai o ID do texto selecionado
+                    chosen_id = int(escolha.split()[1])
+                except Exception:
+                    st.error("Falha ao identificar o ID do registro selecionado.")
+                    chosen_id = None
+
+                if chosen_id:
+                    # Busca o registro no banco por ID (seguro e stateless)
+                    db = SessionLocal()
+                    try:
+                        base = db.query(Equipamento).filter(Equipamento.id == chosen_id).first()
+                    except Exception as e:
+                        base = None
+                        st.error(f"Erro ao buscar o registro por ID: {e}")
+                    finally:
+                        db.close()
+
+                    if not base:
+                        st.error("Registro não encontrado. Tente buscar novamente.")
+                    else:
+                        pre = _build_prefill_from_record(base)
+                        if marcar_origem:
+                            pre["observacoes"] = (pre.get("observacoes") or "") + \
+                                f" [Clonado do ID {base.id} em {datetime.now():%d/%m/%Y %H:%M}]"
+                        st.session_state["form_prefill"] = pre
+                        st.session_state.pop("__prefill_applied__", None)
+                        st.success("Pré-preenchimento carregado! Role até o formulário para revisar.")
+                        st.rerun()
+
+    # ======================================================
+    # APLICAR PREFILL (antes de criar os widgets)
+    # ======================================================
+    prefill = _ss_get("form_prefill", {})
+    _apply_prefill_to_state(prefill, debug=debug)
+
+    if debug:
+        with st.expander("🔎 DEBUG • session_state (parcial)"):
+            keys = [k for k in st.session_state.keys() if k.startswith("w_") or k in ("form_prefill", "__prefill_applied__", "__nf_busca_result__", "__nf_busca_opts__", "sel_registro_base")]
+            dump = {k: st.session_state[k] for k in sorted(keys)}
+            st.write(dump)
+
+    # ======================================================
+    # FORMULÁRIO (SEM st.form)
+    # ======================================================
+
+    # -------- FPSO --------
+    st.subheader("🚢 Identificação FPSO")
+    c1, c2 = st.columns(2)
+
+    lista_fpso1 = get_fpsos1() + ["➕ Novo FPSO1"]
+    lista_fpso = get_fpsos() + ["➕ Novo FPSO"]
+
+    # Se valor não está na lista, muda para "➕ Novo …" e mantém texto
+    if _ss_get("w_fpso1", "") not in lista_fpso1:
+        _ss_set("w_fpso1", "➕ Novo FPSO1" if _ss_get("w_fpso1_text") else "")
+    if _ss_get("w_fpso", "") not in lista_fpso:
+        _ss_set("w_fpso", "➕ Novo FPSO" if _ss_get("w_fpso_text") else "")
+
+    with c1:
+        st.selectbox(
+            "FPSO1 *",
+            lista_fpso1,
+            index=_safe_index(lista_fpso1, _ss_get("w_fpso1", "")),
+            key="w_fpso1"
+        )
+        if _ss_get("w_fpso1") == "➕ Novo FPSO1":
+            st.text_input("Digite o novo FPSO1 *", key="w_fpso1_text")
+            fpso1 = _ss_get("w_fpso1_text", "").strip()
+        else:
+            _ss_set("w_fpso1_text", _ss_get("w_fpso1"))
+            fpso1 = _ss_get("w_fpso1")
+
+    with c2:
+        st.selectbox(
+            "FPSO *",
+            lista_fpso,
+            index=_safe_index(lista_fpso, _ss_get("w_fpso", "")),
+            key="w_fpso"
+        )
+        if _ss_get("w_fpso") == "➕ Novo FPSO":
+            st.text_input("Digite o novo FPSO *", key="w_fpso_text")
+            fpso = _ss_get("w_fpso_text", "").strip()
+        else:
+            _ss_set("w_fpso_text", _ss_get("w_fpso"))
+            fpso = _ss_get("w_fpso")
+
+    st.divider()
+
+    # -------- Dados Operacionais --------
+    st.subheader("📦 Dados Operacionais")
+    c1, c2, c3 = st.columns(3)
+
+    with c1:
+        # 🟢 Usa valor do estado; se vier None, o widget ainda precisa de um date válido.
+        st.date_input(
+            "Data de Coleta na ARM *",
+            value=_ss_get("w_data_coleta") or date.today(),
+            key="w_data_coleta"
+        )
+        st.text_input("Especialista Responsável *", key="w_especialista")
+        st.text_input("Conferente Responsável *", key="w_conferente")
+        st.text_input("OSM *", key="w_osm")
+
+    with c2:
+        st.selectbox("Modal *", MODAL_LISTA,
+            index=_safe_index(MODAL_LISTA, _ss_get("w_modal", "")),
+            key="w_modal")
+        st.number_input("Quantidade de Equipamentos *", min_value=0, value=_ss_get("w_quant_equip", 0), key="w_quant_equip")
+        st.text_input("MROB *", key="w_mrob")
+
+    with c3:
+        st.number_input("Total de Linhas OSM", min_value=0, value=_ss_get("w_linhas_osm", 0), key="w_linhas_osm")
+        st.number_input("Total de Linhas MROB", min_value=0, value=_ss_get("w_linhas_mrob", 0), key="w_linhas_mrob")
+        st.number_input("Total de Linhas com Erro", min_value=0, value=_ss_get("w_linhas_erros", 0), key="w_linhas_erros")
+
+    st.divider()
+
+    # -------- Análise de Erros --------
+    st.subheader("⚠️ Análise de Erros")
+    c1, c2, c3, c4 = st.columns(4)
+    c1.selectbox("Storekeeper", RESP_ERRO_LISTA, index=_safe_index(RESP_ERRO_LISTA, _ss_get("w_erro_storekeeper", "")), key="w_erro_storekeeper")
+    c2.selectbox("Operação WH", RESP_ERRO_LISTA, index=_safe_index(RESP_ERRO_LISTA, _ss_get("w_erro_operacao", "")), key="w_erro_operacao")
+    c3.selectbox("Especialista WH", RESP_ERRO_LISTA, index=_safe_index(RESP_ERRO_LISTA, _ss_get("w_erro_especialista", "")), key="w_erro_especialista")
+    c4.selectbox("Outros", RESP_ERRO_LISTA, index=_safe_index(RESP_ERRO_LISTA, _ss_get("w_erro_outros", "")), key="w_erro_outros")
+
+    st.selectbox(
+        "Inclusão / Exclusão",
+        INCLUSAO_EXCLUSAO_LISTA,
+        index=_safe_index(INCLUSAO_EXCLUSAO_LISTA, _ss_get("w_inclusao_exclusao", "")),
+        key="w_inclusao_exclusao"
+    )
+
+    st.divider()
+
+    # -------- Dados Administrativos --------
+    st.subheader("🧾 Dados Administrativos")
+    ca, cb, cc = st.columns(3)
+    with ca:
+        st.text_input("PO", key="w_po")
+        st.text_input("Part Number", key="w_part_number")
+    with cb:
+        st.text_input("Material", key="w_material")
+        st.text_input("Nota Fiscal *", key="w_nota_fiscal")
+    with cc:
+        st.text_input("Solicitante *", key="w_solicitante")
+        st.text_input("Requisitante *", key="w_requisitante")
+
+    st.text_input("Impacto *", key="w_impacto")
+    st.text_input("Dimensão *", key="w_dimensao")
+    st.text_input("Motivo da Inclusão / Exclusão", key="w_motivo")
+
+    st.text_area("Observações", key="w_observacoes", height=120)
+
+    # -------- Dia D --------
+    st.subheader("🗓️ Dia de Inclusão (D)")
+    st.selectbox(
+        "Selecione o dia",
+        D_LISTA,
+        index=_safe_index(D_LISTA, _ss_get("w_dia_inclusao", "")),
+        key="w_dia_inclusao"
+    )
+
+    # ======================================================
+    # SALVAR (sempre nova entrada)
+    # ======================================================
+    if st.button("💾 Salvar Registro", type="primary"):
+        # Lê valores atuais do session_state
+        data_coleta = _ss_get("w_data_coleta")
+        especialista = _ss_get("w_especialista", "").strip()
+        conferente = _ss_get("w_conferente", "").strip()
+        osm = _ss_get("w_osm", "").strip()
+        modal = _ss_get("w_modal", "")
+        quant_equip = int(_ss_get("w_quant_equip", 0) or 0)
+        mrob = _ss_get("w_mrob", "").strip()
+        linhas_osm = int(_ss_get("w_linhas_osm", 0) or 0)
+        linhas_mrob = int(_ss_get("w_linhas_mrob", 0) or 0)
+        linhas_erros = int(_ss_get("w_linhas_erros", 0) or 0)
+        erro_storekeeper = _ss_get("w_erro_storekeeper", "")
+        erro_operacao = _ss_get("w_erro_operacao", "")
+        erro_especialista = _ss_get("w_erro_especialista", "")
+        erro_outros = _ss_get("w_erro_outros", "")
+        inclusao_exclusao = _ss_get("w_inclusao_exclusao", "")
+        po = _ss_get("w_po", "").strip()
+        part_number = _ss_get("w_part_number", "").strip()
+        material = _ss_get("w_material", "").strip()
+        solicitante = _ss_get("w_solicitante", "").strip()
+        requisitante = _ss_get("w_requisitante", "").strip()
+        nota_fiscal = _ss_get("w_nota_fiscal", "").strip()
+        impacto = _ss_get("w_impacto", "").strip()
+        dimensao = _ss_get("w_dimensao", "").strip()
+        motivo = _ss_get("w_motivo", "").strip()
+        observacoes = _ss_get("w_observacoes", "").strip()
+        dia_inclusao = _ss_get("w_dia_inclusao", "")
+
+        # Campos FPSO/FPSO1
+        fpso1 = _ss_get("w_fpso1_text", "").strip() if _ss_get("w_fpso1") == "➕ Novo FPSO1" else _ss_get("w_fpso1", "").strip()
+        fpso  = _ss_get("w_fpso_text", "").strip()  if _ss_get("w_fpso")  == "➕ Novo FPSO"  else _ss_get("w_fpso", "").strip()
+
+        obrigatorios = {
+            "FPSO1": fpso1,
+            "FPSO": fpso,
+            "Especialista": especialista,
+            "Conferente": conferente,
+            "OSM": osm,
+            "Modal": modal,
+            "MROB": mrob,
+            "Solicitante": solicitante,
+            "Requisitante": requisitante,
+            "Nota Fiscal": nota_fiscal,
+            "Impacto": impacto,
+            "Dimensão": dimensao,
+            "Dia de Inclusão (D)": dia_inclusao,
+        }
+        faltantes = [k for k, v in obrigatorios.items() if not v]
+        if faltantes:
+            st.error("❌ Campos obrigatórios não preenchidos: " + ", ".join(faltantes))
+            return
+
+        db = SessionLocal()
+        try:
+            novo = Equipamento(
+                fpso1=fpso1,
+                fpso=fpso,
+                data_coleta=data_coleta,
+                especialista=especialista,
+                conferente=conferente,
+                osm=osm,
+                modal=modal,
+                quant_equip=quant_equip,
+                mrob=mrob,
+                linhas_osm=linhas_osm,
+                linhas_mrob=linhas_mrob,
+                linhas_erros=linhas_erros,
+                erro_storekeeper=erro_storekeeper,
+                erro_operacao=erro_operacao,
+                erro_especialista=erro_especialista,
+                erro_outros=erro_outros,
+                inclusao_exclusao=inclusao_exclusao,
+                po=po,
+                part_number=part_number,
+                material=material,
+                solicitante=solicitante,
+                motivo=motivo,
+                requisitante=requisitante,
+                nota_fiscal=nota_fiscal,
+                impacto=impacto,
+                dimensao=dimensao,
+                observacoes=observacoes,
+                dia_inclusao=dia_inclusao,
+                data_hora_input=datetime.now(),
+            )
+            db.add(novo)
+            db.commit()
+
+            registrar_log(
+                usuario=_ss_get("usuario", "desconhecido"),
+                acao="INSERIR",
+                tabela="equipamentos",
+                registro_id=novo.id
+            )
+
+            st.success("✅ Registro salvo com sucesso!")
+            st.rerun()
+
+        except Exception as e:
+            db.rollback()
+            st.error(f"❌ Erro ao salvar: {e}")
+        finally:
+            db.close()
+
+if __name__ == "__main__":
+    main()

importar_excel.py

@@ -0,0 +1,301 @@
+
+import streamlit as st
+import pandas as pd
+from io import BytesIO
+from datetime import datetime, date
+
+from banco import SessionLocal
+from models import Equipamento
+from utils_auditoria import registrar_log
+
+
+# =====================================================
+# FUNÇÕES AUXILIARES
+# =====================================================
+def to_date(value):
+    """
+    Converte pandas.Timestamp ou datetime para datetime.date
+    Necessário para compatibilidade com SQLite
+    """
+    if value is None or pd.isna(value):
+        return None
+    if isinstance(value, pd.Timestamp):
+        return value.date()
+    if isinstance(value, datetime):
+        return value.date()
+    if isinstance(value, date):
+        return value
+    return None
+
+
+def safe_value(value):
+    """
+    Retorna 0 se o valor for vazio/NaN, senão retorna o próprio valor.
+    Usado para campos obrigatórios.
+    """
+    if value is None or pd.isna(value):
+        return 0
+    return value
+
+
+# =====================================================
+# MÓDULO PRINCIPAL
+# =====================================================
+def main():
+    st.title("📥 Importação de Dados via Excel")
+
+    st.markdown(
+        """
+        Este módulo permite:
+        - 📄 Baixar um **modelo Excel padrão**
+        - ✍️ Preencher os dados offline
+        - 🔍 Validar antes da gravação
+        - 💾 Importar os registros para o banco
+        """
+    )
+
+    # =====================================================
+    # 1️⃣ GERAR MODELO EXCEL
+    # =====================================================
+    st.subheader("📄 Baixar modelo Excel")
+
+    colunas = [
+        "fpso1", "fpso", "data_coleta", "especialista", "conferente", "osm", "modal",
+        "quant_equip", "mrob", "linhas_osm", "linhas_mrob", "linhas_erros",
+        "erro_storekeeper", "erro_operacao", "erro_especialista", "erro_outros",
+        "inclusao_exclusao", "po", "part_number", "material", "solicitante", "motivo",
+        "requisitante", "nota_fiscal", "impacto", "dimensao", "observacoes", "dia_inclusao",
+    ]
+
+    modelo_df = pd.DataFrame(columns=colunas)
+
+    buffer = BytesIO()
+    with pd.ExcelWriter(buffer, engine="openpyxl") as writer:
+        modelo_df.to_excel(writer, index=False, sheet_name="MODELO")
+
+    buffer.seek(0)
+
+    st.download_button(
+        label="⬇️ Baixar modelo Excel",
+        data=buffer,
+        file_name="modelo_importacao_load.xlsx",
+        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    )
+
+    st.divider()
+
+    # =====================================================
+    # 2️⃣ UPLOAD DO ARQUIVO
+    # =====================================================
+    st.subheader("📤 Importar arquivo preenchido")
+
+    arquivo = st.file_uploader(
+        "Selecione o arquivo Excel",
+        type=["xlsx"]
+    )
+
+    if not arquivo:
+        st.info("📌 Faça o upload de um arquivo para continuar.")
+        return
+
+    try:
+        df = pd.read_excel(arquivo)
+    except Exception as e:
+        st.error(f"❌ Erro ao ler o arquivo: {e}")
+        return
+
+    # Garante um identificador estável para cada linha durante as edições
+    if "_row_id" not in df.columns:
+        df["_row_id"] = range(len(df))
+
+    # Salva o DF bruto na sessão para persistência entre reruns
+    st.session_state["df_raw"] = df.copy()
+
+    st.success("✅ Arquivo carregado com sucesso!")
+
+    # =====================================================
+    # 3️⃣ PRÉVIA DOS DADOS
+    # =====================================================
+    st.subheader("🔍 Prévia dos dados")
+    st.dataframe(df, use_container_width=True)
+
+    # =====================================================
+    # 4️⃣ VERIFICAÇÃO DE DUPLICIDADE (com seleção de linhas a excluir)
+    # =====================================================
+    st.subheader("🧪 Verificação de duplicidade")
+
+    st.caption("Escolha as colunas que definem a duplicidade. Em seguida, marque o checkbox **_excluir** nas linhas que **não** deseja importar.")
+
+    # Sugerimos um conjunto padrão de chaves, mas só usamos as que existem no arquivo
+    sugestao_chaves = [c for c in ["fpso", "osm", "po", "part_number", "nota_fiscal", "data_coleta"] if c in df.columns]
+
+    chaves = st.multiselect(
+        "📌 Colunas para verificação de duplicidade:",
+        options=list(df.columns),
+        default=sugestao_chaves if len(sugestao_chaves) > 0 else []
+    )
+
+    # Prepara um DF de trabalho com colunas auxiliares
+    work_df = df.copy()
+    work_df["_duplicado"] = False
+    work_df["_excluir"] = False  # será editado pelo usuário
+
+    if len(chaves) == 0:
+        st.info("Selecione ao menos **uma** coluna para verificar duplicidade.")
+        # Mesmo sem duplicidade definida, permitimos marcar exclusões manuais, se quiser:
+        with st.expander("🔧 (Opcional) Excluir linhas manualmente mesmo sem duplicidade"):
+            manual_view = work_df.set_index("_row_id")[
+                [c for c in work_df.columns if c not in ["_duplicado"]] + ["_excluir"]
+            ]
+            edited_manual = st.data_editor(
+                manual_view,
+                use_container_width=True,
+                num_rows="fixed",
+                column_config={
+                    "_excluir": st.column_config.CheckboxColumn("Excluir da importação")
+                }
+            )
+            # Aplica exclusões manuais
+            work_df = work_df.set_index("_row_id")
+            work_df["_excluir"] = edited_manual["_excluir"].reindex(work_df.index).fillna(False).astype(bool)
+            work_df = work_df.reset_index()
+
+    else:
+        # Marca duplicadas com base nas chaves selecionadas
+        mask_dup_any = work_df.duplicated(subset=chaves, keep=False)
+        work_df["_duplicado"] = mask_dup_any
+
+        # Sugerimos exclusão automática das ocorrências não-primárias (o usuário pode alterar)
+        mask_dup_not_first = work_df.duplicated(subset=chaves, keep="first")
+        work_df.loc[mask_dup_not_first, "_excluir"] = True
+
+        if mask_dup_any.any():
+            st.warning("⚠️ Foram encontradas linhas duplicadas com base nas chaves selecionadas:")
+            # Mostrar somente as duplicadas para facilitar a decisão
+            cols_para_mostrar = chaves + [c for c in ["_duplicado", "_excluir"] if c not in chaves]
+            # Evita colunas repetidas mantendo ordem
+            seen = set()
+            cols_para_mostrar = [c for c in cols_para_mostrar if not (c in seen or seen.add(c))]
+
+            dup_view = work_df.loc[mask_dup_any].set_index("_row_id")[cols_para_mostrar]
+            edited_dup = st.data_editor(
+                dup_view,
+                use_container_width=True,
+                num_rows="fixed",
+                column_config={
+                    "_excluir": st.column_config.CheckboxColumn("Excluir da importação"),
+                    "_duplicado": st.column_config.CheckboxColumn("Duplicado", disabled=True)
+                }
+            )
+
+            # Mescla de volta as escolhas do usuário
+            work_df = work_df.set_index("_row_id")
+            if "_excluir" in edited_dup.columns:
+                work_df.loc[edited_dup.index, "_excluir"] = (
+                    edited_dup["_excluir"].reindex(work_df.index).fillna(work_df["_excluir"]).astype(bool)
+                )
+            work_df = work_df.reset_index()
+
+            st.info(
+                f"📊 Totais — Linhas: {len(work_df)} | Duplicadas: {mask_dup_any.sum()} | "
+                f"Marcadas para excluir: {int(work_df['_excluir'].sum())}"
+            )
+        else:
+            st.success("✅ Nenhuma duplicidade encontrada com as chaves selecionadas.")
+
+    st.divider()
+
+    # =====================================================
+    # 4.1️⃣ Prévia final do que será importado + download
+    # =====================================================
+    df_para_importar = work_df[~work_df["_excluir"]].drop(columns=["_duplicado", "_excluir"], errors="ignore")
+    st.session_state["df_para_importar"] = df_para_importar.copy()
+
+    st.subheader("🧾 Prévia do que será importado")
+    st.caption("A prévia abaixo desconsidera as linhas marcadas como **_excluir**.")
+    st.dataframe(df_para_importar.drop(columns=["_row_id"], errors="ignore"), use_container_width=True)
+
+    # Download da prévia para conferência
+    buf_prev = BytesIO()
+    with pd.ExcelWriter(buf_prev, engine="openpyxl") as writer:
+        df_para_importar.drop(columns=["_row_id"], errors="ignore").to_excel(writer, index=False, sheet_name="A_IMPORTAR")
+    buf_prev.seek(0)
+    st.download_button(
+        "⬇️ Baixar prévia (Excel)",
+        data=buf_prev,
+        file_name="previa_a_importar.xlsx",
+        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        help="Baixe a prévia do conjunto que será gravado."
+    )
+
+    # =====================================================
+    # 5️⃣ GRAVAÇÃO NO BANCO (usa o DataFrame filtrado)
+    # =====================================================
+    st.subheader("💾 Gravar dados no banco")
+
+    col1, col2 = st.columns(2)
+
+    if col1.button("💾 Salvar registros importados"):
+        df_import = st.session_state.get("df_para_importar", df)
+
+        if df_import.empty:
+            st.error("Não há registros para importar. Revise as exclusões.")
+            return
+
+        with SessionLocal() as db:
+            try:
+                for _, row in df_import.iterrows():
+                    registro = Equipamento(
+                        fpso1=safe_value(row.get("fpso1")),
+                        fpso=safe_value(row.get("fpso")),
+                        data_coleta=to_date(row.get("data_coleta")),
+                        especialista=safe_value(row.get("especialista")),
+                        conferente=safe_value(row.get("conferente")),
+                        osm=safe_value(row.get("osm")),
+                        modal=safe_value(row.get("modal")),
+                        quant_equip=int(row["quant_equip"]) if not pd.isna(row.get("quant_equip")) else 0,
+                        mrob=safe_value(row.get("mrob")),
+                        linhas_osm=int(row["linhas_osm"]) if not pd.isna(row.get("linhas_osm")) else 0,
+                        linhas_mrob=int(row["linhas_mrob"]) if not pd.isna(row.get("linhas_mrob")) else 0,
+                        linhas_erros=int(row["linhas_erros"]) if not pd.isna(row.get("linhas_erros")) else 0,
+                        erro_storekeeper=safe_value(row.get("erro_storekeeper")),
+                        erro_operacao=safe_value(row.get("erro_operacao")),
+                        erro_especialista=safe_value(row.get("erro_especialista")),
+                        erro_outros=safe_value(row.get("erro_outros")),
+                        inclusao_exclusao=safe_value(row.get("inclusao_exclusao")),
+                        po=safe_value(row.get("po")),
+                        part_number=safe_value(row.get("part_number")),
+                        material=safe_value(row.get("material")),
+                        solicitante=safe_value(row.get("solicitante")),
+                        motivo=safe_value(row.get("motivo")),
+                        requisitante=safe_value(row.get("requisitante")),
+                        nota_fiscal=safe_value(row.get("nota_fiscal")),
+                        impacto=safe_value(row.get("impacto")),
+                        dimensao=safe_value(row.get("dimensao")),
+                        observacoes=safe_value(row.get("observacoes")),
+                        dia_inclusao=safe_value(row.get("dia_inclusao")),
+                    )
+                    db.add(registro)
+
+                db.commit()
+
+                registrar_log(
+                    usuario=st.session_state.get("usuario"),
+                    acao=f"IMPORTAÇÃO EXCEL ({len(df_import)} registros) - com filtro de duplicidade",
+                    tabela="equipamentos",
+                    registro_id=None
+                )
+
+                st.success(f"🎉 Importação concluída com sucesso! {len(df_import)} registros gravados.")
+
+            except Exception as e:
+                db.rollback()
+                st.error(f"❌ Erro ao gravar no banco: {e}")
+
+    if col2.button("❌ Cancelar importação"):
+        st.warning("Importação cancelada pelo usuário.")
+
+
+if __name__ == "__main__":
+    main()
+

init_admin.py

@@ -0,0 +1,33 @@
+# init_admin.py
+from banco import SessionLocal, engine, Base
+from models import Usuario
+from werkzeug.security import generate_password_hash
+
+def criar_admin():
+    Base.metadata.create_all(bind=engine)
+
+    db = SessionLocal()
+
+    admin = db.query(Usuario).filter(Usuario.usuario == "admin").first()
+
+    if admin:
+        print("✔ Usuário admin já existe")
+        return
+
+    admin = Usuario(
+        usuario="admin",
+        senha=generate_password_hash("admin123"),
+        perfil="admin",
+        ativo=True
+    )
+
+    db.add(admin)
+    db.commit()
+    db.close()
+
+    print("✅ Usuário admin criado com sucesso")
+    print("Login: admin")
+    print("Senha: admin123")
+
+if __name__ == "__main__":
+    criar_admin()

init_db.py

@@ -0,0 +1,38 @@
+from banco import engine, SessionLocal, Base
+import models
+from models import Usuario
+from utils_seguranca import gerar_hash_senha
+
+# Cria todas as tabelas definidas nos modelos
+Base.metadata.create_all(bind=engine)
+
+db = SessionLocal()
+
+try:
+    usuarios_padrao = [
+        ("admin", "admin123", "admin"),
+        ("usuario", "usuario123", "usuario"),
+        ("consulta", "consulta123", "consulta"),
+    ]
+
+    for nome, senha, perfil in usuarios_padrao:
+        existe = db.query(Usuario).filter(Usuario.usuario == nome).first()
+
+        if not existe:
+            novo = Usuario(
+                usuario=nome,
+                senha=gerar_hash_senha(senha),
+                perfil=perfil,
+                ativo=True
+            )
+            db.add(novo)
+            print(f"✅ Usuário '{nome}' criado")
+        else:
+            print(f"ℹ️ Usuário '{nome}' já existe")
+
+    db.commit()
+
+finally:
+    db.close()
+
+print("✅ Banco inicializado com sucesso!")

jogos.py

@@ -0,0 +1,384 @@
+
+import streamlit as st
+import random
+import unicodedata
+from datetime import date, timedelta  # ✅ para controle diário de tentativas falhas
+
+
+def reset_keys(keys):
+    for k in keys:
+        st.session_state.pop(k, None)
+
+
+def strip_accents(s: str) -> str:  # ✅ corrigido '->' (sem entidades HTML)
+    if not isinstance(s, str):
+        return s
+    return "".join(c for c in unicodedata.normalize("NFD", s) if unicodedata.category(c) != "Mn")
+
+
+# ✅ Helper de estado: garantia defensiva (executa sem impactar sua lógica)
+def _init_estado_jogos():
+    st.session_state.setdefault("pontuacao", 0)
+    st.session_state.setdefault("rodadas", 0)
+    st.session_state.setdefault("ultimo_resultado", None)
+    # ⬇️ NOVO (Dado): memória de resultados já vistos por configuração de lados
+    st.session_state.setdefault("dado_resultados_vistos", [])
+    st.session_state.setdefault("dado_lados_atual", None)
+    # ⬇️ NOVO (Forca): palavras já concluídas por categoria (evita pontuar repetidas)
+    # Estrutura: { "FPSO": ["INSPECAO VISUAL", ...], "Estoque e Armazenagens": [...], ... }
+    st.session_state.setdefault("forca_palavras_vistas", {})
+    # ⬇️ NOVO (Forca): letras já clicadas (apagadas/desativadas no teclado)
+    st.session_state.setdefault("forca_letras_usadas", set())
+    # ⬇️ NOVO (Forca): controle diário por rodada perdida (tentativa de jogo falha)
+    st.session_state.setdefault("forca_falhas_hoje", 0)
+    st.session_state.setdefault("forca_block_expires_on", None)
+    st.session_state.setdefault("forca_data_ref", str(date.today()))
+    st.session_state.setdefault("forca_round_contabilizado", False)  # marca se a perda já foi contabilizada nesta rodada
+    # ⬇️ NOVO (Tesouro): perguntas já concluídas por categoria (evita pontuar repetidas)
+    # Estrutura: { "FPSO": ["Identifique o item correto...", ...], ... }
+    st.session_state.setdefault("tesouro_perguntas_vistas", {})
+
+
+# Mantém inicialização que você tinha (compatível com o helper)
+if "pontuacao" not in st.session_state:
+    st.session_state.pontuacao = 0
+
+
+FORCA_BANK = [
+    {
+        "categoria": "FPSO",
+        "pergunta": "Qual procedimento prioriza a integridade de carga no deck?",
+        "resposta": "INSPEÇÃO VISUAL",
+    },
+    {
+        "categoria": "Estoque e Armazenagens",
+        "pergunta": "Qual política prioriza itens com menor validade remanescente?",
+        "resposta": "FEFO",
+    },
+    {
+        "categoria": "Óleo e Gás",
+        "pergunta": "Qual documento acompanha movimentação de resíduos perigosos?",
+        "resposta": "MANIFESTO DE RESÍDUOS",
+    },
+]
+
+TESOURO_BANK = [
+    {
+        "categoria": "FPSO",
+        "pergunta": "Identifique o item correto para amarração segura no deck.",
+        "pistas": [
+            {"texto": "Requer inspeção visual antes do uso.", "correto": True},
+            {"texto": "É descartável após uma operação.", "correto": False},
+            {"texto": "Possui etiqueta de carga segura com WLL.", "correto": True},
+            {"texto": "Não pode ser usado em ambiente offshore.", "correto": False},
+        ],
+    },
+    {
+        "categoria": "Estoque e Armazenagens",
+        "pergunta": "Determine a política correta para expedição de produtos com validade.",
+        "pistas": [
+            {"texto": "Prioriza vencimento mais próximo.", "correto": True},
+            {"texto": "Ignora datas de validade.", "correto": False},
+        ],
+    },
+]
+
+
+def jogo_dado():
+    _init_estado_jogos()  # ✅ garante chaves antes do uso
+    st.subheader("🎲 Jogo do Dado (Curiosidades)")
+
+    curiosidades = [
+        "FIFO e FEFO impactam diretamente a acuracidade de estoque.",
+        "Cross-docking reduz tempos e evita armazenagem desnecessária.",
+        "WMS integra endereçamento, picking e inventários cíclicos.",
+    ]
+
+    lados = st.slider("Escolha o número de lados do dado:", 6, 20, 8)
+
+    # ⬇️ NOVO: ao alterar o número de lados, resetamos os resultados vistos para esta configuração
+    if st.session_state.dado_lados_atual != lados:
+        st.session_state.dado_lados_atual = lados
+        st.session_state.dado_resultados_vistos = []  # limpa histórico para a nova configuração de lados
+
+    if st.button("Girar dado"):
+        resultado = random.randint(1, lados)
+        st.success(f"🎲 Você rolou: {resultado}")
+        st.info(curiosidades[resultado % len(curiosidades)])
+
+        # ⬇️ NOVO: só pontua se o resultado ainda NÃO tiver saído nesta configuração de lados
+        if resultado in st.session_state.dado_resultados_vistos:
+            st.warning("🔁 Resultado repetido — nenhum ponto adicionado ao ranking.")
+        else:
+            st.session_state.dado_resultados_vistos.append(resultado)
+            st.session_state.pontuacao += 5
+            st.balloons()
+
+    # Informações úteis
+    if st.session_state.dado_resultados_vistos:
+        vistos_fmt = ", ".join(str(v) for v in sorted(st.session_state.dado_resultados_vistos))
+        st.caption(f"🔎 Valores únicos já obtidos com {lados} lados: {vistos_fmt}")
+
+    st.write(f"Pontuação atual: {st.session_state.pontuacao}")
+
+
+def jogo_forca_treinamento():
+    _init_estado_jogos()  # ✅ garante chaves antes do uso
+    st.subheader("🔤 Jogo da Forca (Treinamento)")
+
+    # 🔧 Reset diário dos contadores/bloqueio por rodada perdida
+    if st.session_state.get("forca_data_ref") != str(date.today()):
+        st.session_state.forca_data_ref = str(date.today())
+        st.session_state.forca_falhas_hoje = 0
+        st.session_state.forca_block_expires_on = None
+
+    # 🔒 Se bloqueado até amanhã, impedir jogar
+    block_until = st.session_state.get("forca_block_expires_on")
+    if block_until and date.today() < block_until:
+        st.error(f"⏳ Você atingiu 3 tentativas falhas hoje. Tente novamente em {block_until.strftime('%d/%m/%Y')}.")
+        st.write(f"Pontuação atual: {st.session_state.pontuacao}")
+        return
+
+    categorias = sorted(set(q["categoria"] for q in FORCA_BANK))
+    cat_sel = st.selectbox("Categoria:", ["Todas"] + categorias, index=0)
+
+    banco_filtrado = [q for q in FORCA_BANK if cat_sel == "Todas" or q["categoria"] == cat_sel]
+    total = len(banco_filtrado)
+
+    # Reset ao trocar categoria ou na primeira carga
+    if "forca_idx" not in st.session_state or st.session_state.get("forca_cat") != cat_sel:
+        st.session_state.forca_idx = 0
+        st.session_state.forca_cat = cat_sel
+        reset_keys(["forca_palavra", "letras_descobertas", "tentativas", "letras_erradas", "forca_input", "forca_letras_usadas", "forca_round_contabilizado"])
+
+    if not banco_filtrado:
+        st.warning("Não há perguntas para esta categoria.")
+        return
+
+    nivel = st.session_state.forca_idx % total
+    st.write(f"Progresso: Pergunta {nivel + 1}/{total}")
+    atual = banco_filtrado[nivel]
+    pergunta, resposta = atual["pergunta"], atual["resposta"].upper()
+    categoria_atual = atual["categoria"]
+
+    # Inicializa rodada da forca
+    if "forca_palavra" not in st.session_state or st.session_state.get("forca_palavra") != resposta:
+        st.session_state.forca_palavra = resposta
+        st.session_state.letras_descobertas = ["_" if c.isalpha() else c for c in resposta]
+        st.session_state.tentativas = 6
+        st.session_state.letras_erradas = []
+        st.session_state.forca_letras_usadas = set()  # ⬅️ inicia teclado limpo
+        st.session_state.forca_round_contabilizado = False  # ⬅️ nova rodada ainda não contabilizada como falha
+
+    st.write(f"Pergunta: {pergunta}")
+    st.write("Palavra:", " ".join(st.session_state.letras_descobertas))
+    st.write(f"Tentativas restantes: {st.session_state.tentativas}")
+
+    # ==============================
+    # 🔤 NOVO: TECLADO DE ALFABETO (compacto)
+    # ==============================
+    # CSS para deixar botões mais juntos (afeta globalmente — usar com parcimônia)
+    st.markdown(
+        """
+        <style>
+        div.stButton > button {
+            padding: 6px 8px !important;
+            margin: 2px !important;
+            font-size: 14px !important;
+        }
+        </style>
+        """,
+        unsafe_allow_html=True
+    )
+
+    # A–Z; comparação sem acentos (ex.: 'O' casa 'Ó', 'C' casa 'Ç')
+    alfabeto = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+
+    # Duas linhas com 13 letras cada (mais compacto)
+    linhas = [
+        alfabeto[0:13],
+        alfabeto[13:26],
+    ]
+
+    for idx_linha, linha in enumerate(linhas):
+        cols = st.columns(len(linha))
+        for idx_letra, letra in enumerate(linha):
+            usada = letra in st.session_state.forca_letras_usadas
+            if cols[idx_letra].button(letra, key=f"forca_btn_{nivel}_{letra}", disabled=usada):
+                # Marca como usada (apagada)
+                st.session_state.forca_letras_usadas.add(letra)
+
+                # Verifica se a letra existe na palavra (comparando sem acentos)
+                hit = False
+                for i, ch in enumerate(st.session_state.forca_palavra):
+                    if strip_accents(ch) == strip_accents(letra):
+                        st.session_state.letras_descobertas[i] = ch
+                        hit = True
+
+                if not hit:
+                    # Letra errada: registra e decrementa tentativa
+                    if letra not in st.session_state.letras_erradas:
+                        st.session_state.letras_erradas.append(letra)
+                        st.session_state.tentativas -= 1
+
+                # Rerender após o clique para atualizar visualmente a palavra e tentativas
+                st.rerun()
+
+    # Feedback de letras erradas (visível)
+    if st.session_state.letras_erradas:
+        st.caption(f"❌ Letras erradas: {', '.join(st.session_state.letras_erradas)}")
+
+    venceu = "_" not in st.session_state.letras_descobertas
+    perdeu = st.session_state.tentativas <= 0  # ✅ corrigido '<=' (sem entidades HTML)
+
+    # ⬇️ NOVO: prepara lista de palavras já vistas por categoria
+    # normaliza removendo acentos para evitar duplicidades por grafia
+    normalizada = strip_accents(resposta)
+
+    if venceu:
+        # Checa repetição por categoria e evita somar pontos
+        vistas = st.session_state.forca_palavras_vistas.get(categoria_atual, [])
+        if normalizada in vistas:
+            st.warning("🔁 Palavra repetida nesta categoria — nenhum ponto adicionado ao ranking.")
+        else:
+            vistas.append(normalizada)
+            st.session_state.forca_palavras_vistas[categoria_atual] = vistas
+            st.success("🎉 Você venceu! Palavra completa.")
+            st.session_state.pontuacao += 10
+            st.balloons()
+
+        # Mostrar resumo de palavras únicas concluídas nesta categoria
+        if st.session_state.forca_palavras_vistas.get(categoria_atual):
+            lista_fmt = ", ".join(st.session_state.forca_palavras_vistas[categoria_atual])
+            st.caption(f"🔎 Palavras únicas concluídas ({categoria_atual}): {lista_fmt}")
+
+        if nivel + 1 < total:  # ✅ corrigido '<' (sem entidades HTML)
+            if st.button("➡️ Próxima pergunta"):
+                st.session_state.forca_idx += 1
+                reset_keys(["forca_palavra", "letras_descobertas", "tentativas", "letras_erradas", "forca_input", "forca_letras_usadas", "forca_round_contabilizado"])
+                st.rerun()
+        else:
+            st.success("🏆 Você finalizou todas as perguntas do jogo da Forca!")
+
+    elif perdeu:
+        # ✅ NOVO: contabiliza tentativa falha (rodada perdida) uma única vez
+        if not st.session_state.forca_round_contabilizado:
+            st.session_state.forca_falhas_hoje += 1
+            st.session_state.forca_round_contabilizado = True
+
+            # 🔒 Bloqueia após 3 tentativas falhas no dia
+            if st.session_state.forca_falhas_hoje >= 3:
+                st.session_state.forca_block_expires_on = date.today() + timedelta(days=1)
+                st.error(
+                    f"⏳ Limite diário atingido (3 tentativas falhas). "
+                    f"Tente novamente em {st.session_state.forca_block_expires_on.strftime('%d/%m/%Y')}."
+                )
+
+        st.error(f"💀 Você perdeu! A palavra era: {st.session_state.forca_palavra}")
+
+    st.write(f"Pontuação atual: {st.session_state.pontuacao}")
+
+
+def jogo_tesouro_niveis():
+    _init_estado_jogos()  # ✅ garante chaves antes do uso
+    st.subheader("🗺️ Caça ao Tesouro (Níveis)")
+
+    categorias = sorted(set(q["categoria"] for q in TESOURO_BANK))
+    cat_sel = st.selectbox("Categoria:", ["Todas"] + categorias, index=0)
+
+    banco_filtrado = [q for q in TESOURO_BANK if cat_sel == "Todas" or q["categoria"] == cat_sel]
+    total = min(100, len(banco_filtrado))
+
+    # Reset ao trocar categoria ou primeira carga
+    if "tes_idx" not in st.session_state or st.session_state.get("tes_cat") != cat_sel:
+        st.session_state.tes_idx = 0
+        st.session_state.tes_cat = cat_sel
+        reset_keys(["tes_respostas", "tes_concluido"])
+
+    if total == 0:
+        st.warning("Não há perguntas para esta categoria.")
+        return
+
+    nivel = st.session_state.tes_idx % total
+    st.write(f"Progresso: Nível {nivel + 1}/{total}")
+    atual = banco_filtrado[nivel]
+    pergunta_atual = atual["pergunta"]
+    categoria_atual = atual["categoria"]
+    st.write(f"Pergunta: {pergunta_atual}")
+
+    if "tes_respostas" not in st.session_state:
+        st.session_state.tes_respostas = {i: None for i in range(len(atual["pistas"]))}
+        st.session_state.tes_concluido = False
+
+    for i, pista in enumerate(atual["pistas"]):
+        cols = st.columns([6, 1, 1])
+        cols[0].write(f"🧩 {pista['texto']}")
+        if cols[1].button("Sim", key=f"tes_sim_{nivel}_{i}"):
+            st.session_state.tes_respostas[i] = True
+        if cols[2].button("Não", key=f"tes_nao_{nivel}_{i}"):
+            st.session_state.tes_respostas[i] = False
+
+        r = st.session_state.tes_respostas[i]
+        if r is not None:
+            if r == pista["correto"]:
+                cols[0].success("✅ Correto")
+            else:
+                cols[0].error("❌ Incorreto")
+
+    tudo_respondido = all(v is not None for v in st.session_state.tes_respostas.values())
+    tudo_correto = tudo_respondido and all(
+        st.session_state.tes_respostas[i] == p["correto"] for i, p in enumerate(atual["pistas"])
+    )
+
+    # ⬇️ NOVO: prepara lista de perguntas já concluídas por categoria
+    pergunta_norm = strip_accents(pergunta_atual).upper()
+
+    if tudo_correto:
+        st.session_state.tes_concluido = True
+
+        # Checa repetição por categoria e evita somar pontos
+        vistas = st.session_state.tesouro_perguntas_vistas.get(categoria_atual, [])
+        if pergunta_norm in vistas:
+            st.warning("🔁 Nível/pergunta já concluído anteriormente — nenhum ponto adicionado ao ranking.")
+        else:
+            vistas.append(pergunta_norm)
+            st.session_state.tesouro_perguntas_vistas[categoria_atual] = vistas
+            st.success("🎉 Parabéns! Nível concluído.")
+            st.session_state.pontuacao += 10
+            st.balloons()
+
+        # Mostrar resumo de perguntas únicas concluídas nesta categoria
+        if st.session_state.tesouro_perguntas_vistas.get(categoria_atual):
+            lista_fmt = ", ".join(st.session_state.tesouro_perguntas_vistas[categoria_atual])
+            st.caption(f"🔎 Perguntas únicas concluídas ({categoria_atual}): {lista_fmt}")
+
+        if nivel + 1 < total:  # ✅ corrigido '<' (sem entidades HTML)
+            if st.button("➡️ Avançar para o próximo nível"):
+                st.session_state.tes_idx += 1
+                reset_keys(["tes_respostas", "tes_concluido"])
+                st.experimental_rerun()
+        else:
+            st.success("🏆 Você finalizou todos os níveis do Caça ao Tesouro!")
+
+    st.write(f"Pontuação atual: {st.session_state.pontuacao}")
+
+
+def main():
+    _init_estado_jogos()  # ✅ garante estado ao entrar na página Jogos
+    st.title("🎮 Jogos Interativos para Treinamento")
+
+    jogo = st.selectbox(
+        "Escolha um jogo:",
+        ["Jogo do Dado (Curiosidades)", "Jogo da Forca (Treinamento)", "Caça ao Tesouro (Níveis)"],
+    )
+
+    if jogo == "Jogo do Dado (Curiosidades)":
+        jogo_dado()
+    elif jogo == "Jogo da Forca (Treinamento)":
+        jogo_forca_treinamento()
+    elif jogo == "Caça ao Tesouro (Níveis)":
+        jogo_tesouro_niveis()
+
+
+if __name__ == "__main__":
+    main()

listar_perguntas.py

@@ -0,0 +1,22 @@
+from banco import SessionLocal
+from models import QuizPergunta, QuizResposta
+
+def listar_perguntas_respostas():
+    db = SessionLocal()
+    try:
+        perguntas = db.query(QuizPergunta).filter(QuizPergunta.ativo == True).all()
+        for p in perguntas:
+            print(f"Pergunta (id={p.id}): {p.pergunta}")
+            respostas = db.query(QuizResposta).filter(QuizResposta.pergunta_id == p.id).all()
+            if not respostas:
+                print("  *** SEM RESPOSTAS CADASTRADAS ***")
+                continue
+            for r in respostas:
+                correta = " (correta)" if r.correta else ""
+                print(f"  - Resposta (id={r.id}): {r.texto}{correta}")
+            print()
+    finally:
+        db.close()
+
+if __name__ == "__main__":
+    listar_perguntas_respostas()

log.py

@@ -0,0 +1,63 @@
+
+from datetime import datetime
+import logging
+from banco import SessionLocal
+from models import LogAcesso
+
+# Configuração mínima de logger (opcional; mantenha neutro)
+logger = logging.getLogger(__name__)
+
+def registrar_log(usuario, acao, tabela, registro_id=None):
+    """
+    Registra um log de acesso/ação na tabela LogAcesso.
+    Mantém assinatura e padrão original, mas com tratamento de exceções e normalização.
+
+    :param usuario: str | usuário responsável pela ação (fallback para 'sistema' se None/vazio)
+    :param acao: str | ação realizada (ex.: 'CRIAR', 'DESATIVAR', 'EXCLUIR')
+    :param tabela: str | nome da tabela/entidade relacionada (ex.: 'eventos_calendario')
+    :param registro_id: int | id do registro afetado (opcional)
+    """
+    # Normalização defensiva (mantendo comportamento atual)
+    usuario = (usuario or "sistema")
+    acao = (acao or "").strip() or "DESCONHECIDA"
+    tabela = (tabela or "").strip() or "desconhecida"
+
+    db = SessionLocal()
+    try:
+        log = LogAcesso(
+            usuario=usuario,
+            acao=acao,
+            tabela=tabela,
+            registro_id=registro_id,
+            data_hora=datetime.now()
+        )
+        db.add(log)
+        db.commit()
+    except Exception as e:
+        # Em caso de falha, desfazer transação e registrar o problema no logger
+        try:
+            db.rollback()
+        except Exception:
+            # Se rollback também falhar, seguimos fechando a sessão
+            pass
+        logger.exception(
+            "Falha ao registrar log: usuario=%r, acao=%r, tabela=%r, registro_id=%r. Erro: %s",
+            usuario, acao, tabela, registro_id, e
+        )
+        # Não propaga exceção: evita quebrar o fluxo da aplicação
+    finally:
+        db.close()
+
+
+# ✅ Opcional: uma versão 'safe' que nunca lança erro para o chamador.
+# Mantém o padrão existente; use quando o log não pode interromper a operação.
+def registrar_log_safe(usuario, acao, tabela, registro_id=None):
+    try:
+        registrar_log(usuario, acao, tabela, registro_id)
+    except Exception:
+        # Defesa adicional: se algo escapar do registrar_log, não quebra o chamador
+        logger.exception(
+            "registrar_log_safe: erro inesperado ao registrar log (usuario=%r, acao=%r, tabela=%r, registro_id=%r)",
+            usuario, acao, tabela, registro_id
+        )
+

login.py

@@ -0,0 +1,175 @@
+
+# -*- coding: utf-8 -*-
+import streamlit as st
+from banco import SessionLocal
+from models import Usuario
+from utils_seguranca import verificar_senha
+from utils_auditoria import registrar_log
+
+# 🔀 Roteador de banco (Produção/Teste/Treinamento)
+# Observação: este import assume que db_router.py está na raiz do projeto.
+# Se ainda não existir, usamos um fallback suave (default 'prod').
+try:
+    from db_router import set_db_choice, current_db_choice, list_banks, bank_label
+    _HAS_ROUTER = True
+except Exception:
+    _HAS_ROUTER = False
+    def set_db_choice(choice: str):
+        st.session_state["__db_choice__"] = (choice or "prod").lower()
+    def current_db_choice() -> str:
+        return st.session_state.get("__db_choice__", "prod")
+    def list_banks():
+        return ["prod", "test"]  # fallback básico
+    def bank_label(choice: str) -> str:
+        return {"prod": "Banco 1 (📗 Produção)", "test": "Banco 2 (📕 Teste)"}.get(choice, choice)
+
+
+def _mostrar_efeito_aniversario(nome: str):
+    """Exibe imediatamente efeito e mensagem central de aniversário."""
+    # Efeito visual (confete e balões)
+    st.snow()
+    st.balloons()
+
+    # Mensagem centralizada
+    st.markdown(
+        f"""
+        <div style="
+            display:flex;align-items:center;justify-content:center;
+            text-align:center;margin:40px 0 20px 0;">
+            <div style="
+                font-size: 32px; font-weight: 800; color:#A020F0;
+                background:linear-gradient(90deg,#FFF0F6,#F0E6FF);
+                padding:16px 24px;border-radius:16px;box-shadow:0 4px 10px rgba(0,0,0,.08);">
+                🎉 Feliz Aniversário, {nome}! 🎉
+            </div>
+        </div>
+        """,
+        unsafe_allow_html=True
+    )
+    st.caption("Desejamos a você muitas conquistas e bons embarques ao longo do ano! 💜")
+
+
+def login():
+    st.subheader("🔐 Login")
+
+    # ✅ Seleção do banco (dinâmica) — armazenado em sessão para toda a navegação
+    # Mantém experiência simples e clara para o usuário.
+    banks = list_banks()                         # ex.: ['prod', 'test', 'treinamento']
+    labels = [bank_label(b) for b in banks]      # rótulos amigáveis para UI
+    idx_default = banks.index("prod") if "prod" in banks else 0
+
+    banco_label = st.selectbox("Usar banco:", labels, index=idx_default)
+    db_choice = banks[labels.index(banco_label)]
+    set_db_choice(db_choice)
+
+    # (Opcional) Indicação visual do banco ativo na sidebar
+    # Usando ícones diferentes para cada ambiente:
+    ambiente = current_db_choice()
+    if ambiente == "prod":
+        badge = "🟢 Produção"
+    elif ambiente == "test":
+        badge = "🔴 Teste"
+    elif ambiente == "treinamento":
+        badge = "🔵 Treinamento"
+    else:
+        badge = ambiente
+    st.sidebar.caption(f"🗄️ Banco ativo: {badge}")
+
+    # Campos de credencial
+    usuario_input = st.text_input("Usuário")
+    senha_input = st.text_input("Senha", type="password")
+
+    # 🔘 Botão de entrada (mantendo seu fluxo)
+    if st.button("Entrar", type="primary"):
+        db = SessionLocal()
+        try:
+            usuario_db = (
+                db.query(Usuario)
+                .filter(
+                    Usuario.usuario == usuario_input,
+                    Usuario.ativo == True
+                )
+                .first()
+            )
+
+            if not usuario_db or not verificar_senha(senha_input, usuario_db.senha):
+                st.error("❌ Usuário ou senha inválidos.")
+
+                # 📝 Auditoria — registra também o ambiente atual (prod/test/treinamento)
+                try:
+                    registrar_log(
+                        usuario=usuario_input,
+                        acao="Tentativa de login inválida",
+                        tabela="usuarios",
+                        ambiente=current_db_choice()
+                    )
+                except Exception:
+                    # Não quebra o fluxo se auditoria falhar
+                    pass
+
+                return
+
+            # ✅ LOGIN OK
+            st.session_state.logado = True
+            st.session_state.usuario = usuario_db.usuario
+            st.session_state.perfil = usuario_db.perfil
+
+            # ✅ Armazenar e-mail e, se disponível, nome (para exibição na UI)
+            # Obs.: getattr evita erro caso o campo não exista ou esteja nulo.
+            st.session_state.email = getattr(usuario_db, "email", None)
+            st.session_state.nome = getattr(usuario_db, "nome", None)
+
+            # 🔁 IMPORTANTE: força revalidação do quiz
+            st.session_state.quiz_verificado = False
+
+            # 📝 Auditoria de sucesso — registra o ambiente
+            try:
+                registrar_log(
+                    usuario=usuario_db.usuario,
+                    acao="Login realizado com sucesso",
+                    tabela="usuarios",
+                    registro_id=usuario_db.id,
+                    ambiente=current_db_choice()
+                )
+            except Exception:
+                pass
+
+            # 🎂 NOVO: checagem de data de aniversário (mês/dia), compatível com Date e ISO string
+            try:
+                from datetime import date as _date
+
+                def _to_date_safe(val):
+                    if not val:
+                        return None
+                    # já é 'date'?
+                    if isinstance(val, _date):
+                        return val
+                    # tenta converter de string ISO "YYYY-MM-DD"
+                    try:
+                        yy, mm, dd = map(int, str(val).split("-"))
+                        return _date(yy, mm, dd)
+                    except Exception:
+                        return None
+
+                dn = _to_date_safe(getattr(usuario_db, "data_aniversario", None))
+                hoje = _date.today()
+
+                if dn and (dn.month == hoje.month and dn.day == hoje.day):
+                    # Mostra efeito imediatamente (antes do rerun)
+                    nome_exibir = st.session_state.get("nome") or st.session_state.get("usuario") or "Usuário"
+                    _mostrar_efeito_aniversario(nome_exibir)
+
+                    # Opcional: também sinaliza para main() caso queira reapresentar em outra área
+                    st.session_state["__show_birthday__"] = True
+            except Exception:
+                # Não impede o login se algo falhar nessa checagem
+                pass
+
+            st.success("✅ Login realizado com sucesso!")
+            st.rerun()
+
+        finally:
+            db.close()
+
+
+

models.py

@@ -0,0 +1,463 @@
+# -*- coding: utf-8 -*-
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    Date,
+    DateTime,
+    Boolean,
+    ForeignKey,
+    Text
+)
+from sqlalchemy.orm import relationship
+    # If you face cyclic import issues, place Base here via declarative_base:
+    # from sqlalchemy.orm import declarative_base
+    # Base = declarative_base()
+from datetime import datetime
+from banco import Base
+from sqlalchemy.sql import func  # server_default em AvisoGlobal
+
+# =====================================================
+# TABELA EQUIPAMENTOS
+# =====================================================
+class Equipamento(Base):
+    __tablename__ = "equipamentos"
+
+    id = Column(Integer, primary_key=True, index=True)
+
+    # Identificação
+    fpso1 = Column(String, index=True, nullable=False)
+    fpso = Column(String, index=True, nullable=False)
+    data_coleta = Column(String, index=True, nullable=False)  # sugestão futura: Date
+
+    # Responsáveis
+    especialista = Column(String, nullable=False)
+    conferente = Column(String, nullable=False)
+    osm = Column(String, nullable=False)
+
+    # Operacional
+    modal = Column(String, index=True, nullable=False)
+    quant_equip = Column(Integer, default=0)
+    mrob = Column(String, nullable=False)
+
+    # Métricas
+    linhas_osm = Column(Integer, default=0)
+    linhas_mrob = Column(Integer, default=0)
+    linhas_erros = Column(Integer, default=0)
+
+    # Erros
+    erro_storekeeper = Column(String)
+    erro_operacao = Column(String)
+    erro_especialista = Column(String)
+    erro_outros = Column(String)
+
+    # Dados complementares
+    inclusao_exclusao = Column(String)
+    po = Column(String)
+    part_number = Column(String)
+    material = Column(String)
+
+    solicitante = Column(String, nullable=False)
+    motivo = Column(String)
+    requisitante = Column(String, nullable=False)
+    nota_fiscal = Column(String, nullable=False)
+    impacto = Column(String, nullable=False)
+    dimensao = Column(String, nullable=False)
+
+    observacoes = Column(String)
+
+    # Dia de inclusão
+    dia_inclusao = Column(String, nullable=True, index=True)
+
+    # Auditoria
+    data_hora_input = Column(DateTime, default=datetime.utcnow, index=True)
+
+
+# =====================================================
+# TABELA FPSOS
+# =====================================================
+class FPSO(Base):
+    __tablename__ = "fpsos"
+
+    id = Column(Integer, primary_key=True)
+    nome = Column(String, unique=True, nullable=False, index=True)
+    ativo = Column(Boolean, default=True)
+    data_cadastro = Column(DateTime, default=datetime.utcnow)
+
+
+# =====================================================
+# LOG DE AUDITORIA (OFICIAL)
+# =====================================================
+class LogAcesso(Base):
+    __tablename__ = "log_acesso"
+
+    id = Column(Integer, primary_key=True)
+
+    usuario = Column(String, nullable=False, index=True)
+    acao = Column(String, nullable=False)
+    tabela = Column(String, nullable=True)
+    registro_id = Column(Integer, nullable=True)
+
+    data_hora = Column(DateTime, default=datetime.utcnow, index=True)
+
+
+# =====================================================
+# USUÁRIOS
+# =====================================================
+class Usuario(Base):
+    __tablename__ = "usuarios"
+
+    id = Column(Integer, primary_key=True)
+
+    # login & segurança
+    usuario = Column(String, unique=True, nullable=False, index=True)
+    senha = Column(String, nullable=False)
+
+    # perfil & status
+    perfil = Column(String, nullable=False)  # admin | usuario | consulta
+    ativo = Column(Boolean, default=True)
+
+    # auditoria
+    data_criacao = Column(DateTime, default=datetime.utcnow)
+
+    # UI/contato
+    nome = Column(String, nullable=True, index=True)
+    email = Column(String, unique=True, index=True, nullable=True)
+
+    # aniversário
+    data_aniversario = Column(Date, nullable=True)
+
+
+# =====================================================
+# QUIZ - PERGUNTAS
+# =====================================================
+class QuizPergunta(Base):
+    __tablename__ = "quiz_perguntas"
+
+    id = Column(Integer, primary_key=True)
+    pergunta = Column(String, nullable=False)
+    ativo = Column(Boolean, default=True)
+    data_criacao = Column(DateTime, default=datetime.utcnow)
+
+    respostas = relationship(
+        "QuizResposta",
+        back_populates="pergunta",
+        cascade="all, delete-orphan"
+    )
+
+
+# =====================================================
+# QUIZ - RESPOSTAS
+# =====================================================
+class QuizResposta(Base):
+    __tablename__ = "quiz_respostas"
+
+    id = Column(Integer, primary_key=True)
+    pergunta_id = Column(Integer, ForeignKey("quiz_perguntas.id"), nullable=False)
+    texto = Column(String, nullable=False)
+    correta = Column(Boolean, default=False)
+
+    pergunta = relationship("QuizPergunta", back_populates="respostas")
+
+
+# =====================================================
+# QUIZ - PONTUAÇÃO / RANKING
+# =====================================================
+class QuizPontuacao(Base):
+    __tablename__ = "quiz_pontuacoes"
+
+    id = Column(Integer, primary_key=True)
+    usuario = Column(String, nullable=False, index=True)
+    pontos = Column(Integer, nullable=False, default=0)
+    data = Column(DateTime, default=datetime.utcnow, index=True)
+
+
+# =====================================================
+# VÍDEOS - CATEGORIAS
+# =====================================================
+class VideoCategoria(Base):
+    __tablename__ = "video_categorias"
+
+    id = Column(Integer, primary_key=True)
+    nome = Column(String, nullable=False, unique=True)
+    ativo = Column(Boolean, default=True)
+    data_criacao = Column(DateTime, default=datetime.utcnow)
+
+
+# =====================================================
+# VÍDEOS
+# =====================================================
+class Video(Base):
+    __tablename__ = "videos"
+
+    id = Column(Integer, primary_key=True)
+    titulo = Column(String, nullable=False)
+    descricao = Column(String)
+    url = Column(String, nullable=False)
+
+    categoria_id = Column(Integer, ForeignKey("video_categorias.id"))
+    categoria = relationship("VideoCategoria")
+
+    ativo = Column(Boolean, default=True)
+    data_criacao = Column(DateTime, default=datetime.utcnow)
+
+
+# =====================================================
+# CALENDÁRIO - EVENTOS / LEMBRETES
+# =====================================================
+class EventoCalendario(Base):
+    __tablename__ = "eventos_calendario"
+
+    id = Column(Integer, primary_key=True)
+    titulo = Column(String, nullable=False)
+    descricao = Column(String)
+    data_evento = Column(Date, nullable=False)
+    data_lembrete = Column(Date)
+    ativo = Column(Boolean, default=True)
+    usuario_criacao = Column(String, nullable=False)
+    data_criacao = Column(DateTime, default=datetime.utcnow)
+
+
+# =====================================================
+# IOI-RUN - SUGESTÕES DO SISTEMA
+# =====================================================
+class IOIRunSugestao(Base):
+    __tablename__ = "ioirun_sugestao"
+
+    id = Column(Integer, primary_key=True, index=True)
+
+    # Identificação do autor
+    usuario = Column(String, nullable=False, index=True)
+
+    # Conteúdo
+    area = Column(String, nullable=True, index=True)
+    mensagem = Column(Text, nullable=False)
+
+    # Resposta do time (admin)
+    resposta = Column(Text, nullable=True)
+    status = Column(String, default="pendente", nullable=False, index=True)  # pendente | respondida
+    responsavel = Column(String, nullable=True)
+
+    # Auditoria
+    data_envio = Column(DateTime, default=datetime.utcnow, nullable=False, index=True)
+    data_resposta = Column(DateTime, nullable=True)
+
+
+# =====================================================
+# RNC - REGISTRO DE NÃO CONFORMIDADES (FOR-SGQ-08)
+# =====================================================
+class RNC(Base):
+    __tablename__ = "rnc"
+
+    id = Column(Integer, primary_key=True, index=True)
+
+    # Identificação
+    codigo = Column(String(20), unique=True, index=True)  # ex.: RNC-2026-0001
+    titulo = Column(String(200), nullable=False)
+    descricao = Column(Text, nullable=False)
+
+    # Cabeçalho do formulário
+    data_form = Column(Date, nullable=True, index=True)  # Data do formulário
+    emitente = Column(String(120), nullable=True, index=True)
+    rnc_cliente_numero = Column(String(50), nullable=True)
+    cliente_emitente = Column(String(120), nullable=True)
+    area_solicitante = Column(String(120), nullable=True, index=True)
+    area_notificada = Column(String(120), nullable=True, index=True)
+    origem = Column(String(50), nullable=True, index=True)  # Auditoria Interna/Externa/Outras
+
+    # Envolvidos
+    envolvido1_nome = Column(String(120), nullable=True)
+    envolvido1_matricula = Column(String(50), nullable=True)
+    envolvido1_funcao = Column(String(120), nullable=True)
+    envolvido2_nome = Column(String(120), nullable=True)
+    envolvido2_matricula = Column(String(50), nullable=True)
+    envolvido2_funcao = Column(String(120), nullable=True)
+
+    # Classificação
+    tipo = Column(String(50), nullable=True)
+    severidade = Column(String(20), nullable=True)
+    prioridade = Column(String(20), nullable=True)
+
+    # Status e prazos
+    status = Column(String(30), default="Aberta", nullable=False, index=True)
+    data_abertura = Column(DateTime, default=datetime.utcnow, index=True)
+    prazo = Column(DateTime, nullable=True, index=True)
+    encerrada_em = Column(DateTime, nullable=True, index=True)
+
+    # Responsáveis
+    responsavel = Column(String(120), nullable=True, index=True)
+    criado_por = Column(String(120), nullable=False, index=True)
+
+    # Complementares
+    cliente = Column(String(120), nullable=True)
+    local = Column(String(120), nullable=True)
+
+    # Análise das causas
+    metodologia = Column(String(120), nullable=True)  # ex.: Ishikawa, 5 Porquês
+    causa_raiz = Column(Text, nullable=True)  # descrição da causa raiz
+    ishikawa_json = Column(Text, nullable=True)  # opcional: armazenar estrutura Ishikawa em JSON
+
+    # Auditoria
+    data_hora_input = Column(DateTime, default=datetime.utcnow, index=True)
+
+    # Relacionamentos
+    comentarios = relationship("RNCComentario", back_populates="rnc", cascade="all, delete-orphan")
+    acoes = relationship("RNCAcaoCorretiva", back_populates="rnc", cascade="all, delete-orphan")
+    anexos = relationship("RNCAnexo", back_populates="rnc", cascade="all, delete-orphan")
+
+
+# =====================================================
+# RNC - COMENTÁRIOS / TIMELINE
+# =====================================================
+class RNCComentario(Base):
+    __tablename__ = "rnc_comentario"
+
+    id = Column(Integer, primary_key=True, index=True)
+    rnc_id = Column(Integer, ForeignKey("rnc.id"), nullable=False, index=True)
+
+    data = Column(DateTime, default=datetime.utcnow, index=True)
+    autor = Column(String(120), nullable=False, index=True)
+    mensagem = Column(Text, nullable=False)
+
+    status_novo = Column(String(30), nullable=True, index=True)
+    prazo_novo = Column(DateTime, nullable=True, index=True)
+    responsavel_novo = Column(String(120), nullable=True, index=True)
+
+    rnc = relationship("RNC", back_populates="comentarios")
+
+
+# =====================================================
+# RNC - AÇÕES CORRETIVAS / PREVENTIVAS
+# =====================================================
+class RNCAcaoCorretiva(Base):
+    __tablename__ = "rnc_acao"
+
+    id = Column(Integer, primary_key=True, index=True)
+    rnc_id = Column(Integer, ForeignKey("rnc.id"), nullable=False, index=True)
+
+    descricao = Column(Text, nullable=False)
+    responsavel = Column(String(120), nullable=True, index=True)
+    prazo = Column(DateTime, nullable=True, index=True)
+
+    status = Column(String(30), default="Planejada", nullable=False, index=True)
+    eficacia = Column(String(30), nullable=True, index=True)
+    conclusao_em = Column(DateTime, nullable=True, index=True)
+
+    rnc = relationship("RNC", back_populates="acoes")
+
+
+# =====================================================
+# RNC - ANEXOS
+# =====================================================
+class RNCAnexo(Base):
+    __tablename__ = "rnc_anexo"
+
+    id = Column(Integer, primary_key=True, index=True)
+    rnc_id = Column(Integer, ForeignKey("rnc.id"), nullable=False, index=True)
+
+    nome_arquivo = Column(String(255), nullable=False)
+    caminho = Column(String(500), nullable=False)
+    conteudo_tipo = Column(String(120), nullable=True)
+
+    enviado_por = Column(String(120), nullable=True, index=True)
+    enviado_em = Column(DateTime, default=datetime.utcnow, index=True)
+
+    rnc = relationship("RNC", back_populates="anexos")
+
+
+# =====================================================
+# AVISO GLOBAL (banner superior)
+# =====================================================
+class AvisoGlobal(Base):
+    __tablename__ = "aviso_global"
+
+    id = Column(Integer, primary_key=True, index=True)
+    mensagem = Column(Text, nullable=False)
+
+    # Estilo/visual
+    bg_color = Column(String(32), default="#FFF3CD")
+    text_color = Column(String(32), default="#664D03")
+    largura = Column(String(16), default="100%")
+    efeito = Column(String(16), default="marquee")
+    velocidade = Column(Integer, default=20)
+    font_size = Column(Integer, default=14)
+
+    # Controle/estado
+    ativo = Column(Boolean, default=True, index=True)
+
+    # Auditoria
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
+
+
+# =====================================================
+# RECEBIMENTO — PLANILHA OFICIAL (UM REGISTRO POR LINHA)
+# Alinhado ao layout oficial de 37 colunas
+# =====================================================
+class RecebimentoRegistro(Base):
+    __tablename__ = "recebimento_registros"
+
+    # PK interno + ID da planilha
+    id = Column(Integer, primary_key=True, autoincrement=True, index=True)
+    id_planilha = Column(Integer, nullable=True, index=True, unique=True)  # ID da planilha, se houver
+
+    # Datas
+    data = Column(Date, nullable=True)
+    data_emissao = Column(Date, nullable=True)
+
+    # Horas (texto HH:MM:SS para compatibilidade)
+    hora_chegada_portaria = Column(String(8), nullable=True)
+    hora_chegada_ifs = Column(String(8), nullable=True)
+    hora_saida_ifs_wms = Column(String(8), nullable=True)
+    hora_liberacao_operacao = Column(String(8), nullable=True)
+    hora_chegada_operacao = Column(String(8), nullable=True)
+    hora_saida_operacao = Column(String(8), nullable=True)
+    hora_retorno_operacao = Column(String(8), nullable=True)
+    hora_liberacao_motorista = Column(String(8), nullable=True)
+
+    # Dados principais
+    placa_veiculo = Column(String(50), nullable=True)
+    transportadora = Column(String(255), nullable=True)
+    po = Column(String(60), nullable=True)
+    incoterms = Column(String(30), nullable=True)
+    qtd_sku = Column(Integer, nullable=True)
+    nota_fiscal = Column(String(80), nullable=True)
+    fornecedor = Column(String(255), nullable=True)
+
+    # Bools (SIM/NÃO/N/A)
+    quimicos = Column(Boolean, nullable=True)
+    fds = Column(Boolean, nullable=True)
+    repetro = Column(Boolean, nullable=True)
+    aprovado = Column(Boolean, nullable=True)
+
+    # Status/Texto
+    natureza_operacao = Column(String(120), nullable=True)
+    tipo_operacao = Column(String(120), nullable=True)
+    barco = Column(String(80), nullable=True)
+
+    # Campo alinhado com a coluna "DIVERGENCIA" do layout oficial
+    divergencia = Column(String(200), nullable=True)
+
+    ifs = Column(String(120), nullable=True)
+    wms = Column(String(120), nullable=True)
+    fotografia = Column(String(255), nullable=True)
+    entrega = Column(String(120), nullable=True)
+    projeto = Column(String(120), nullable=True)
+    good_receipt = Column(String(120), nullable=True)
+    divergencia_recebimento = Column(String(255), nullable=True)
+    qualidade = Column(String(120), nullable=True)
+    divergencia_qualidade = Column(String(255), nullable=True)
+    observacao = Column(Text, nullable=True)
+    agendamento = Column(String(120), nullable=True)
+    responsavel = Column(String(120), nullable=True)
+
+    # Novos campos (opcionais) para colunas adicionais do layout
+    po_alt = Column(String(60), nullable=True)       # mapeia "P.O" (alternativo)
+    pn = Column(String(120), nullable=True)          # mapeia "PN"
+    lot_batch = Column(String(120), nullable=True)   # mapeia "LOT BATCH"
+
+    # Auditoria mínima
+    created_by = Column(String(150), nullable=True)
+    updated_by = Column(String(150), nullable=True)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)

module_loader.py

@@ -0,0 +1,68 @@
+
+# -*- coding: utf-8 -*-
+"""
+module_loader.py — Carregador dinâmico de módulos por ambiente (TESTE/Produção)
+Permite importar 'operacao', 'consulta', etc. a partir de um base_path escolhido no login.
+"""
+
+import os
+import importlib.util
+import types
+import streamlit as st
+
+SESSION_ENV_BASE_KEY = "__env_base_path__"
+SESSION_MOD_CACHE_KEY = "__env_module_cache__"
+
+def set_env_base(base_path: str):
+    """Define o caminho base do ambiente (ex.: pasta de produção ou teste)."""
+    base_path = os.path.abspath(base_path)
+    if not os.path.isdir(base_path):
+        raise RuntimeError(f"Caminho do ambiente inválido: {base_path}")
+    st.session_state[SESSION_ENV_BASE_KEY] = base_path
+    # Zera cache ao trocar ambiente
+    st.session_state[SESSION_MOD_CACHE_KEY] = {}
+
+def get_env_base() -> str:
+    base = st.session_state.get(SESSION_ENV_BASE_KEY)
+    if not base:
+        # Default: usar a própria pasta onde está o app (Produção)
+        base = os.path.abspath(os.getcwd())
+        st.session_state[SESSION_ENV_BASE_KEY] = base
+        st.session_state[SESSION_MOD_CACHE_KEY] = {}
+    return base
+
+def _mod_cache() -> dict:
+    cache = st.session_state.get(SESSION_MOD_CACHE_KEY)
+    if cache is None:
+        cache = {}
+        st.session_state[SESSION_MOD_CACHE_KEY] = cache
+    return cache
+
+def load_module(module_name: str) -> types.ModuleType:
+    """
+    Carrega um módulo pelo nome (ex.: 'operacao') a partir do base_path atual.
+    Mantém cache por ambiente/arquivo para evitar reimportações.
+    """
+    base_path = get_env_base()
+    mod_path = os.path.join(base_path, f"{module_name}.py")
+    if not os.path.isfile(mod_path):
+        # fallback: se não achar .py direto, permita subpastas (ex.: envs/test/modulos/operacao.py)
+        # ajuste conforme sua estrutura real:
+        mod_path_alt = os.path.join(base_path, "modulos", f"{module_name}.py")
+        if os.path.isfile(mod_path_alt):
+            mod_path = mod_path_alt
+        else:
+            raise FileNotFoundError(f"Módulo '{module_name}' não encontrado em {base_path}")
+
+    cache_key = f"{base_path}::{module_name}"
+    cache = _mod_cache()
+    mod = cache.get(cache_key)
+    if mod:
+        return mod
+
+    spec = importlib.util.spec_from_file_location(module_name, mod_path)
+    mod = importlib.util.module_from_spec(spec)
+    assert spec and spec.loader, f"Falha ao preparar spec para {mod_path}"
+    spec.loader.exec_module(mod)
+    cache[cache_key] = mod
+    return mod

modules_map.py

@@ -0,0 +1,263 @@
+
+# modules_map.py
+from calendario import main as calendario
+from calendario_mensal import main as calendario_mensal
+
+MODULES = {
+    # =============================
+    # Grupo: Operação Load
+    # =============================
+    "formulario": {
+        "key": "formulario",
+        "label": "Formulário",
+        "descricao": "Cadastro de dados operacionais",
+        "perfis": ["admin", "usuario"],
+        "grupo": "Operação Load"
+    },
+    "consulta": {
+        "key": "consulta",
+        "label": "Consulta",
+        "descricao": "Consulta e exportação de registros",
+        "perfis": ["admin", "usuario"],
+        "grupo": "Operação Load"
+    },
+    "relatorio": {
+        "key": "relatorio",
+        "label": "Relatório",
+        "descricao": "Indicadores e análises",
+        "perfis": ["admin"],
+        "grupo": "Operação Load"
+    },
+    "ranking": {
+        "key": "ranking",
+        "label": "Ranking",
+        "descricao": "Classificação do quiz",
+        "perfis": ["admin", "usuario"],
+        "grupo": "Operação Load"
+    },
+    "quiz": {
+        "key": "quiz",
+        "label": "Quiz",
+        "descricao": "Questionário de conhecimentos",
+        "perfis": ["admin", "usuario"],
+        "grupo": "Operação Load"
+    },
+    "quiz_admin": {
+        "key": "quiz_admin",
+        "label": "Quiz Admin",
+        "descricao": "Gestão de perguntas do quiz",
+        "perfis": ["admin"],
+        "grupo": "Operação Load"
+    },
+    "videos": {
+        "key": "videos",
+        "label": "Vídeos",
+        "descricao": "Biblioteca de vídeos",
+        "perfis": ["admin", "usuario"],
+        "grupo": "Operação Load"
+    },
+    "usuarios": {
+        "key": "usuarios",
+        "label": "Usuários",
+        "descricao": "Gestão de usuários",
+        "perfis": ["admin"],
+        "grupo": "Operação Load"
+    },
+    "administracao": {
+        "key": "administracao",
+        "label": "Administração",
+        "descricao": "Administração do sistema",
+        "perfis": ["admin", "usuario"],
+        "grupo": "Operação Load"
+    },
+    "auditoria": {
+        "key": "auditoria",
+        "label": "Auditoria",
+        "descricao": "Log de ações do sistema",
+        "perfis": ["admin"],
+        "grupo": "Operação Load"
+    },
+    "jogos": {
+        "key": "jogos",
+        "label": "Jogos",
+        "descricao": "Mini-games e diversão",
+        "perfis": ["admin"],
+        "grupo": "Operação Load"
+    },
+    "calendario": {
+        "key": "calendario",
+        "label": "Calendário",
+        "descricao": "Calendário de eventos",
+        "perfis": ["admin", "consulta", "usuario"],
+        "grupo": "Operação Load"
+    },
+    "calendario_mensal": {
+        "key": "calendario_mensal",
+        "label": "Calendário Mensal",
+        "descricao": "Calendário de eventos mensal",
+        "perfis": ["admin", "consulta", "usuario"],
+        "grupo": "Operação Load"
+    },
+    "auditoria_cleanup": {
+        "key": "auditoria_cleanup",
+        "label": "Limpeza Auditoria",
+        "descricao": "Exclusão de logs antigos de auditoria",
+        "perfis": ["admin"],
+        "grupo": "Operação Load"
+    },
+    "importacao": {
+        "key": "importacao",
+        "label": "Importação",
+        "descricao": "Importação de dados via Excel",
+        "perfis": ["admin", "usuario"],
+        "grupo": "Operação Load"
+    },
+    "db_admin": {
+        "key": "db_admin",
+        "label": "Admin DB (Schema)",
+        "descricao": "Editar/Excluir/Adicionar colunas e tipos de dados",
+        "perfis": ["admin"],
+        "grupo": "Operação Load"
+    },
+    "db_monitor": {
+        "key": "db_monitor",
+        "label": "Monitor DB",
+        "descricao": "Estatísticas, ocupação e backup planejado do banco",
+        "perfis": ["admin"],
+        "grupo": "Operação Load"
+    },
+    "db_export_import": {
+        "key": "db_export_import",
+        "label": "Exportação/Importação DB",
+        "descricao": "Export/Import de todas as tabelas do banco ativo",
+        "perfis": ["admin"],
+        "grupo": "Operação Load"
+    },
+    "produtividade_especialista": {
+        "key": "produtividade_especialista",
+        "label": "Produtividade por Especialista",
+        "descricao": "Relatório de produtividade do especialista",
+        "perfis": ["admin", "usuario"],
+        "grupo": "Operação Load"
+    },
+    "outlook_relatorio": {
+        "key": "outlook_relatorio",
+        "label": "Relatório portaria",
+        "descricao": "Relatório de entrada e saída da portaria - ARM",
+        "perfis": ["admin", "usuario"],
+        "grupo": "Operação Load"
+    },
+    "repositorio_load": {
+        "key": "repositorio_load",
+        "label": "Repositório Load",
+        "descricao": "Upload (Admin) e Consulta/Download (Usuário) de Excel e PDF",
+        "perfis": ["admin", "usuario"],
+        "grupo": "Operação Load"
+    },
+
+    # =============================
+    # Grupo: Backload
+    # =============================
+    "backload_consulta": {
+        "key": "backload_consulta",
+        "label": "Consulta Backload",
+        "descricao": "Consulta de operações Backload",
+        "perfis": ["admin", "usuario"],
+        "grupo": "Backload"
+    },
+
+    # =============================
+    # Grupo: Operação
+    # =============================
+    "operacao": {
+        "key": "operacao",
+        "label": "Operação",
+        "descricao": "Relatórios via API (Mayasuite)",
+        "perfis": ["admin"],
+        "grupo": "Operação"
+    },
+
+    # =============================
+    # Grupo: Indicadores
+    # =============================
+    "indicadores": {
+        "key": "indicadores",
+        "label": "Indicadores",
+        "descricao": "Relatórios de indicadores (KPIs por API)",
+        "perfis": ["admin"],
+        "grupo": "BI / Indicadores"
+    },
+
+    # =============================
+    # Grupo: Terceiros
+    # =============================
+    "terceiros_gestao": {
+        "key": "terceiros_gestao",
+        "label": "Gestão Terceiros",
+        "descricao": "Controle de fornecedores e terceiros",
+        "perfis": ["admin"],
+        "grupo": "Terceiros"
+    },
+
+    # =============================
+    # Grupo: IOI-RUN
+    # =============================
+    "resposta": {
+        "key": "resposta",
+        "label": "Resposta de perguntas",
+        "descricao": "Resposta de perguntas do sistema IOI‑RUN",
+        "perfis": ["admin"],
+        "grupo": "Resposta de perguntas"
+    },
+    "sugestoes_ioirun": {
+        "key": "sugestoes_ioirun",
+        "label": "Sugestões IOI‑RUN",
+        "descricao": "Envio e histórico de sugestões do sistema IOI‑RUN",
+        "perfis": ["admin", "usuario", "consulta"],
+        "grupo": "Geral"
+    },
+
+    # =============================
+    # Grupo: Qualidade
+    # =============================
+    "rnc": {
+        "key": "rnc",
+        "label": "RNC • Não Conformidades",
+        "descricao": "Registro e acompanhamento de não conformidades, plano de ação e anexos.",
+        "perfis": ["admin", "usuario"],
+        "grupo": "Sistemas de Gestão da Qualidade"
+    },
+    "rnc_listagem": {
+        "key": "rnc_listagem",
+        "label": "RNC • Listagem",
+        "descricao": "Consulta de RNCs com filtros, exportação e expanders",
+        "perfis": ["admin", "usuario", "consulta"],
+        "grupo": "Sistemas de Gestão da Qualidade"
+    },
+    "rnc_relatorio": {
+        "key": "rnc_relatorio",
+        "label": "RNC • Relatórios",
+        "descricao": "Painel analítico completo de RNC",
+        "perfis": ["admin", "usuario", "consulta"],
+        "grupo": "Sistemas de Gestão da Qualidade"
+    },
+    "repo_rnc": {
+        "key": "repo_rnc",
+        "label": "RNC • Repositório",
+        "descricao": "Upload/Download de documentos e planilhas das RNCs",
+        "perfis": ["admin", "usuario"],
+        "grupo": "Sistemas de Gestão da Qualidade"
+    },
+
+    # ======================================================
+    # RECEBIMENTO — PLANILHA OFICIAL
+    # ======================================================
+    "recebimento": {
+        "key": "recebimento",
+        "label": "Recebimento",
+        "descricao": "Recebimento – Planilha Oficial (importação, edição e controle de registros)",
+        "perfis": ["admin", "usuario"],
+        "grupo": "Operação"
+    },
+}
+

operacao.py

@@ -0,0 +1,1564 @@
+
+# -*- coding: utf-8 -*-
+"""
+operacao.py — Módulo Operação (Mayasuite)
+
+Recursos principais:
+- Modo rápido (Consulta leve): apenas 1 página + colunas essenciais na visualização
+- Limite de itens por página (via x-filter-limit se suportado pela API)
+- Cache de consultas (TTL configurável) + botões para limpar cache
+- Botão de cancelar consulta
+- Barra de progresso por página + status
+- Debounce no submit
+- Retentativas para 429/5xx (incl. 502) e timeouts com backoff
+- Filtros avançados: Data operação (única), Type(API), Tipo SBM (relacionado ao Depositante),
+  Endereços/Notas/Categorias com sugestões, Destinatários (multisseleção) + CNPJs múltiplos,
+  Depositantes (multisseleção)
+- Formatação PT-BR: datas DD/MM/AAAA, valores R$, SKU sem zeros à esquerda, oculta colunas vazias
+- KPIs dinâmicos por consulta (cards) — Estoque, Endereços, NF Entrada/Saída, etc.
+- Oculta navegação de outros módulos ao carregar
+"""
+
+import os
+import re
+import json
+import time
+import random
+from io import BytesIO
+from datetime import datetime
+import base64
+
+import streamlit as st
+import pandas as pd
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+# Se existirem, importe utilitários do seu projeto
+try:
+    from utils_permissoes import verificar_permissao
+except Exception:
+    def verificar_permissao(_):
+        return True
+
+try:
+    from utils_auditoria import registrar_log
+except Exception:
+    def registrar_log(**kwargs):
+        return None
+
+# =====================================================
+# CONFIG (.env)
+# =====================================================
+OP_API_BASE_URL   = os.getenv("OP_API_BASE_URL", "https://api.mayasuite.com").rstrip("/")
+OP_LOGIN_EMAIL    = (os.getenv("OP_LOGIN_EMAIL", "") or "").strip()
+OP_LOGIN_PASSWORD = (os.getenv("OP_LOGIN_PASSWORD", "") or "").strip()
+
+# Timeouts
+OP_CONNECT_TIMEOUT = float((os.getenv("OP_CONNECT_TIMEOUT", "10") or "10"))   # s
+OP_READ_TIMEOUT    = float((os.getenv("OP_READ_TIMEOUT", "90") or "90"))      # s
+
+# Token direto (bypass do login)
+OP_ACCESS_TOKEN       = (os.getenv("OP_ACCESS_TOKEN", "") or "").strip()
+
+# Diagnóstico / alternativas
+OP_LOGIN_EMAIL_ALT    = (os.getenv("OP_LOGIN_EMAIL_ALT", "") or "").strip()
+OP_LOGIN_PASSWORD_ALT = (os.getenv("OP_LOGIN_PASSWORD_ALT", "") or "").strip()
+OP_LOGIN_DEBUG        = (os.getenv("OP_LOGIN_DEBUG", "false") or "").strip().lower() == "true"
+
+# Headers compatíveis
+OP_COMPAT_HEADERS     = (os.getenv("OP_COMPAT_HEADERS", "true") or "").strip().lower() == "true"
+
+# Proxy (opcional)
+OP_PROXY_HTTP         = (os.getenv("OP_PROXY_HTTP", "") or "").strip()
+OP_PROXY_HTTPS        = (os.getenv("OP_PROXY_HTTPS", "") or "").strip()
+PROXIES = {"http": OP_PROXY_HTTP, "https": OP_PROXY_HTTPS} if (OP_PROXY_HTTP or OP_PROXY_HTTPS) else None
+
+# Rate limit / timeouts
+OP_RATE_DELAY_SEC       = float((os.getenv("OP_RATE_DELAY_SEC", "0.8") or "0.8"))
+OP_MAX_RETRIES_PER_PAGE = int((os.getenv("OP_MAX_RETRIES_PER_PAGE", "3") or "3"))
+OP_MAX_PAGES            = int((os.getenv("OP_MAX_PAGES", "0") or "0"))
+OP_MAX_TIMEOUT_RETRIES  = int((os.getenv("OP_MAX_TIMEOUT_RETRIES", "2") or "2"))
+OP_TIMEOUT_BACKOFF_BASE = float((os.getenv("OP_TIMEOUT_BACKOFF_BASE", "5") or "5"))
+
+# Retentativas específicas para 5xx (inclusive 502)
+OP_MAX_RETRIES_5XX     = int((os.getenv("OP_MAX_RETRIES_5XX", "4") or "4"))
+OP_5XX_BACKOFF_BASE    = float((os.getenv("OP_5XX_BACKOFF_BASE", "3") or "3"))
+
+# Tempo de cache (minutos) — configura no .env: CACHE_TTL_MIN=5
+CACHE_TTL_MIN = int((os.getenv("CACHE_TTL_MIN", "5") or "5"))
+CACHE_TTL_SEC = CACHE_TTL_MIN * 60
+
+# Bases
+BASES_MAP = {
+    "Matriz": "5a926346-15ee-4af4-ba2d-1a71d62d9b51",
+    "CL":     "b0099983-5b44-4650-821a-e352c5c1f10e",
+    "YARD":   "2c506e56-641d-48e2-a330-93fd088526cf",
+}
+
+# Endpoints
+ENDPOINTS = {
+    "Nota Fiscal de Entrada":  "/wsreceipt/list",
+    "Nota Fiscal de Saída":    "/wsdispatch/list",
+    "Endereços":               "/address/list",
+    "Endereços bloqueados":    "/address/blocking/list",
+    "Lista de Pedido":         "/cargorelease/list",
+    "Monitor Sefaz":           "/monitor/nfe/list",
+    "Estoque":                 "/stock/list",
+    "Operações":               "/operation/list",
+    "Agendamento":             "/yms/scheduling/list",
+    "Produto":                 "/product/list",
+    "Faturamento":             "/financial/invoice/list",
+}
+
+# Tipos (API) e Tipos SBM
+OPERATION_TYPES = ["ALLOCATION", "CHECK", "DISPATCH", "MOVEMENT", "RECEIVING", "PICK"]
+SBM_TYPES       = ["SBM - LOAD", "SBM - BACKLOAD", "OUTROS"]
+
+# Cancelamento
+CANCEL_TOKEN_KEY = "__op_cancel__"
+
+# ✅ NOVO: OAuth2 Client Credentials (se a API suportar)
+OAUTH_TOKEN_URL     = (os.getenv("OAUTH_TOKEN_URL", "") or "").strip()     # ex.: https://api.mayasuite.com/oauth/token
+OAUTH_CLIENT_ID     = (os.getenv("CLIENT_ID", "") or "").strip()
+OAUTH_CLIENT_SECRET = (os.getenv("CLIENT_SECRET", "") or "").strip()
+OAUTH_SCOPE         = (os.getenv("OAUTH_SCOPE", "") or "").strip()         # opcional
+
+# =====================================================
+# RENAME_MAP — renomeia colunas por endpoint (somente se existirem)
+# =====================================================
+RENAME_MAP = {
+    "/wsreceipt/list": {
+        "wsreceipt_code": "NF Entrada",
+        "create_date": "Data Emissão",
+        "customer_document": "CNPJ_Depositante",
+        "customer_name": "Depositante",
+        "product_code": "SKU",
+        "product_description": "Descrição",
+        "qty": "Qtde",
+        "unit_measure_code": "Unidade",
+        "receipt_unit_value": "Vr. Unitário",
+        "receipt_value": "Vr. Total",
+        "lot": "Lote",
+        "sublot": "SubLote",
+        "expiration_date": "Validade",
+        "manufacturing_date": "Fabricação",
+        "location_id_code": "Endereço",
+        "last_update_date": "Última Atualização",
+        "last_update_user": "Usuário Atualização",
+        "category_description": "Categoria",
+        "type": "Tipo",
+    },
+    "/wsdispatch/list": {
+        "wsdispatch_code": "NF Saída",
+        "issue_date": "Data Emissão",
+        "recipient_document": "CNPJ_Destinatário",
+        "recipient_description": "Destinatário",
+        "product_code": "SKU",
+        "product_description": "Descrição",
+        "qty": "Qtde",
+        "unit_measure_code": "Unidade",
+        "item_unit_value": "Vr. Unitário",
+        "item_total_value": "Vr. Total",
+        "lot": "Lote",
+        "sublot": "SubLote",
+        "location_code": "Endereço",
+        "category_description": "Categoria",
+        "group_description": "Grupo",
+        "type": "Tipo",
+    },
+    "/address/list": {
+        "location_code": "Endereço",
+        "location_id_code": "Endereço",
+        "description": "Descrição",
+        "status": "Status",
+        "fpso": "FPSO",
+        "last_update_date": "Última Atualização",
+        "last_update_user": "Usuário Atualização",
+        "type": "Tipo",
+    },
+    "/address/blocking/list": {
+        "location_code": "Endereço",
+        "location_id_code": "Endereço",
+        "block_reason": "Motivo Bloqueio",
+        "block_date": "Data Bloqueio",
+        "block_user": "Usuário Bloqueio",
+        "unblock_date": "Data Desbloqueio",
+        "unblock_user": "Usuário Desbloqueio",
+        "status": "Status",
+        "type": "Tipo",
+    },
+    "/cargorelease/list": {
+        "cargorelease_code": "Pedido",
+        "create_date": "Data Criação",
+        "customer_document": "CNPJ_Depositante",
+        "customer_name": "Depositante",
+        "product_code": "SKU",
+        "product_description": "Descrição",
+        "qty": "Qtde",
+        "unit_measure_code": "Unidade",
+        "status": "Status",
+        "expiration_date": "Validade",
+        "manufacturing_date": "Fabricação",
+        "category_description": "Categoria",
+        "type": "Tipo",
+    },
+    "/monitor/nfe/list": {
+        "nfe_key": "Chave NFe",
+        "nfe_number": "Número NFe",
+        "status": "Status SEFAZ",
+        "protocol": "Protocolo",
+        "issue_date": "Data Emissão",
+        "recipient_document": "CNPJ_Destinatário",
+        "customer_document": "CNPJ_Depositante",
+        "message": "Mensagem",
+        "last_update_date": "Última Atualização",
+        "type": "Tipo",
+    },
+    "/stock/list": {
+        "date": "Data Operação",
+        "wsreceipt_code": "Nota Fiscal",
+        "product_code": "SKU",
+        "product_description": "Descrição",
+        "unit_measure_code": "Unidade",
+        "qty": "Qtde",
+        "item_unit_value": "Vr. Unitário",
+        "item_total_value": "Vr. Total",
+        "customer_document": "CNPJ_Depositante",
+        "customer_description": "Depositante",
+        "lot": "Lote",
+        "location_code": "Endereço",
+        "expiration_date": "Validade",
+        "manufacturing_date": "Fabricação",
+        "category_description": "Categoria",
+        "group_description": "Grupo",
+        "recipient_document": "CNPJ_Destinatário",
+        "recipient_description": "Destinatário",
+        "qty_reservation": "Qtde Reservada",
+        "type": "Tipo",
+    },
+    "/operation/list": {
+        "cargorelease_code": "Pedido",
+        "create_date": "Data",
+        "create_user": "Usuário Criação",
+        "customer_document": "CNPJ_Depositante",
+        "customer_name": "Depositante",
+        "expiration_date": "Validade",
+        "last_update_date": "Última Atualização",
+        "last_update_user": "Usuário Atualização",
+        "location_id_code": "Endereço",
+        "lot": "Lote",
+        "manufacturing_date": "Fabricação",
+        "product_code": "SKU",
+        "product_description": "Descrição",
+        "qty": "Qtde",
+        "receipt_unit_value": "Vr. Unitário",
+        "receipt_value": "Vr. Total",
+        "sublot": "SubLote",
+        "type": "Tipo",
+        "wsreceipt_code": "NF Entrada",
+        "category_description": "Categoria",
+    },
+    "/yms/scheduling/list": {
+        "scheduling_id": "ID Agendamento",
+        "yard": "Pátio",
+        "dock": "Doca",
+        "truck_plate": "Placa",
+        "driver_name": "Motorista",
+        "scheduled_date": "Data Agendada",
+        "scheduled_time": "Hora Agendada",
+        "status": "Status",
+        "last_update_date": "Última Atualização",
+        "type": "Tipo",
+    },
+    "/product/list": {
+        "product_code": "SKU",
+        "product_description": "Descrição",
+        "category_description": "Categoria",
+        "group_description": "Grupo",
+        "unit_measure_code": "Unidade",
+        "status": "Status",
+        "last_update_date": "Última Atualização",
+        "type": "Tipo",
+    },
+    "/financial/invoice/list": {
+        "invoice_number": "Número Fatura",
+        "invoice_date": "Data Fatura",
+        "customer_document": "CNPJ_Depositante",
+        "customer_name": "Depositante",
+        "total_value": "Vr. Total",
+        "status": "Status",
+        "nfe_key": "Chave NFe",
+        "wsdispatch_code": "NF Saída",
+        "last_update_date": "Última Atualização",
+        "type": "Tipo",
+    },
+}
+
+# =====================================================
+# SESSÃO HTTP (retry 5xx/429) + PROGRESSO + CANCELAMENTO
+# =====================================================
+def _build_retry_adapter() -> HTTPAdapter:
+    """Adapter de retry: lida com 429/5xx transientes."""
+    retry = Retry(
+        total=3, connect=3, read=3, backoff_factor=1.0,
+        status_forcelist=[429, 500, 502, 503, 504],
+        allowed_methods=["POST"], raise_on_status=False,
+    )
+    return HTTPAdapter(max_retries=retry)
+
+def _get_session() -> requests.Session:
+    sess = st.session_state.get("_op_session")
+    if sess is None:
+        sess = requests.Session()
+        adapter = _build_retry_adapter()
+        sess.mount("https://", adapter)
+        sess.mount("http://", adapter)
+        st.session_state["_op_session"] = sess
+    return sess
+
+# =====================================================
+# LOGIN / TOKEN
+# =====================================================
+class TokenManager:
+    """
+    Gerencia token de acesso:
+    - Se OP_ACCESS_TOKEN estiver definido no .env: usa diretamente (bypass).
+    - Se variáveis OAuth2 estiverem configuradas: obtém/renova via client_credentials.
+    - Caso contrário: usa login atual (POST /login) com OP_LOGIN_EMAIL/OP_LOGIN_PASSWORD
+      (inclui conta alternativa e cooldown).
+    """
+    def __init__(self):
+        self.access_token: str | None = OP_ACCESS_TOKEN if OP_ACCESS_TOKEN else None
+        self.expire_ts: float = 0.0
+        self._skew_sec: int = 30  # tolerância de relógio
+
+    def _fetch_oauth_token(self) -> tuple[str | None, float]:
+        """Tenta obter via OAuth2 client_credentials. Retorna (token, expire_ts_epoch)."""
+        if not (OAUTH_TOKEN_URL and OAUTH_CLIENT_ID and OAUTH_CLIENT_SECRET):
+            return None, 0.0
+        try:
+            resp = requests.post(
+                OAUTH_TOKEN_URL,
+                data={"grant_type": "client_credentials", "scope": OAUTH_SCOPE},
+                auth=(OAUTH_CLIENT_ID, OAUTH_CLIENT_SECRET),
+                timeout=(OP_CONNECT_TIMEOUT, OP_READ_TIMEOUT),
+                proxies=PROXIES
+            )
+            if resp.status_code >= 400:
+                if OP_LOGIN_DEBUG:
+                    st.warning(f"OAuth2 falhou ({resp.status_code}): {(resp.text or '')[:300]}")
+                return None, 0.0
+            data = resp.json()
+            token = data.get("access_token") or data.get("token")
+            expires_in = float(data.get("expires_in") or 3600.0)
+            return token, (time.time() + max(60.0, expires_in))
+        except requests.exceptions.RequestException as e:
+            if OP_LOGIN_DEBUG:
+                st.warning(f"Falha OAuth2: {e}")
+            return None, 0.0
+
+    def _fetch_login_token(self) -> tuple[str | None, float]:
+        """
+        Fallback para o login atual (POST /login), mantendo:
+        - alternativa (OP_LOGIN_EMAIL_ALT/OP_LOGIN_PASSWORD_ALT)
+        - cooldown por banimento (api_login_lock_until)
+        - e toda lógica de parsing/erros
+        """
+        lock_until = st.session_state.get("api_login_lock_until")
+        if lock_until and time.time() < lock_until:
+            raise RuntimeError("Login temporariamente bloqueado após 403 (cooldown ativo).")
+
+        url = f"{OP_API_BASE_URL}/login"
+        payload_str = json.dumps({"login": OP_LOGIN_EMAIL, "password": OP_LOGIN_PASSWORD}, ensure_ascii=False)
+        headers = {"Content-Type": "application/json"}
+
+        try:
+            resp = requests.post(url, headers=headers, data=payload_str,
+                                 timeout=(OP_CONNECT_TIMEOUT, OP_READ_TIMEOUT), proxies=PROXIES)
+        except requests.exceptions.RequestException as e:
+            raise RuntimeError(f"Falha na conexão ao login: {e}")
+
+        body_text = (resp.text or "")[:600]
+        if resp.status_code >= 400:
+            if "banned" in body_text.lower():
+                st.session_state["api_login_lock_until"] = time.time() + 3600
+                if OP_LOGIN_DEBUG:
+                    st.warning(f"Servidor retornou banimento. Cooldown 1h. Corpo: {body_text}")
+                raise RuntimeError("Origem/host/IP banido pelo servidor (403). Solicite desbloqueio/allowlist.")
+            if OP_LOGIN_EMAIL_ALT and OP_LOGIN_PASSWORD_ALT:
+                payload_alt = json.dumps({"login": OP_LOGIN_EMAIL_ALT, "password": OP_LOGIN_PASSWORD_ALT}, ensure_ascii=False)
+                resp2 = requests.post(url, headers=headers, data=payload_alt,
+                                      timeout=(OP_CONNECT_TIMEOUT, OP_READ_TIMEOUT), proxies=PROXIES)
+                if resp2.status_code >= 400:
+                    if OP_LOGIN_DEBUG:
+                        st.warning(f"Alternativa falhou (HTTP {resp2.status_code}). Corpo: {(resp2.text or '')[:600]}")
+                    raise RuntimeError(f"Login rejeitado ({resp.status_code}).")
+                try:
+                    data2 = resp2.json()
+                except Exception:
+                    raise RuntimeError("Resposta de login (alt) não é JSON.")
+                token2 = data2.get("access_token") or data2.get("token")
+                if not token2:
+                    raise RuntimeError("Token (alt) não encontrado na resposta de login.")
+                return token2, (time.time() + 3600.0)
+            if OP_LOGIN_DEBUG:
+                st.warning(f"Login falhou (HTTP {resp.status_code}). Corpo: {body_text}")
+            raise RuntimeError(f"Login rejeitado ({resp.status_code}).")
+
+        try:
+            data = resp.json()
+        except Exception:
+            raise RuntimeError("Resposta de login não é JSON.")
+        token = data.get("access_token") or data.get("token") or (data if isinstance(data, str) else "")
+        if not token:
+            raise RuntimeError("Token 'access_token' não encontrado na resposta de login.")
+        return token, (time.time() + 3600.0)
+
+    def get_token(self) -> str:
+        """Obtém token atual (renova se necessário)."""
+        # Bypass: token fixo do .env
+        if OP_ACCESS_TOKEN:
+            self.access_token = OP_ACCESS_TOKEN
+            self.expire_ts = time.time() + 365*24*3600  # validade simbólica longa
+            return self.access_token
+
+        now = time.time()
+        if (not self.access_token) or (now + self._skew_sec >= self.expire_ts):
+            # Tenta primeiro OAuth2; se indisponível, usa login /login
+            token, exp_ts = self._fetch_oauth_token()
+            if not token:
+                token, exp_ts = self._fetch_login_token()
+            self.access_token = token
+            self.expire_ts = exp_ts or (now + 3600.0)
+        return self.access_token
+
+    def force_refresh(self) -> str:
+        """Força renovar o token (útil em 401) e retorna o novo."""
+        self.access_token = None
+        self.expire_ts = 0.0
+        return self.get_token()
+
+# ✅ Instância global (mantém sua organização)
+TM = TokenManager()
+
+# 🛠️ Refatora função _get_token para delegar ao TokenManager
+# (remove cache para não “congelar” o token; mantém assinatura/uso)
+def _get_token(login_email: str, login_password: str) -> str:
+    """
+    Obtém token automaticamente:
+    - OAuth2 client_credentials se configurado;
+    - Caso contrário, login /login com e-mail/senha (mantendo sua lógica).
+    """
+    return TM.get_token()
+
+# =====================================================
+# HEADERS
+# =====================================================
+def _auth_headers(token: str, base_guid: str, page: int, limit: int, is_post: bool) -> dict:
+    h = {"Authorization": f"Bearer {token}", "Content-Type": "application/json", "x-user-enterprise-id": base_guid}
+    if OP_COMPAT_HEADERS:
+        h["Accept"] = "application/json"
+        h["User-Agent"] = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) ArmLoadApp/1.0 PowerQueryCompat"
+        h["Connection"] = "keep-alive"
+        h["Origin"] = OP_API_BASE_URL
+        h["Referer"] = OP_API_BASE_URL + "/"
+    # Paginação do servidor (se suportado)
+    h["x-filter-page"]  = str(page)
+    h["x-filter-limit"] = str(limit)
+    return h
+
+# =====================================================
+# RATE LIMIT: helpers
+# =====================================================
+def _parse_retry_after(resp) -> float:
+    ra_hdr = resp.headers.get("Retry-After")
+    if ra_hdr:
+        try:
+            return float(ra_hdr.strip())
+        except Exception:
+            pass
+    try:
+        data = resp.json()
+        ra_body = data.get("retry-after") or ""
+        if isinstance(ra_body, (int, float)):
+            return float(ra_body)
+        if isinstance(ra_body, str):
+            m = re.search(r"(\d+)", ra_body)
+            if m:
+                return float(m.group(1))
+    except Exception:
+        pass
+    return 60.0
+
+# =====================================================
+# LIST — POST + RAW JSON com rate-limit/timeout/5xx
+# + Progresso de carregamento + Cancelamento
+# =====================================================
+def _call_list_paginated(
+    path: str,
+    base_guid: str,
+    token: str,
+    body_filter: dict,
+    limit: int = 1000,
+    max_pages_override: int | None = None
+):
+    """
+    - POST com RAW JSON (data=payload_str), como Excel.
+    - Respeita 429 (Retry-After); aplica atraso entre páginas.
+    - Retenta automaticamente Timeout (backoff exponencial).
+    - Retenta 5xx (incl. 502) com backoff exponencial + jitter.
+    - Suporta cancelamento via st.session_state[CANCEL_TOKEN_KEY].
+    - Exibe barra de progresso e status de carregamento por página.
+    """
+    page = 1
+    all_rows = []
+    session = _get_session()
+    consecutive_429 = 0
+    max_pages = OP_MAX_PAGES if max_pages_override is None else max_pages_override
+
+    # ----- UI de progresso -----
+    progress_bar = st.session_state.get("__op_progress_bar__")
+    status_text  = st.session_state.get("__op_status_text__")
+    if progress_bar is None:
+        progress_bar = st.progress(0)
+        st.session_state["__op_progress_bar__"] = progress_bar
+    if status_text is None:
+        status_text = st.empty()
+        st.session_state["__op_status_text__"] = status_text
+
+    denom = max_pages if (max_pages and max_pages > 0) else None
+
+    # reset progresso/cancelamento
+    st.session_state[CANCEL_TOKEN_KEY] = st.session_state.get(CANCEL_TOKEN_KEY, False)
+    st.session_state["op_pages_processed"] = 0
+
+    try:
+        while True:
+            # Cancelamento
+            if st.session_state.get(CANCEL_TOKEN_KEY):
+                raise RuntimeError("Consulta cancelada.")
+
+            if max_pages and page > max_pages:
+                break
+
+            url = f"{OP_API_BASE_URL}{path}"
+            headers = _auth_headers(token, base_guid, page, limit, is_post=True)
+            payload_str = json.dumps(body_filter or {}, ensure_ascii=False)
+
+            # ---- Retentativas por Timeout ----
+            timeout_attempt = 0
+            while True:
+                try:
+                    resp = session.post(
+                        url, headers=headers, data=payload_str,
+                        timeout=(OP_CONNECT_TIMEOUT, OP_READ_TIMEOUT), proxies=PROXIES
+                    )
+                    break
+                except (requests.exceptions.ReadTimeout,
+                        requests.exceptions.ConnectTimeout,
+                        requests.exceptions.Timeout) as e:
+                    timeout_attempt += 1
+                    if timeout_attempt > OP_MAX_TIMEOUT_RETRIES:
+                        raise RuntimeError(f"Timeout após {OP_MAX_TIMEOUT_RETRIES} tentativas na página {page}: {e}")
+                    sleep_sec = OP_TIMEOUT_BACKOFF_BASE * timeout_attempt
+                    if OP_LOGIN_DEBUG:
+                        st.warning(f"Timeout na página {page}. Retentativa {timeout_attempt} em ~{sleep_sec}s...")
+                    time.sleep(sleep_sec)
+                except requests.exceptions.RequestException as e:
+                    raise RuntimeError(f"Falha na página {page}: {e}")
+
+            # ✅ 401 → renovar token 1x (OAuth2/client_credentials ou /login) e re-tentar
+            if resp.status_code == 401:
+                token = TM.force_refresh()
+                headers = _auth_headers(token, base_guid, page, limit, is_post=True)
+                resp = session.post(
+                    url, headers=headers, data=payload_str,
+                    timeout=(OP_CONNECT_TIMEOUT, OP_READ_TIMEOUT), proxies=PROXIES
+                )
+                if resp.status_code == 401:
+                    raise RuntimeError(f"Token inválido/expirado após renovação (401) na página {page}: {resp.text[:500]}")
+
+            # 429 → Retry-After + repetir
+            if resp.status_code == 429:
+                wait_sec = _parse_retry_after(resp)
+                consecutive_429 += 1
+                if consecutive_429 > OP_MAX_RETRIES_PER_PAGE:
+                    raise RuntimeError(
+                        f"Limite de tentativas após 429 excedido na página {page}. Aguarde ~{wait_sec}s e tente novamente."
+                    )
+                if OP_LOGIN_DEBUG:
+                    st.warning(f"429 recebido. Aguardando ~{wait_sec}s antes de repetir página {page}...")
+                time.sleep(wait_sec)
+                resp = session.post(
+                    url, headers=headers, data=payload_str,
+                    timeout=(OP_CONNECT_TIMEOUT, OP_READ_TIMEOUT), proxies=PROXIES
+                )
+
+            # 5xx (inclui 502 Bad Gateway) → backoff + jitter
+            if resp.status_code in (500, 502, 503, 504):
+                for attempt in range(1, OP_MAX_RETRIES_5XX + 1):
+                    wait = OP_5XX_BACKOFF_BASE * (2 ** (attempt - 1)) + random.uniform(0, OP_5XX_BACKOFF_BASE)
+                    if OP_LOGIN_DEBUG:
+                        st.warning(f"{resp.status_code} recebido. Retentativa {attempt}/{OP_MAX_RETRIES_5XX} em ~{wait:.1f}s...")
+                    time.sleep(wait)
+                    try:
+                        resp = session.post(
+                            url, headers=headers, data=payload_str,
+                            timeout=(OP_CONNECT_TIMEOUT, OP_READ_TIMEOUT), proxies=PROXIES
+                        )
+                    except requests.exceptions.RequestException:
+                        continue
+                    if resp.status_code < 500:
+                        break
+                if resp.status_code in (500, 502, 503, 504):
+                    snippet = (resp.text or "")[:500]
+                    raise RuntimeError(f"Erro {resp.status_code} na página {page}: {snippet}")
+
+            # Outros erros HTTP
+            if resp.status_code >= 400:
+                raise RuntimeError(f"Erro {resp.status_code} na página {page}: {resp.text[:500]}")
+
+            # RESET 429 quando OK
+            consecutive_429 = 0
+
+            # Parse JSON
+            try:
+                data = resp.json()
+            except Exception:
+                raise RuntimeError(f"JSON inválido na página {page}: {resp.text[:300]}")
+
+            # Normaliza linhas
+            if isinstance(data, list):
+                rows = data
+            elif isinstance(data, dict):
+                rows = data.get("data") or data.get("items") or []
+                if not isinstance(rows, list):
+                    rows = []
+            else:
+                rows = []
+
+            # Fim se vazio
+            if not rows:
+                break
+
+            # Soma acumulado
+            all_rows.extend(rows)
+            st.session_state["op_pages_processed"] = page
+
+            # ----- Atualiza UI de progresso -----
+            status_text.info(f"🔄 Carregando página {page}…")
+            if denom:
+                frac = min(page / float(denom), 1.0)
+                progress_bar.progress(frac)
+            else:
+                progress_bar.progress((page % 10) / 10.0)
+
+            # Próxima página
+            page += 1
+
+            # Atraso entre páginas (rate limit)
+            if OP_RATE_DELAY_SEC > 0:
+                time.sleep(OP_RATE_DELAY_SEC)
+
+        # Concluído: barra 100%
+        progress_bar.progress(1.0)
+        time.sleep(0.1)
+
+    finally:
+        # Limpa componentes de UI sempre
+        try:
+            status_text.empty()
+        except Exception:
+            pass
+        try:
+            progress_bar.empty()
+        except Exception:
+            pass
+        st.session_state.pop("__op_progress_bar__", None)
+        st.session_state.pop("__op_status_text__", None)
+
+    return all_rows
+
+# =====================================================
+# EXPORTS
+# =====================================================
+def _export_excel(df: pd.DataFrame, report_key: str, filtros_aplicados: dict) -> bytes:
+    buffer = BytesIO()
+    with pd.ExcelWriter(buffer, engine="openpyxl") as writer:
+        df.to_excel(writer, index=False, sheet_name=report_key[:30] or "Relatorio")
+        meta_df = pd.DataFrame([filtros_aplicados])
+        meta_df.to_excel(writer, index=False, sheet_name="Filtros_Aplicados")
+    return buffer.getvalue()
+
+def _export_csv(df: pd.DataFrame) -> bytes:
+    return df.to_csv(index=False, encoding="utf-8-sig").encode("utf-8-sig")
+
+# =====================================================
+# Helpers — JWT iat/exp
+# =====================================================
+def _jwt_payload(token: str):
+    try:
+        parts = token.split(".")
+        if len(parts) != 3:
+            return None
+        def b64url_to_b64(s): return s + "=" * (-len(s) % 4)
+        payload_b64 = b64url_to_b64(parts[1])
+        payload_json = base64.urlsafe_b64decode(payload_b64.encode("utf-8")).decode("utf-8")
+        return json.loads(payload_json)
+    except Exception:
+        return None
+
+def _fmt_ts(ts):
+    try:
+        dt = datetime.utcfromtimestamp(int(ts))
+        return dt.strftime("%d/%m/%Y %H:%M:%S") + " UTC"
+    except Exception:
+        return "—"
+
+# =====================================================
+# Sugestões — cache (TTL configurável)
+# =====================================================
+@st.cache_data(ttl=CACHE_TTL_SEC, show_spinner=False)
+def _load_suggestions_recipients(base_guid: str, token: str):
+    """Sugestões de Destinatários (desc+cnpj) a partir de /stock/list (1 página)."""
+    session = _get_session()
+    url = f"{OP_API_BASE_URL}/stock/list"
+    headers = _auth_headers(token, base_guid, page=1, limit=1000, is_post=True)
+    try:
+        resp = session.post(url, headers=headers, data=json.dumps({}, ensure_ascii=False),
+                            timeout=(OP_CONNECT_TIMEOUT, OP_READ_TIMEOUT), proxies=PROXIES)
+        if resp.status_code >= 400: return []
+        data = resp.json()
+    except Exception:
+        return []
+    rows = data if isinstance(data, list) else data.get("data") or data.get("items") or []
+    opts, seen = [], set()
+    for r in rows:
+        desc = str(r.get("recipient_description") or "").strip()
+        doc  = str(r.get("recipient_document") or "").strip()
+        if not desc and not doc: continue
+        label = f"{desc} ({doc})" if doc else desc
+        key = (label, doc)
+        if key not in seen:
+            seen.add(key); opts.append((label, doc))
+    return opts
+
+@st.cache_data(ttl=CACHE_TTL_SEC, show_spinner=False)
+def _load_suggestions_notas(base_guid: str, token: str, path: str):
+    """Sugestões de Nota Fiscal a partir do endpoint corrente (1 página)."""
+    session = _get_session()
+    url = f"{OP_API_BASE_URL}{path}"
+    headers = _auth_headers(token, base_guid, page=1, limit=1000, is_post=True)
+    try:
+        resp = session.post(url, headers=headers, data=json.dumps({}, ensure_ascii=False),
+                            timeout=(OP_CONNECT_TIMEOUT, OP_READ_TIMEOUT), proxies=PROXIES)
+        if resp.status_code >= 400: return []
+        data = resp.json()
+    except Exception:
+        return []
+    rows = data if isinstance(data, list) else data.get("data") or data.get("items") or []
+    field = "wsreceipt_code" if path in ("/wsreceipt/list", "/stock/list", "/operation/list") else \
+            "wsdispatch_code" if path in ("/wsdispatch/list", "/financial/invoice/list") else None
+    opts, seen = [], set()
+    for r in rows:
+        nota = str(r.get(field) or "").strip() if field else ""
+        if nota and nota not in seen:
+            seen.add(nota); opts.append(nota)
+    return opts
+
+@st.cache_data(ttl=CACHE_TTL_SEC, show_spinner=False)
+def _load_suggestions_categories(base_guid: str, token: str, path: str):
+    """Sugestões de Categoria (1 página)."""
+    session = _get_session()
+    url = f"{OP_API_BASE_URL}{path}"
+    headers = _auth_headers(token, base_guid, page=1, limit=1000, is_post=True)
+    try:
+        resp = session.post(url, headers=headers, data=json.dumps({}, ensure_ascii=False),
+                            timeout=(OP_CONNECT_TIMEOUT, OP_READ_TIMEOUT), proxies=PROXIES)
+        if resp.status_code >= 400: return []
+        data = resp.json()
+    except Exception:
+        return []
+    rows = data if isinstance(data, list) else data.get("data") or data.get("items") or []
+    seen, opts = set(), []
+    for r in rows:
+        cat = str(r.get("category_description") or r.get("Categoria") or "").strip()
+        if cat and cat not in seen:
+            seen.add(cat); opts.append(cat)
+    return opts
+
+@st.cache_data(ttl=CACHE_TTL_SEC, show_spinner=False)
+def _load_suggestions_addresses(base_guid: str, token: str):
+    """Sugestões de Endereço (1 página)."""
+    session = _get_session()
+    url = f"{OP_API_BASE_URL}/address/list"
+    headers = _auth_headers(token, base_guid, page=1, limit=1000, is_post=True)
+    try:
+        resp = session.post(url, headers=headers, data=json.dumps({}, ensure_ascii=False),
+                            timeout=(OP_CONNECT_TIMEOUT, OP_READ_TIMEOUT), proxies=PROXIES)
+        if resp.status_code >= 400: return []
+        data = resp.json()
+    except Exception:
+        return []
+    rows = data if isinstance(data, list) else data.get("data") or data.get("items") or []
+    seen, opts = set(), []
+    for r in rows:
+        code = str(r.get("location_code") or r.get("location_id_code") or "").strip()
+        desc = str(r.get("description") or "").strip()
+        if not code: continue
+        label = f"{code} - {desc}" if desc else code
+        if code not in seen:
+            seen.add(code); opts.append((label, code))
+    return opts
+
+@st.cache_data(ttl=CACHE_TTL_SEC, show_spinner=False)
+def _load_suggestions_depositantes(base_guid: str, token: str):
+    """Sugestões de Depositantes (nome+cnpj) a partir de /stock/list (1 página)."""
+    session = _get_session()
+    url = f"{OP_API_BASE_URL}/stock/list"
+    headers = _auth_headers(token, base_guid, page=1, limit=1000, is_post=True)
+    try:
+        resp = session.post(url, headers=headers, data=json.dumps({}, ensure_ascii=False),
+                            timeout=(OP_CONNECT_TIMEOUT, OP_READ_TIMEOUT), proxies=PROXIES)
+        if resp.status_code >= 400: return []
+        data = resp.json()
+    except Exception:
+        return []
+    rows = data if isinstance(data, list) else data.get("data") or data.get("items") or []
+    opts, seen = [], set()
+    for r in rows:
+        name = str(r.get("customer_name") or r.get("customer_description") or r.get("Depositante") or "").strip()
+        doc  = str(r.get("customer_document") or r.get("CNPJ_Depositante") or "").strip()
+        if not name and not doc: continue
+        label = f"{name} ({doc})" if doc else name
+        key = (label, doc)
+        if key not in seen:
+            seen.add(key); opts.append((label, doc))
+    return opts
+
+# =====================================================
+# Body mapping (filtros comuns) — server-side quando suportado
+# =====================================================
+def _map_common_filters_to_body(path: str, ui: dict) -> dict:
+    """
+    Para múltiplas seleções, a maioria dos endpoints não aceita array.
+    Estratégia: enviar 1 valor (o primeiro) no body e aplicar os demais client-side.
+    """
+    enderecos_sel      = ui.get("enderecos_sel", [])
+    endereco_text      = ui.get("endereco_text", "").strip()
+    nf_sel             = ui.get("nota_fiscal_sel", "").strip()
+    sku_item           = ui.get("sku_item", "").strip()
+    part_number        = ui.get("part_number", "").strip()
+    destinatarios_docs = ui.get("destinatarios_docs", [])
+    cnpjs_livres       = ui.get("cnpjs_livres", [])
+    data_op            = ui.get("data_op")  # date único
+    categorias_sel     = ui.get("categorias_sel", [])
+    types_sel          = ui.get("types_sel", [])
+    depositantes_docs  = ui.get("depositantes_docs", [])  # múltiplos CNPJs (sugestões)
+
+    mapped = {}
+
+    # Endereço
+    addr = (enderecos_sel[0] if enderecos_sel else "") or endereco_text
+    if addr:
+        mapped["location_code"] = addr
+
+    # Nota fiscal (apenas sugestões)
+    nf_val = nf_sel
+    if nf_val:
+        if path in ("/wsreceipt/list", "/stock/list", "/operation/list"):
+            mapped["wsreceipt_code"] = nf_val
+        if path in ("/wsdispatch/list", "/financial/invoice/list"):
+            mapped["wsdispatch_code"] = nf_val
+
+    # SKU / Part Number
+    if sku_item:
+        mapped["product_code"] = sku_item
+    if part_number:
+        mapped["part_number"] = part_number
+
+    # Categoria (1 server-side; demais client-side)
+    if len(categorias_sel) == 1:
+        mapped["category_description"] = categorias_sel[0]
+
+    # Destinatário CNPJ (1 server-side)
+    all_cnpjs_dest = [c for c in destinatarios_docs + cnpjs_livres if c]
+    if all_cnpjs_dest:
+        mapped["recipient_document"] = all_cnpjs_dest[0]
+
+    # Depositante CNPJ (1 server-side)
+    if depositantes_docs:
+        mapped["customer_document"] = depositantes_docs[0]
+
+    # Data operação — em /operation/list
+    if path == "/operation/list" and data_op:
+        mapped["date_ini"] = data_op.strftime("%Y-%m-%d")
+        mapped["date_fim"] = data_op.strftime("%Y-%m-%d")
+
+    # Type(API) — 1 server-side
+    if path == "/operation/list" and len(types_sel) == 1:
+        mapped["type"] = types_sel[0]
+
+    return mapped
+
+# =====================================================
+# Client-side filters (Data operação única, Categoria, múltiplos seleção)
+# =====================================================
+def _contains_ci(series: pd.Series, needle: str) -> pd.Series:
+    if series.dtype != "O":
+        series = series.astype("string")
+    return series.fillna("").str.contains(needle, case=False, na=False)
+
+def _coalesce_datetime_ptbr(df: pd.DataFrame, candidates: list) -> pd.Series:
+    result = pd.Series([pd.NaT] * len(df), index=df.index)
+    for c in candidates:
+        if c in df.columns:
+            s = df[c]
+            s1 = pd.to_datetime(s, errors="coerce", dayfirst=True)
+            result = result.fillna(s1)
+            mask_nat = result.isna()
+            if mask_nat.any():
+                s2 = pd.to_datetime(s[mask_nat], errors="coerce", dayfirst=False)
+                result.loc[mask_nat] = s2
+    return result
+
+def _classify_sbm(row: pd.Series) -> str:
+    """
+    Classificação SBM baseada em DEPOSITANTE (não em Destinatário):
+    - Se Depositante contém 'SBM' e Tipo == RECEIVING  -> SBM - LOAD
+    - Se Depositante contém 'SBM' e Tipo == DISPATCH   -> SBM - BACKLOAD
+    - Caso contrário -> OUTROS
+    """
+    depos = str(row.get("Depositante") or row.get("customer_name") or "").upper()
+    typ   = str(row.get("Tipo") or row.get("type") or "").upper()
+    if "SBM" in depos:
+        if typ == "RECEIVING": return "SBM - LOAD"
+        if typ == "DISPATCH":  return "SBM - BACKLOAD"
+    return "OUTROS"
+
+def _apply_client_side_filters(df: pd.DataFrame, ui: dict, sbm_types_sel: list, types_sel: list) -> pd.DataFrame:
+    enderecos_sel      = ui.get("enderecos_sel", [])
+    endereco_text      = ui.get("endereco_text", "").strip()
+    nf_sel             = ui.get("nota_fiscal_sel", "").strip()
+    sku_item           = ui.get("sku_item", "").strip()
+    part_number        = ui.get("part_number", "").strip()
+    destinatarios_docs = [c.strip() for c in ui.get("destinatarios_docs", []) if c.strip()]
+    cnpjs_livres       = [c.strip() for c in ui.get("cnpjs_livres", []) if c.strip()]
+    data_op            = ui.get("data_op")  # único
+    categorias_sel     = ui.get("categorias_sel", [])
+    depositantes_docs  = [c.strip() for c in ui.get("depositantes_docs", []) if c.strip()]
+    depositantes_nomes = [s.strip() for s in ui.get("depositantes_nomes", []) if str(s).strip()]
+
+    # Endereços
+    addr_cols = [c for c in ["Endereço", "location_code", "location_id_code"] if c in df.columns]
+    if addr_cols:
+        if enderecos_sel:
+            mask = False
+            for c in addr_cols:
+                mask = df[c].isin(enderecos_sel) | mask
+            df = df[mask].copy()
+        if endereco_text:
+            mask = False
+            for c in addr_cols:
+                mask = _contains_ci(df[c], endereco_text) | mask
+            df = df[mask].copy()
+
+    # Nota Fiscal (apenas seleção)
+    if nf_sel:
+        cols = [c for c in ["Nota Fiscal", "NF Saída", "wsreceipt_code", "wsdispatch_code"] if c in df.columns]
+        mask = False
+        for c in cols:
+            mask = _contains_ci(df[c], nf_sel) | mask
+        df = df[mask].copy()
+
+    # SKU / item
+    if sku_item:
+        cols = [c for c in ["SKU", "product_code"] if c in df.columns]
+        mask = False
+        for c in cols:
+            mask = _contains_ci(df[c], sku_item) | mask
+        df = df[mask].copy()
+
+    # Part Number
+    if part_number and "part_number" in df.columns:
+        df = df[_contains_ci(df["part_number"], part_number)].copy()
+
+    # CNPJ Destinatários
+    all_cnpjs_dest = destinatarios_docs + cnpjs_livres
+    if all_cnpjs_dest:
+        cols = [c for c in ["CNPJ_Destinatário", "recipient_document"] if c in df.columns]
+        mask = False
+        for c in cols:
+            mask = df[c].isin(all_cnpjs_dest) | mask
+        df = df[mask].copy()
+
+    # Depositantes (por CNPJ e/ou por nome) — multisseleção
+    dep_doc_cols  = [c for c in ["CNPJ_Depositante", "customer_document"] if c in df.columns]
+    dep_name_cols = [c for c in ["Depositante", "customer_name", "customer_description"] if c in df.columns]
+    if depositantes_docs and dep_doc_cols:
+        mask = False
+        for c in dep_doc_cols:
+            mask = df[c].isin(depositantes_docs) | mask
+        df = df[mask].copy()
+    if depositantes_nomes and dep_name_cols:
+        mask = False
+        for c in dep_name_cols:
+            mask_local = False
+            for name in depositantes_nomes:
+                mask_local = _contains_ci(df[c], name) | mask_local
+            mask = mask | mask_local
+        df = df[mask].copy()
+
+    # Data da operação (única)
+    if data_op:
+        op_date = _coalesce_datetime_ptbr(df, [
+            "Data Operação","Data","Data Emissão","Data Agendada",
+            "Validade","Fabricação",
+            "date","create_date","issue_date","scheduled_date","expiration_date","manufacturing_date","last_update_date"
+        ])
+        data_ini = pd.to_datetime(data_op)
+        data_fim = data_ini + pd.Timedelta(days=1) - pd.Timedelta(milliseconds=1)
+        df = df[(op_date >= data_ini) & (op_date <= data_fim)].copy()
+
+    # Categoria
+    if categorias_sel:
+        cols = [c for c in ["Categoria", "category_description"] if c in df.columns]
+        mask = False
+        for c in cols:
+            mask = df[c].isin(categorias_sel) | mask
+        df = df[mask].copy()
+
+    # Tipo (API) multisseleção ('Tipo' ou 'type')
+    if types_sel and ("Tipo" in df.columns or "type" in df.columns):
+        col_t = "Tipo" if "Tipo" in df.columns else "type"
+        df = df[df[col_t].isin(types_sel)].copy()
+
+    # Tipo de operação (SBM) — baseado em DEPOSITANTE
+    if sbm_types_sel:
+        sbm_series = df.apply(_classify_sbm, axis=1)
+        df = df[sbm_series.isin(sbm_types_sel)].copy()
+
+    return df
+
+# =====================================================
+# Formatação (R$, SKU, datas PT-BR, remove colunas vazias)
+# =====================================================
+def _format_currency_brl(val):
+    try:
+        x = float(val)
+    except Exception:
+        return val
+    s = f"{x:,.2f}"
+    s = s.replace(",", "X").replace(".", ",").replace("X", ".")
+    return f"R$ {s}"
+
+def _format_dates_ptbr(df: pd.DataFrame) -> pd.DataFrame:
+    candidate_cols = [
+        "Data Operação","Data","Data Emissão","Validade","Fabricação",
+        "Data Agendada","date","create_date","issue_date","expiration_date",
+        "manufacturing_date","scheduled_date","last_update_date"
+    ]
+    for col in df.columns:
+        if col in candidate_cols:
+            try:
+                s = pd.to_datetime(df[col], errors="coerce", dayfirst=True)
+                nat_mask = s.isna()
+                if nat_mask.any():
+                    s.loc[nat_mask] = pd.to_datetime(df[col][nat_mask], errors="coerce", dayfirst=False)
+                df[col] = s.dt.strftime("%d/%m/%Y").fillna(df[col])
+            except Exception:
+                pass
+    return df
+
+def _format_dataframe(df: pd.DataFrame) -> pd.DataFrame:
+    if df.empty:
+        return df
+
+    # R$
+    money_candidates = ["Vr. Total", "Vr. Unitário", "Item_Value",
+                        "item_total_value", "item_unit_value", "receipt_value", "total_value"]
+    for col in money_candidates:
+        if col in df.columns:
+            df[col] = df[col].apply(_format_currency_brl)
+
+    # SKU sem zeros à esquerda
+    for col in ["SKU", "product_code"]:
+        if col in df.columns:
+            def strip_zeros(v):
+                s = str(v or "").strip()
+                if not s:
+                    return s
+                s2 = s.lstrip("0")
+                return s2 if s2 else "0"
+            df[col] = df[col].apply(strip_zeros)
+
+    # Datas PT-BR
+    df = _format_dates_ptbr(df)
+
+    # Remove colunas vazias
+    to_drop = []
+    for col in df.columns:
+        serie = df[col]
+        empties = serie.isna() | (serie.astype(str).str.strip() == "")
+        if empties.all():
+            to_drop.append(col)
+    if to_drop:
+        df = df.drop(columns=to_drop)
+
+    return df
+
+# =====================================================
+# Helpers de KPI (somas seguras, moeda BRL, contagens)
+# =====================================================
+def _to_num_brl(val) -> float:
+    """Converte 'R$ 1.234,56' ou num/str para float (1234.56)."""
+    if val is None: return 0.0
+    if isinstance(val, (int, float)): return float(val)
+    s = str(val).strip()
+    if not s: return 0.0
+    s = s.replace("R$", "").replace(" ", "")
+    s = s.replace(".", "").replace(",", ".")
+    try:
+        return float(s)
+    except Exception:
+        return 0.0
+
+def _safe_sum(series: pd.Series) -> float:
+    """Soma segura de séries possivelmente formatadas em BRL (strings)."""
+    if series is None or series.empty: return 0.0
+    return float(series.apply(_to_num_brl).sum())
+
+def _nunique(df: pd.DataFrame, colnames: list) -> int:
+    """Conta distintos na primeira coluna existente em 'colnames'."""
+    for c in colnames:
+        if c in df.columns:
+            return int(df[c].nunique(dropna=True))
+    return 0
+
+def _count_status(df: pd.DataFrame, col: str, positivos=("ATIVO","ACTIVE","BLOQUEADO","BLOCKED")) -> int:
+    """Conta registros com 'Status' em valores positivos (case-insensitive)."""
+    if col not in df.columns: return 0
+    s = df[col].astype(str).str.upper()
+    return int(s.isin([p.upper() for p in positivos]).sum())
+
+# =====================================================
+# KPIs dinâmicos por endpoint (usa colunas pós-RENAME_MAP)
+# =====================================================
+def _build_kpis(path: str, df: pd.DataFrame) -> dict:
+    kpis = {}
+
+    if path == "/address/blocking/list":
+        kpis["Endereços bloqueados (distintos)"] = _nunique(df, ["Endereço","location_code","location_id_code"])
+        kpis["Bloqueios (linhas)"]              = int(len(df))
+        kpis["Motivos de bloqueio (distintos)"] = _nunique(df, ["Motivo Bloqueio","block_reason"])
+        if "Status" in df.columns:
+            kpis["Bloqueios ativos"] = _count_status(df, "Status", positivos=("BLOQUEADO","BLOCKED"))
+
+    elif path == "/address/list":
+        kpis["Endereços (distintos)"] = _nunique(df, ["Endereço","location_code","location_id_code"])
+        if "Status" in df.columns:
+            kpis["Endereços ativos"] = _count_status(df, "Status", positivos=("ATIVO","ACTIVE"))
+
+    elif path == "/stock/list":
+        # IMPORTANT: Valor total em estoque deve vir DA COLUNA 'Vr. Total'
+        qtde_total   = _safe_sum(df["Qtde"])           if "Qtde"            in df.columns else 0.0
+        qtde_reserva = _safe_sum(df["Qtde Reservada"]) if "Qtde Reservada"  in df.columns else 0.0
+        valor_total  = _safe_sum(df["Vr. Total"])      if "Vr. Total"       in df.columns else 0.0
+
+        kpis["SKUs (distintos)"]            = _nunique(df, ["SKU","product_code"])
+        kpis["Itens em estoque (Qtde)"]     = qtde_total
+        kpis["Itens reservados (Qtde)"]     = qtde_reserva
+        kpis["Valor total em estoque (R$)"] = valor_total
+        kpis["Lotes (distintos)"]           = _nunique(df, ["Lote","lot"])
+        kpis["Endereços (distintos)"]       = _nunique(df, ["Endereço","location_code"])
+        kpis["Depositantes (distintos)"]    = _nunique(df, ["Depositante","customer_description","customer_name"])
+
+    elif path == "/wsreceipt/list":
+        qtde_total  = _safe_sum(df["Qtde"])      if "Qtde"      in df.columns else 0.0
+        valor_total = _safe_sum(df["Vr. Total"]) if "Vr. Total" in df.columns else 0.0
+        kpis["NF de entrada (distintas)"]  = _nunique(df, ["NF Entrada","wsreceipt_code"])
+        kpis["Linhas (itens)"]             = int(len(df))
+        kpis["Qtde total (Entrada)"]       = qtde_total
+        kpis["Valor total (Entrada) R$"]   = valor_total
+        kpis["Depositantes (distintos)"]   = _nunique(df, ["Depositante","customer_name"])
+
+    elif path == "/wsdispatch/list":
+        qtde_total  = _safe_sum(df["Qtde"])      if "Qtde"      in df.columns else 0.0
+        valor_total = _safe_sum(df["Vr. Total"]) if "Vr. Total" in df.columns else 0.0
+        kpis["NF de saída (distintas)"]    = _nunique(df, ["NF Saída","wsdispatch_code"])
+        kpis["Linhas (itens)"]             = int(len(df))
+        kpis["Qtde total (Saída)"]         = qtde_total
+        kpis["Valor total (Saída) R$"]     = valor_total
+        kpis["Destinatários (distintos)"]  = _nunique(df, ["Destinatário","recipient_description"])
+
+    elif path == "/operation/list":
+        qtde_total = _safe_sum(df["Qtde"]) if "Qtde" in df.columns else 0.0
+        kpis["Operações (linhas)"]     = int(len(df))
+        kpis["Tipos (distintos)"]      = _nunique(df, ["Tipo","type"])
+        kpis["Qtde total (Operações)"] = qtde_total
+
+    elif path == "/product/list":
+        kpis["Produtos (linhas)"]       = int(len(df))
+        kpis["Categorias (distintas)"]  = _nunique(df, ["Categoria","category_description"])
+        kpis["Grupos (distintos)"]      = _nunique(df, ["Grupo","group_description"])
+        kpis["Status (distintos)"]      = _nunique(df, ["Status","status"])
+
+    elif path == "/financial/invoice/list":
+        valor_total = _safe_sum(df["Vr. Total"]) if "Vr. Total" in df.columns else 0.0
+        kpis["Faturas (distintas)"]     = _nunique(df, ["Número Fatura","invoice_number"])
+        kpis["Valor total (R$)"]        = valor_total
+        kpis["Status (distintos)"]      = _nunique(df, ["Status","status"])
+
+    elif path == "/monitor/nfe/list":
+        kpis["NFes (distintas)"]         = _nunique(df, ["Chave NFe","nfe_key"])
+        kpis["Status SEFAZ (distintos)"] = _nunique(df, ["Status SEFAZ","status"])
+
+    elif path == "/yms/scheduling/list":
+        kpis["Agendamentos (distintos)"] = _nunique(df, ["ID Agendamento","scheduling_id"])
+        kpis["Status (distintos)"]       = _nunique(df, ["Status","status"])
+        kpis["Pátios (distintos)"]       = _nunique(df, ["Pátio","yard"])
+        kpis["Docas (distintas)"]        = _nunique(df, ["Doca","dock"])
+
+    elif path == "/cargorelease/list":
+        qtde_total = _safe_sum(df["Qtde"]) if "Qtde" in df.columns else 0.0
+        kpis["Pedidos (distintos)"]      = _nunique(df, ["Pedido","cargorelease_code"])
+        kpis["Status (distintos)"]       = _nunique(df, ["Status","status"])
+        kpis["Qtde total (Pedidos)"]     = qtde_total
+
+    else:
+        kpis["Linhas"] = int(len(df))
+
+    return kpis
+
+# =====================================================
+# Cache de consulta (DF final) — TTL configurável
+# =====================================================
+@st.cache_data(ttl=CACHE_TTL_SEC, show_spinner=True)
+def _run_query_cached(path: str, base_guid: str, token: str, body_filter: dict, limit_per_page: int, max_pages_override, ui_common: dict, sbm_types_sel: list):
+    rows = _call_list_paginated(
+        path, base_guid, token, body_filter,
+        limit=limit_per_page,
+        max_pages_override=max_pages_override
+    )
+    df = pd.json_normalize(rows)
+    rename = RENAME_MAP.get(path, {})
+    if rename:
+        df = df.rename(columns={k: v for k, v in rename.items() if k in df.columns})
+    df = _apply_client_side_filters(df, ui_common, sbm_types_sel, ui_common.get("types_sel", []))
+    df = _format_dataframe(df)
+    return df
+
+# =====================================================
+# UI — Type(API), Destinatários, Endereços; Data operação (única); Categoria; SBM; Depositantes
+# + Modo rápido (consulta leve) e limite por página
+# + Debounce e Cancelar
+# =====================================================
+def _render_form(report_label: str, token: str):
+    with st.form(f"form_{report_label.replace(' ', '_')}"):
+        base = st.selectbox("Base (x-user-enterprise-id):", list(BASES_MAP.keys()), index=0)
+
+        # Performance
+        col_perf1, col_perf2 = st.columns(2)
+        with col_perf1:
+            quick_mode = st.checkbox("Consulta leve (rápida)", value=True, help="Coleta apenas 1 página e mostra colunas essenciais.")
+        with col_perf2:
+            limit_per_page = st.number_input("Itens por página", min_value=50, max_value=2000, value=500, step=50, help="Se suportado pelo servidor.")
+
+        # Paginação manual (quando necessário)
+        colp1, colp2 = st.columns(2)
+        with colp1:
+            only_first = st.checkbox("Coletar apenas a primeira página (evitar limite/timeouts)", value=False)
+        with colp2:
+            max_pages_ui = st.number_input("Máximo de páginas (0=∞)", min_value=0, max_value=100, value=0, step=1)
+
+        path = ENDPOINTS[report_label]
+
+        # Type (API) multisseleção
+        types_sel = st.multiselect("Type (API)", OPERATION_TYPES, default=[])
+
+        # Data da operação (única)
+        data_op = st.date_input("Data da operação (opcional)", value=None)
+
+        # Categoria (sugestões) multisseleção
+        categorias_opts = _load_suggestions_categories(BASES_MAP[base], token, path)
+        categorias_sel = st.multiselect("Categoria (sugestões)", categorias_opts, default=[])
+
+        # Endereços (sugestões) multisseleção + texto
+        addr_opts = _load_suggestions_addresses(BASES_MAP[base], token)  # [(label, code)]
+        addr_labels = [lbl for (lbl, code) in addr_opts]
+        addr_values = [code for (lbl, code) in addr_opts]
+        end_sel_labels = st.multiselect("Endereços (sugestões)", addr_labels, default=[])
+        enderecos_sel = []
+        for sel in end_sel_labels:
+            i = addr_labels.index(sel)
+            enderecos_sel.append(addr_values[i])
+        endereco_text = st.text_input("Endereço (texto)")
+
+        # Nota Fiscal (apenas sugestões)
+        nf_opts = _load_suggestions_notas(BASES_MAP[base], token, path)
+        nota_fiscal_sel  = st.selectbox("Nota Fiscal (sugestões)", [""] + nf_opts, index=0)
+
+        # Item / SKU e Part Number
+        colA, colB = st.columns(2)
+        with colA:
+            sku_item    = st.text_input("Item / SKU")
+        with colB:
+            part_number = st.text_input("Part Number")
+
+        # Destinatários (sugestões multisseleção) + CNPJ múltiplos
+        dest_opts = _load_suggestions_recipients(BASES_MAP[base], token)  # [(label, cnpj)]
+        dest_labels = [lbl for (lbl, cnpj) in dest_opts]
+        dest_values = [cnpj for (lbl, cnpj) in dest_opts]
+        dest_sel_labels = st.multiselect("Destinatários (sugestões)", dest_labels, default=[])
+        destinatarios_docs = []
+        for sel in dest_sel_labels:
+            i = dest_labels.index(sel)
+            destinatarios_docs.append(dest_values[i])
+
+        cnpj_livre_text = st.text_input("CNPJ(s) do destinatário (múltiplos, separados por vírgula)")
+        cnpjs_livres = [c.strip() for c in cnpj_livre_text.split(",")] if cnpj_livre_text.strip() else []
+
+        # Depositantes (sugestões multisseleção)
+        dep_opts = _load_suggestions_depositantes(BASES_MAP[base], token)  # [(label, cnpj)]
+        dep_labels = [lbl for (lbl, cnpj) in dep_opts]
+        dep_values = [cnpj for (lbl, cnpj) in dep_opts]
+        dep_sel_labels = st.multiselect("Depositantes (sugestões)", dep_labels, default=[])
+        depositantes_docs, depositantes_nomes = [], []
+        for sel in dep_sel_labels:
+            i = dep_labels.index(sel)
+            depositantes_docs.append(dep_values[i])
+            # Também guardamos o nome (parte antes do " (CNPJ)") para filtro por nome, se desejar
+            name = sel.split(" (")[0].strip() if " (" in sel else sel
+            depositantes_nomes.append(name)
+
+        # Tipo de operação (SBM) multisseleção — baseado em Depositante
+        sbm_types_sel = st.multiselect("Tipo de operação (SBM)", SBM_TYPES, default=[]) if report_label == "Estoque" else []
+
+        # Server-side (quando suportado)
+        body = {}
+        if report_label == "Operações":
+            st.markdown("**Filtros de Operações (server-side)**")
+            if len(types_sel) == 1:
+                body["type"] = types_sel[0]
+            if data_op:
+                body["date_ini"] = data_op.strftime("%Y-%m-%d")
+                body["date_fim"] = data_op.strftime("%Y-%m-%d")
+
+        elif report_label == "Agendamento":
+            st.markdown("**Filtros de Agendamento (YMS)**")
+            if data_op:
+                body["date_ini"] = data_op.strftime("%Y-%m-%d")
+                body["date_fim"] = data_op.strftime("%Y-%m-%d")
+
+        ui_common = {
+            "enderecos_sel": enderecos_sel,
+            "endereco_text": endereco_text,
+            "nota_fiscal_sel": nota_fiscal_sel,  # sem campo texto
+            "sku_item": sku_item,
+            "part_number": part_number,
+            "destinatarios_docs": destinatarios_docs,
+            "cnpjs_livres": cnpjs_livres,
+            "data_op": data_op,                         # único
+            "categorias_sel": categorias_sel,
+            "types_sel": types_sel,
+            "depositantes_docs": depositantes_docs,     # multisseleção
+            "depositantes_nomes": depositantes_nomes,   # para match por nome, se desejar
+        }
+
+        mapped = _map_common_filters_to_body(path, ui_common)
+        body.update({k: v for k, v in mapped.items() if v})
+
+        submitted = st.form_submit_button("Consultar", type="primary", use_container_width=True)
+
+        # Debounce leve
+        if submitted:
+            last_submit = st.session_state.get("__last_submit_ts__", 0)
+            now = time.time()
+            if now - last_submit < 2.0:
+                st.info("Aguarde um instante e evite clicar repetidamente em 'Consultar'.")
+                submitted = False
+            st.session_state["__last_submit_ts__"] = now
+
+    max_pages_effective = 1 if only_first else int(max_pages_ui or 0)
+    return (
+        submitted,
+        BASES_MAP[base],
+        max_pages_effective,
+        body,
+        ui_common,
+        sbm_types_sel,
+        quick_mode,
+        limit_per_page,
+    )
+
+# =====================================================
+# TELA PRINCIPAL
+# =====================================================
+def main():
+    # Oculta nav lateral de outros módulos
+    st.markdown("""
+    <style>
+    [data-testid="stSidebarNav"] { display: none !important; }
+    </style>
+    """, unsafe_allow_html=True)
+
+    st.title("⚙️ Operação | Relatórios via API (Mayasuite)")
+
+    # Permissão
+    if not verificar_permissao("operacao") and st.session_state.get("perfil") != "admin":
+        st.error("⛔ Acesso não autorizado.")
+        return
+
+    if not (OP_LOGIN_EMAIL and OP_LOGIN_PASSWORD) and not OP_ACCESS_TOKEN and not (OAUTH_TOKEN_URL and OAUTH_CLIENT_ID and OAUTH_CLIENT_SECRET):
+        st.warning("⚠️ Configure OP_LOGIN_EMAIL/OP_LOGIN_PASSWORD, ou OP_ACCESS_TOKEN, ou OAuth2 (OAUTH_TOKEN_URL/CLIENT_ID/CLIENT_SECRET) no .env (nunca hardcode).")
+        st.info("Ex.: OP_LOGIN_EMAIL=api@armmatriz.com.br / OP_LOGIN_PASSWORD=***  OU  OP_ACCESS_TOKEN=jwt...  OU  OAuth2 client_credentials.")
+        return
+
+    # Token antes do form (sugestões)
+    try:
+        token = _get_token(OP_LOGIN_EMAIL, OP_LOGIN_PASSWORD)
+    except Exception as e:
+        st.error(f"Login/API falhou: {e}")
+        return
+
+    # Sidebar: token info
+    if OP_ACCESS_TOKEN:
+        payload = _jwt_payload(OP_ACCESS_TOKEN)
+        if payload:
+            st.sidebar.caption(f"🔑 Token carregado\n• iat: {_fmt_ts(payload.get('iat'))}\n• exp: {_fmt_ts(payload.get('exp'))}")
+    st.sidebar.caption(f"🌐 Base API: {OP_API_BASE_URL}")
+
+    st.session_state["__active_module__"] = "operacao"
+
+    st.sidebar.markdown("### Relatórios")
+    report_label = st.sidebar.selectbox("Selecione:", list(ENDPOINTS.keys()), index=0)
+    path = ENDPOINTS[report_label]
+
+    # ⚡ Cache controls (TTL, limpar caches)
+    with st.sidebar.expander("⚡ Cache", expanded=False):
+        ttl_ui = st.slider("TTL do cache (minutos)", min_value=1, max_value=60, value=CACHE_TTL_MIN, step=1)
+        st.session_state["__cache_ttl_sec__"] = ttl_ui * 60
+        colc1, colc2 = st.columns(2)
+        with colc1:
+            if st.button("🧹 Limpar cache de dados"):
+                try:
+                    _run_query_cached.clear()
+                except Exception:
+                    pass
+                st.success("Cache de dados limpo.")
+                st.rerun()
+        with colc2:
+            if st.button("🧹 Limpar cache de sugestões"):
+                try:
+                    _load_suggestions_recipients.clear()
+                    _load_suggestions_notas.clear()
+                    _load_suggestions_categories.clear()
+                    _load_suggestions_addresses.clear()
+                    _load_suggestions_depositantes.clear()
+                except Exception:
+                    pass
+                st.success("Cache de sugestões limpo.")
+                st.rerun()
+
+    submitted, base_guid, max_pages_effective, body_filter, ui_common, sbm_types_sel, quick_mode, limit_per_page = _render_form(report_label, token)
+    if not submitted:
+        return
+
+    # Botão cancelar
+    cancel_col, _ = st.columns([1,3])
+    with cancel_col:
+        if st.button("⛔ Cancelar consulta"):
+            st.session_state[CANCEL_TOKEN_KEY] = True
+            st.warning("Consulta cancelada pelo usuário.")
+            return
+    st.session_state[CANCEL_TOKEN_KEY] = False
+
+    # Modo rápido → força apenas 1 página
+    effective_max_pages = 1 if quick_mode else (max_pages_effective if max_pages_effective > 0 else None)
+
+    # Executa consulta com cache
+    t0 = time.time()
+    try:
+        df = _run_query_cached(path, base_guid, token, body_filter, limit_per_page, effective_max_pages, ui_common, sbm_types_sel)
+    except Exception as e:
+        st.error(f"Falha na consulta: {e}")
+        # Botão para tentar novamente
+        if st.button("🔁 Tentar novamente agora"):
+            try:
+                _run_query_cached.clear()
+                df = _run_query_cached(path, base_guid, token, body_filter, limit_per_page, effective_max_pages, ui_common, sbm_types_sel)
+            except Exception as e2:
+                st.error(f"Falha na nova tentativa: {e2}")
+                return
+        else:
+            return
+    latency_ms = int((time.time() - t0) * 1000)
+
+    if df.empty:
+        st.info("Nenhum registro retornado.")
+        return
+
+    st.success(f"✅ Consulta concluída ({latency_ms} ms). Registros: {len(df)}")
+    pages_done = int(st.session_state.get("op_pages_processed", 0))
+    st.caption(f"📄 Páginas coletadas: {pages_done}")
+
+    # Visualização essencial em modo rápido
+    if quick_mode:
+        essential_cols = [c for c in [
+            "Data Operação","Data","Nota Fiscal","NF Saída","SKU","Descrição","Qtde",
+            "Unidade","Endereço","Categoria","Destinatário","CNPJ_Destinatário","Tipo","Depositante","CNPJ_Depositante"
+        ] if c in df.columns]
+        df_view = df[essential_cols].copy() if essential_cols else df
+    else:
+        df_view = df
+
+    # KPIs básicos
+    k1, k2, k3 = st.columns(3)
+    with k1: st.metric("Registros", len(df_view))
+    with k2: st.metric("Latência (ms)", latency_ms)
+    with k3: st.metric("Colunas", df_view.shape[1])
+
+    # ======== NOVOS CARDS DINÂMICOS POR CONSULTA ========
+    kpis = _build_kpis(path, df)  # usa o df já renomeado/filtrado
+    if kpis:
+        st.markdown("#### 📈 Indicadores da consulta")
+        cols = st.columns(min(4, max(1, len(kpis))))
+        for i, (label, value) in enumerate(kpis.items()):
+            # Formata moeda R$ quando aplicável
+            if isinstance(value, (int, float)) and ("R$" in label or "Valor" in label):
+                display_val = _format_currency_brl(value)
+            else:
+                display_val = value
+            cols[i % len(cols)].metric(label, display_val)
+
+    # Tabela
+    st.dataframe(df_view, use_container_width=True)
+
+    # Export
+    col_a, col_b = st.columns(2)
+    with col_a:
+        filtros_export = {"base": base_guid, "max_pages": effective_max_pages or 0, **body_filter, **{f"ui_{k}": v for k, v in ui_common.items()}, "sbm_types": sbm_types_sel}
+        excel_bytes = _export_excel(df, report_label, filtros_export)
+        st.download_button("📥 Exportar Excel", excel_bytes, file_name=f"operacao_{report_label.replace(' ','_')}.xlsx",
+                           mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
+    with col_b:
+        csv_bytes = _export_csv(df)
+        st.download_button("📥 Exportar CSV", csv_bytes, file_name=f"operacao_{report_label.replace(' ','_')}.csv", mime="text/csv")
+
+    # Auditoria
+    try:
+        registrar_log(usuario=st.session_state.get("usuario"),
+                      acao=f"Operação/API: {report_label} (base={base_guid}, {latency_ms}ms, reg={len(df)})",
+                      tabela="operacao_api", registro_id=None)
+    except Exception:
+        pass
+
+# Se for executado diretamente (opcional para debug local)
+if __name__ == "__main__":
+    st.set_page_config(page_title="Operação | ARM", layout="wide")
+    main()
+
+
+
+

outlook_relatorio.py

@@ -0,0 +1,1624 @@
+
+# -*- coding: utf-8 -*-
+import streamlit as st
+import pandas as pd
+from datetime import datetime, timedelta, date
+import io
+import re
+import unicodedata
+import pythoncom  # ✅ COM init/finalize para evitar 'CoInitialize não foi chamado'
+
+# (opcional) auditoria, se existir no seu projeto
+try:
+    from utils_auditoria import registrar_log
+    _HAS_AUDIT = True
+except Exception:
+    _HAS_AUDIT = False
+
+# ==============================
+# 🎨 Estilos (UX)
+# ==============================
+_STYLES = """
+<style>
+/* --- Cards/KPIs --- */
+.kpi-wrap {display:grid;grid-template-columns:repeat(3,1fr);gap:14px;margin:6px 0 8px 0;}
+.kpi-card {border:1px solid rgba(0,0,0,.06);border-radius:12px;padding:14px;background:#ffffff;
+           box-shadow: 0 1px 3px rgba(0,0,0,.04);}
+.kpi-top {display:flex;align-items:center;gap:10px;margin-bottom:6px;}
+.kpi-ico {font-size:22px;line-height:1;}
+.kpi-title {font-size:12px;font-weight:700;color:#6c757d;letter-spacing:.2px;text-transform:uppercase;}
+.kpi-val {font-size:26px;font-weight:800;color:#0b1320;margin-top:2px;}
+.kpi-note {font-size:12px;color:#6c757d;margin-top:4px;}
+
+/* --- Barra de status --- */
+.status-bar {border:1px solid rgba(0,0,0,.06);border-radius:12px;padding:10px 12px;margin:4px 0 10px 0;
+             background:linear-gradient(180deg, rgba(248,249,250,.9), rgba(255,255,255,.9));}
+.status-line {display:flex;flex-wrap:wrap;gap:10px;font-size:13px;color:#495057;}
+.badge {display:inline-flex;align-items:center;gap:6px;padding:4px 8px;border-radius:999px;background:#eef2ff;color:#1d4ed8;
+        border:1px solid #e0e7ff;font-weight:600;}
+.badge.gray {background:#f8f9fa;color:#495057;border:1px solid #e9ecef;}
+.badge.green {background:#e7f6ec;color:#1b5e20;border:1px solid #cdebd7;}
+.badge.amber {background:#fff4e5;color:#8a4b08;border:1px solid #ffe2bf;}
+
+/* --- Toolbar Downloads (fixa no rodapé) --- */
+.dl-bar {position:sticky;bottom:8px;z-index:99;display:flex;gap:10px;padding:8px;background:rgba(255,255,255,.85);
+         border:1px solid rgba(0,0,0,.06);border-radius:12px;backdrop-filter:saturate(180%) blur(8px);}
+
+@media (max-width: 900px){ .kpi-wrap{grid-template-columns:1fr 1fr;} }
+@media (max-width: 600px){ .kpi-wrap{grid-template-columns:1fr;} .dl-bar{flex-wrap:wrap;} }
+</style>
+"""
+
+# ==============================
+# Utils — exportação / indicadores
+# ==============================
+def _build_downloads(df: pd.DataFrame, base_name: str):
+    """Cria botões de download (CSV, Excel e PDF) para o DataFrame."""
+    if df.empty:
+        st.warning("Nenhum dado para exportar.")
+        return
+
+    st.markdown('<div class="dl-bar">', unsafe_allow_html=True)
+
+    # CSV
+    csv_buf = io.StringIO()
+    df.to_csv(csv_buf, index=False, encoding="utf-8-sig")
+    st.download_button(
+        "⬇️ Baixar CSV",
+        data=csv_buf.getvalue(),
+        file_name=f"{base_name}.csv",
+        mime="text/csv",
+        key=f"dl_csv_{base_name}"
+    )
+
+    # Excel (com autoajuste de larguras)
+    xlsx_buf = io.BytesIO()
+    with pd.ExcelWriter(xlsx_buf, engine="openpyxl") as writer:
+        df.to_excel(writer, index=False, sheet_name="Relatorio")
+        ws = writer.sheets["Relatorio"]
+
+        # 🔎 Ajuste automático de largura das colunas
+        from openpyxl.utils import get_column_letter
+        for col_idx, col_cells in enumerate(ws.columns, start=1):
+            max_len = 0
+            for cell in col_cells:
+                try:
+                    v = "" if cell.value is None else str(cell.value)
+                    max_len = max(max_len, len(v))
+                except Exception:
+                    pass
+            ws.column_dimensions[get_column_letter(col_idx)].width = min(max_len + 2, 60)
+
+    xlsx_buf.seek(0)
+    st.download_button(
+        "⬇️ Baixar Excel",
+        data=xlsx_buf,
+        file_name=f"{base_name}.xlsx",
+        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        key=f"dl_xlsx_{base_name}"
+    )
+
+    # PDF (resumo até 100 linhas)
+    try:
+        from reportlab.lib.pagesizes import A4, landscape
+        from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer
+        from reportlab.lib import colors
+        from reportlab.lib.styles import getSampleStyleSheet
+
+        pdf_buf = io.BytesIO()
+        doc = SimpleDocTemplate(
+            pdf_buf, pagesize=landscape(A4),
+            rightMargin=20, leftMargin=20, topMargin=20, bottomMargin=20
+        )
+        styles = getSampleStyleSheet()
+        story = [Paragraph(f"Relatório de E-mails — {base_name}", styles["Title"]), Spacer(1, 12)]
+        df_show = df.copy().head(100)
+        data_table = [list(df_show.columns)] + df_show.astype(str).values.tolist()
+        table = Table(data_table, repeatRows=1)
+        table.setStyle(TableStyle([
+            ("BACKGROUND", (0,0), (-1,0), colors.HexColor("#E9ECEF")),
+            ("TEXTCOLOR", (0,0), (-1,0), colors.HexColor("#212529")),
+            ("GRID", (0,0), (-1,-1), 0.25, colors.HexColor("#ADB5BD")),
+            ("FONTNAME", (0,0), (-1,0), "Helvetica-Bold"),
+            ("FONTNAME", (0,1), (-1,-1), "Helvetica"),
+            ("FONTSIZE", (0,0), (-1,-1), 9),
+            ("ALIGN", (0,0), (-1,-1), "LEFT"),
+            ("VALIGN", (0,0), (-1,-1), "MIDDLE"),
+        ]))
+        story.append(table)
+        doc.build(story)
+        pdf_buf.seek(0)
+        st.download_button(
+            "⬇️ Baixar PDF",
+            data=pdf_buf,
+            file_name=f"{base_name}.pdf",
+            mime="application/pdf",
+            key=f"dl_pdf_{base_name}"
+        )
+    except Exception as e:
+        st.info(f"PDF: não foi possível gerar o arquivo (ReportLab). Detalhe: {e}")
+
+    st.markdown("</div>", unsafe_allow_html=True)  # fecha dl-bar
+
+
+# ======================================================
+# Helpers para clientes múltiplos e Indicadores visuais
+# ======================================================
+def _ensure_client_exploded(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Garante 'cliente_lista' a partir de 'cliente' separando por ';' quando necessário
+    e retorna um DF 'explodido' (uma linha por cliente), sem perder as colunas originais.
+    """
+    if df.empty:
+        return df.copy()
+
+    df2 = df.copy()
+
+    if "cliente_lista" not in df2.columns and "cliente" in df2.columns:
+        def _split_by_semicolon(s):
+            if pd.isna(s):
+                return None
+            parts = [p.strip() for p in str(s).split(";")]
+            parts = [p for p in parts if p]
+            return parts or None
+        df2["cliente_lista"] = df2["cliente"].apply(_split_by_semicolon)
+
+    if "cliente_lista" in df2.columns:
+        try:
+            exploded = df2.explode("cliente_lista", ignore_index=True)
+            exploded["cliente_lista"] = exploded["cliente_lista"].astype(str).str.strip()
+            exploded = exploded[exploded["cliente_lista"].notna() & (exploded["cliente_lista"].str.len() > 0)]
+            return exploded
+        except Exception:
+            return df2
+    return df2
+
+# ==============================
+# ✅ NOVO: visão da Tabela (cliente único + Data/Hora + ícones)
+# ==============================
+def _build_table_view_unique_client(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Prepara a Tabela com:
+      - Cliente único por linha (explode por ';')
+      - RecebidoEm separado em Data e Hora
+      - Colunas visuais (📎, 🔔, 👁️)
+    """
+    if df.empty:
+        return df.copy()
+
+    base = df.copy()
+
+    # 1) Garante lista de clientes e "explode"
+    base = _ensure_client_exploded(base)
+    if "cliente_lista" not in base.columns and "cliente" in base.columns:
+        base["cliente_lista"] = base["cliente"].apply(
+            lambda s: [p.strip() for p in str(s).split(";") if p.strip()] if pd.notna(s) else None
+        )
+        try:
+            base = base.explode("cliente_lista", ignore_index=True)
+        except Exception:
+            pass
+
+    # Nome final do cliente para a Tabela
+    base["Cliente"] = base["cliente_lista"].where(base["cliente_lista"].notna(), base.get("cliente"))
+
+    # 2) Separa RecebidoEm em Data e Hora
+    dt = pd.to_datetime(base.get("RecebidoEm"), errors="coerce")
+    base["Data"] = dt.dt.strftime("%d/%m/%Y").fillna("")
+    base["Hora"] = dt.dt.strftime("%H:%M").fillna("")
+
+    # 3) Colunas visuais
+    anexos = base.get("Anexos")
+    if anexos is not None:
+        base["📎"] = anexos.fillna(0).astype(int).apply(lambda n: "📎" if n > 0 else "")
+    else:
+        base["📎"] = ""
+
+    imp = base.get("Importancia")
+    if imp is not None:
+        mapa_imp = {"2": "🔴 Alta", "1": "🟡 Normal", "0": "⚪ Baixa", 2: "🔴 Alta", 1: "🟡 Normal", 0: "⚪ Baixa"}
+        base["🔔"] = base["Importancia"].map(mapa_imp).fillna("")
+    else:
+        base["🔔"] = ""
+
+    if "Lido" in base.columns:
+        base["👁️"] = base["Lido"].apply(lambda v: "✅" if bool(v) else "⏳")
+    else:
+        base["👁️"] = ""
+
+    # 4) Alias para Placa
+    if "placa" in base.columns and "Placa" not in base.columns:
+        base["Placa"] = base["placa"]
+
+    # 5) Ordenação das colunas para leitura profissional
+    prefer = [
+        "Data", "Hora", "Cliente", "tipo", "Placa", "Assunto",
+        "Status_join", "portaria",
+        "📎", "🔔", "👁️",
+        "Anexos", "TamanhoKB", "Remetente",
+        "PastaPath", "Pasta",
+    ]
+    prefer = [c for c in prefer if c in base.columns]
+
+    drop_aux = {"cliente_lista"}  # oculta auxiliar interna
+    others = [c for c in base.columns if c not in (set(prefer) | drop_aux | {"RecebidoEm"})]
+    cols = prefer + others
+
+    df_show = base[cols].copy()
+    return df_show
+
+# ==============================
+# Indicadores (visual + profissional)
+# ==============================
+import plotly.express as px
+
+def _render_indicators_custom(df: pd.DataFrame, dt_col_name: str, cols_for_topn: list[str], topn_default: int = 10):
+    """
+    Indicadores com:
+      - Série temporal (gráfico)
+      - Top Clientes (tratando clientes múltiplos separados por ';')
+      - Outros Top N (Remetente, Tipo, Categoria, Status etc.)
+    Em layout de duas colunas para não ocupar a página inteira.
+    Inclui controles: Top N e Mostrar tabelas.
+    """
+    if df.empty:
+        st.info("Nenhum dado após filtros. Ajuste os filtros para ver indicadores.")
+        return
+
+    st.subheader("📊 Indicadores")
+
+    # Controles globais dos Indicadores
+    ctl1, ctl2, ctl3 = st.columns([1,1,2])
+    topn = ctl1.selectbox("Top N", [5, 10, 15, 20, 30], index=[5,10,15,20,30].index(topn_default))
+    show_tables = ctl2.checkbox("Mostrar tabelas abaixo dos gráficos", value=True)
+    palette = ctl3.selectbox("Tema de cor", ["plotly_white", "plotly", "ggplot2", "seaborn"], index=0)
+
+    # ===== 1) Série temporal =====
+    if dt_col_name in df.columns:
+        try:
+            _dt = pd.to_datetime(df[dt_col_name], errors="coerce")
+            por_dia = _dt.dt.date.value_counts().sort_index()
+            if not por_dia.empty:
+                fig_ts = px.bar(
+                    por_dia, x=por_dia.index, y=por_dia.values,
+                    labels={"x": "Data", "y": "Qtd"},
+                    title="Mensagens por dia",
+                    template=palette,
+                    height=300,
+                )
+                fig_ts.update_layout(margin=dict(l=10, r=10, t=50, b=10))
+                st.plotly_chart(fig_ts, use_container_width=True)
+        except Exception:
+            pass
+
+    # ===== 2) Top Clientes =====
+    col_left, col_right = st.columns(2)
+
+    with col_left:
+        st.markdown("### 👥 Top Clientes")
+        df_clients = _ensure_client_exploded(df)
+
+        if "cliente_lista" in df_clients.columns:
+            vc_clientes = (
+                df_clients["cliente_lista"]
+                .dropna()
+                .astype(str)
+                .str.strip()
+                .value_counts()
+                .head(topn)
+            )
+            if not vc_clientes.empty:
+                ordered = vc_clientes.sort_values(ascending=True)
+                fig_cli = px.bar(
+                    ordered,
+                    x=ordered.values, y=ordered.index, orientation="h",
+                    labels={"x": "Qtd", "y": "Cliente"},
+                    title=f"Top {topn} Clientes",
+                    template=palette, height=420,
+                )
+                fig_cli.update_layout(margin=dict(l=10, r=10, t=50, b=10))
+                st.plotly_chart(fig_cli, use_container_width=True)
+
+                if show_tables:
+                    st.dataframe(
+                        vc_clientes.rename("Qtd").to_frame(),
+                        use_container_width=True,
+                        height=300
+                    )
+            else:
+                st.info("Não há clientes para exibir.")
+        else:
+            st.info("Coluna de clientes não disponível para indicador.")
+
+    # ===== 3) Outros Top N =====
+    with col_right:
+        st.markdown("### 🏆 Outros Top N")
+        ignore_cols = {"cliente", "cliente_lista"}
+        cols_others = [c for c in (cols_for_topn or []) if c in df.columns and c not in ignore_cols]
+
+        if not cols_others:
+            fallback_cols = [c for c in ["Remetente", "tipo", "Categoria", "Status_join", "Pasta", "PastaPath"] if c in df.columns]
+            cols_others = fallback_cols[:3]  # até 3 por padrão
+
+        for col in cols_others[:4]:
+            try:
+                st.markdown(f"**Top {topn} por `{col}`**")
+                if df[col].apply(lambda x: isinstance(x, list)).any():
+                    exploded = df.explode(col)
+                    serie = exploded[col].dropna().astype(str).str.strip().value_counts().head(topn)
+                else:
+                    serie = df[col].dropna().astype(str).str.strip().value_counts().head(topn)
+
+                if serie is None or serie.empty:
+                    st.caption("Sem dados nesta coluna.")
+                    continue
+
+                ordered = serie.sort_values(ascending=True)
+                fig_any = px.bar(
+                    ordered,
+                    x=ordered.values, y=ordered.index, orientation="h",
+                    labels={"x": "Qtd", "y": col},
+                    template=palette, height=260,
+                )
+                fig_any.update_layout(margin=dict(l=10, r=10, t=30, b=10))
+                st.plotly_chart(fig_any, use_container_width=True)
+
+                if show_tables:
+                    st.dataframe(
+                        serie.rename("Qtd").to_frame(),
+                        use_container_width=True,
+                        height=220,
+                    )
+            except Exception as e:
+                st.warning(f"Não foi possível calcular TopN para `{col}`: {e}")
+
+
+# ==============================
+# Cards/KPIs — clientes, veículos e notas
+# ==============================
+def _count_notes(row) -> int:
+    """Conta notas em uma linha (lista em 'nota_fiscal' ou string)."""
+    v = row.get("nota_fiscal")
+    if isinstance(v, list):
+        return len([x for x in v if str(x).strip()])
+    if isinstance(v, str) and v.strip():
+        parts = [p for p in re.split(r"[^\d]+", v) if p.strip()]
+        return len(parts)
+    return 0
+
+def _render_kpis(df: pd.DataFrame):
+    """Renderiza cards de KPIs e tabelas de resumo por cliente, incluindo tipos de operação."""
+    if df.empty:
+        return
+
+    # Preferimos 'cliente_lista' para múltiplos; caso contrário, 'cliente'
+    cliente_col = "cliente_lista" if "cliente_lista" in df.columns else ("cliente" if "cliente" in df.columns else None)
+    tipo_col = "tipo" if "tipo" in df.columns else None
+    placa_col = "placa" if "placa" in df.columns else ("Placa" if "Placa" in df.columns else None)
+
+    _df = df.copy()
+    _df["__notes_count__"] = _df.apply(_count_notes, axis=1)
+
+    # Se for lista, vamos explodir para análises por cliente
+    _df_exploded = None
+    if cliente_col == "cliente_lista":
+        try:
+            _df_exploded = _df.explode("cliente_lista")
+            _df_exploded["cliente_lista"] = _df_exploded["cliente_lista"].astype(str).str.strip()
+        except Exception:
+            _df_exploded = None
+
+    # Clientes únicos
+    if cliente_col == "cliente_lista" and _df_exploded is not None:
+        clientes_unicos = _df_exploded["cliente_lista"].dropna().astype(str).str.strip().nunique()
+    elif cliente_col:
+        clientes_unicos = _df[cliente_col].dropna().astype(str).str.strip().nunique()
+    else:
+        clientes_unicos = 0
+
+    # Placas únicas
+    placas_unicas = _df[placa_col].dropna().nunique() if placa_col else 0
+
+    # Total de notas
+    notas_total = int(_df["__notes_count__"].sum())
+
+    st.markdown('<div class="kpi-wrap">', unsafe_allow_html=True)
+    st.markdown(
+        f"""
+        <div class="kpi-card">
+            <div class="kpi-top"><div class="kpi-ico">👥</div><div class="kpi-title">Clientes (únicos)</div></div>
+            <div class="kpi-val">{clientes_unicos}</div>
+            <div class="kpi-note">Número total de clientes distintos no período.</div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+    st.markdown(
+        f"""
+        <div class="kpi-card">
+            <div class="kpi-top"><div class="kpi-ico">🚚</div><div class="kpi-title">Placas (veículos únicos)</div></div>
+            <div class="kpi-val">{placas_unicas}</div>
+            <div class="kpi-note">Contagem de veículos distintos identificados.</div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+    st.markdown(
+        f"""
+        <div class="kpi-card">
+            <div class="kpi-top"><div class="kpi-ico">🧾</div><div class="kpi-title">Notas (total)</div></div>
+            <div class="kpi-val">{notas_total}</div>
+            <div class="kpi-note">Soma de notas fiscais informadas nos e-mails.</div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+    st.markdown("</div>", unsafe_allow_html=True)
+
+    try:
+        media_placas_por_cliente = (placas_unicas / clientes_unicos) if clientes_unicos else 0
+        media_notas_por_cliente = (notas_total / clientes_unicos) if clientes_unicos else 0
+        st.caption(
+            f"📌 Média de **placas por cliente**: {media_placas_por_cliente:.2f} • "
+            f"Média de **notas por cliente**: {media_notas_por_cliente:.2f}"
+        )
+    except Exception:
+        pass
+
+    with st.expander("📒 Detalhes por cliente (resumo)", expanded=False):
+        # ✅ Operações por cliente e tipo
+        if cliente_col and tipo_col:
+            st.write("**Operações por cliente (contagem por tipo)**")
+            if cliente_col == "cliente_lista" and _df_exploded is not None:
+                operacoes_por_cliente = (
+                    _df_exploded.dropna(subset=["cliente_lista", tipo_col])
+                                .groupby(["cliente_lista", tipo_col])
+                                .size()
+                                .unstack(fill_value=0)
+                                .sort_index()
+                )
+            else:
+                operacoes_por_cliente = (
+                    _df.dropna(subset=[cliente_col, tipo_col])
+                       .groupby([cliente_col, tipo_col])
+                       .size()
+                       .unstack(fill_value=0)
+                       .sort_index()
+                )
+            st.dataframe(operacoes_por_cliente, use_container_width=True)
+
+            # ✅ Gráfico de barras agrupadas
+            st.write("📊 **Gráfico: Operações por cliente e tipo**")
+            try:
+                df_plot = operacoes_por_cliente.reset_index().melt(
+                    id_vars=(["cliente_lista"] if cliente_col == "cliente_lista" else [cliente_col]),
+                    var_name="Tipo", value_name="Quantidade"
+                )
+                x_col = "cliente_lista" if cliente_col == "cliente_lista" else cliente_col
+                fig = px.bar(
+                    df_plot, x=x_col, y="Quantidade", color="Tipo", barmode="group",
+                    title="Operações por Cliente e Tipo", text="Quantidade", template="plotly_white"
+                )
+                fig.update_layout(xaxis_title="Cliente", yaxis_title="Quantidade", legend_title="Tipo", height=460)
+                st.plotly_chart(fig, use_container_width=True)
+            except Exception as e:
+                st.warning(f"Não foi possível gerar o gráfico: {e}")
+        else:
+            st.info("Sem colunas suficientes para resumo de operações por tipo.")
+
+        # ✅ Veículos por cliente
+        if cliente_col and placa_col:
+            if cliente_col == "cliente_lista" and _df_exploded is not None:
+                veic_por_cliente = (
+                    _df_exploded.dropna(subset=["cliente_lista", placa_col])
+                                .groupby("cliente_lista")[placa_col].nunique()
+                                .sort_values(ascending=False)
+                                .rename("Placas_Únicas")
+                                .to_frame()
+                )
+            else:
+                veic_por_cliente = (
+                    _df.dropna(subset=[cliente_col, placa_col])
+                       .groupby(cliente_col)[placa_col].nunique()
+                       .sort_values(ascending=False)
+                       .rename("Placas_Únicas")
+                       .to_frame()
+                )
+            st.write("**Veículos (placas únicas) por cliente — Top 20**")
+            st.dataframe(veic_por_cliente.head(20), use_container_width=True, height=460)
+        else:
+            st.info("Sem colunas de cliente/placa suficientes para o resumo de veículos.")
+
+        # ✅ Notas por cliente
+        if cliente_col:
+            if cliente_col == "cliente_lista" and _df_exploded is not None:
+                notas_por_cliente = (
+                    _df_exploded.groupby("cliente_lista")["__notes_count__"]
+                                .sum()
+                                .sort_values(ascending=False)
+                                .rename("Notas_Total")
+                                .to_frame()
+                )
+            else:
+                notas_por_cliente = (
+                    _df.groupby(cliente_col)["__notes_count__"]
+                       .sum()
+                       .sort_values(ascending=False)
+                       .rename("Notas_Total")
+                       .to_frame()
+                )
+            st.write("**Notas por cliente — Top 20**")
+            st.dataframe(notas_por_cliente.head(20), use_container_width=True, height=460)
+        else:
+            st.info("Sem coluna de cliente para o resumo de notas.")
+
+# ==============================
+# Funções auxiliares — normalização / validação
+# ==============================
+def _strip_accents(s: str) -> str:
+    if not isinstance(s, str):
+        return s
+    return "".join(c for c in unicodedata.normalize("NFD", s) if unicodedata.category(c) != "Mn")
+
+def _html_to_text(html: str) -> str:
+    if not html:
+        return ""
+    text = re.sub(r"(?is)<style.*?>.*?</style>", " ", html)
+    text = re.sub(r"(?is)<script.*?>.*?</script>", " ", text)
+    text = re.sub(r"(?is)<br\s*/?>", "\n", text)
+    text = re.sub(r"(?is)</p>", "\n", text)
+    text = re.sub(r"(?is)<.*?>", " ", text)
+    text = re.sub(r"[ \t]+", " ", text)
+    text = re.sub(r"\s*\n\s*", "\n", text).strip()
+    return text
+
+def _normalize_spaces(s: str) -> str:
+    if not s:
+        return ""
+    s = s.replace("\r", "\n")
+    s = re.sub(r"[ \t]+", " ", s)
+    s = re.sub(r"\n{2,}", "\n", s).strip()
+    return s
+
+def _normalize_person_name(s: str) -> str:
+    """
+    Converte 'Sobrenome, Nome' -> 'Nome Sobrenome'.
+    Mantém como está se não houver vírgula.
+    """
+    if not s:
+        return s
+    s = s.strip()
+    if "," in s:
+        partes = [p.strip() for p in s.split(",")]
+        if len(partes) >= 2:
+            return f"{partes[1]} {partes[0]}".strip()
+    return s
+
+# ====== Utilitário robusto para extrair e validar PLACA ======
+def _clean_plate(p: str) -> str:
+    """Normaliza a placa: remove espaços/hífens e deixa maiúscula."""
+    return re.sub(r"[^A-Za-z0-9]", "", (p or "")).upper()
+
+def _is_valid_plate(p: str) -> bool:
+    """
+    Valida placa nos formatos:
+      - antigo: AAA1234
+      - Mercosul: AAA1B23
+    """
+    if not p:
+        return False
+    p = _clean_plate(p)
+    if len(p) != 7:
+        return False
+    if re.fullmatch(r"[A-Z]{3}[0-9]{4}", p):  # antigo
+        return True
+    if re.fullmatch(r"[A-Z]{3}[0-9][A-Z][0-9]{2}", p):  # Mercosul
+        return True
+    return False
+
+def _format_plate(p: str) -> str:
+    """Formata visualmente: antigo → AAA-1234; Mercosul permanece sem hífen."""
+    p0 = _clean_plate(p)
+    if re.fullmatch(r"[A-Z]{3}[0-9]{4}", p0):
+        return f"{p0[:3]}-{p0[3:]}"
+    return p0
+
+def _extract_plate_from_text(text: str) -> str | None:
+    """Extrai placa do texto com robustez."""
+    if not text:
+        return None
+
+    t = _strip_accents(text).upper()
+    t = re.sub(r"PLACA\s+DE\s+AUTORIZA\w+", " ", t)
+
+    # 1) Por linhas contendo 'PLACA' e NÃO 'AUTORIZA'
+    for ln in [x.strip() for x in t.splitlines() if x.strip()]:
+        if "PLACA" in ln and "AUTORIZA" not in ln:
+            for m in re.finditer(r"\b[A-Z0-9]{7}\b", ln):
+                cand = m.group(0)
+                if _is_valid_plate(cand):
+                    return _format_plate(cand)
+            m_old = re.search(r"\b([A-Z]{3})[ -]?([0-9]{4})\b", ln)
+            if m_old:
+                cand = (m_old.group(1) + m_old.group(2)).upper()
+                if _is_valid_plate(cand):
+                    return _format_plate(cand)
+            m_new = re.search(r"\b([A-Z]{3})[ -]?([0-9])[ -]?([A-Z])[ -]?([0-9]{2})\b", ln)
+            if m_new:
+                cand = (m_new.group(1) + m_new.group(2) + m_new.group(3) + m_new.group(4)).upper()
+                if _is_valid_plate(cand):
+                    return _format_plate(cand)
+
+    # 2) Fallbacks
+    for m in re.finditer(r"\b([A-Z]{3})[ -]?([0-9]{4})\b", t):
+        cand = (m.group(1) + m.group(2)).upper()
+        if _is_valid_plate(cand):
+            return _format_plate(cand)
+    for m in re.finditer(r"\b([A-Z]{3})[ -]?([0-9])[ -]?([A-Z])[ -]?([0-9]{2})\b", t):
+        cand = (m.group(1) + m.group(2) + m.group(3) + m.group(4)).upper()
+        if _is_valid_plate(cand):
+            return _format_plate(cand)
+
+    return None
+
+# ====== Sanitização de CLIENTE ======
+def _sanitize_cliente(s: str | None) -> str | None:
+    if not s:
+        return s
+    s2 = re.sub(r"\s*:\s*", " ", s)
+    s2 = re.sub(r"\s+", " ", s2).strip(" -:|")
+    return s2.strip()
+
+def _split_semicolon(s: str | None) -> list[str] | None:
+    if not s:
+        return None
+    parts = [p.strip(" -:|").strip() for p in s.split(";")]
+    parts = [p for p in parts if p]
+    return parts or None
+
+def _cliente_to_list(cliente_raw: str | None) -> list[str] | None:
+    s = _sanitize_cliente(cliente_raw)
+    return _split_semicolon(s)
+
+# ==============================
+# Parser do corpo do e‑mail (modelo padrão)
+# ==============================
+def _parse_email_body(raw_text: str) -> dict:
+    """Extrai campos estruturados do e‑mail padrão."""
+    text = _normalize_spaces(raw_text or "")
+    text_acc = _strip_accents(text)
+
+    def get(pat, acc=False, flags=re.IGNORECASE | re.MULTILINE):
+        return (re.search(pat, text_acc if acc else text, flags) or re.search(pat, text, flags))
+
+    data = {}
+    m = get(r"\bItem\s+ID\s*([0-9]+)")
+    data["item_id"] = m.group(1) if m else None
+
+    m = get(r"Portaria\s*-\s*([^\n]+)")
+    data["portaria"] = (m.group(1).strip() if m else None)
+
+    m = get(r"\b([0-9]{2}/[0-9]{2}/[0-9]{4})\s+([0-9]{2}:[0-9]{2})\b")
+    data["timestamp_corpo_data"] = m.group(1) if m else None
+    data["timestamp_corpo_hora"] = m.group(2) if m else None
+
+    m = get(r"NOTA\s+FISCAL\s*([0-9/\- ]+)")
+    nf = None
+    if m:
+        nf = re.sub(r"\s+", "", m.group(1))
+        nf = [p for p in nf.split("/") if p]
+    data["nota_fiscal"] = nf
+
+    m = get(r"TIPO\s*([A-ZÁÂÃÉÍÓÚÇ ]+)")
+    data["tipo"] = (m.group(1).strip() if m else None)
+
+    m = get(r"N[º°]?\s*DA\s*PLACA\s*DE\s*AUTORIZA[ÇC]AO\s*([0-9]+)", acc=True)
+    data["num_placa_autorizacao"] = m.group(1) if m else None
+
+    # CLIENTE — ":" opcional
+    m = get(r"CLIENTE\s*:?\s*([^\n]+)")
+    cliente_raw = (m.group(1).strip() if m else None)
+    data["cliente"] = _sanitize_cliente(cliente_raw)
+    data["cliente_lista"] = _cliente_to_list(cliente_raw)
+
+    # STATUS — ":" opcional; separa por múltiplos espaços/tab
+    m = get(r"STATUS\s*:?\s*([^\n]+)")
+    status_raw = m.group(1).strip() if m else None
+    data["status_lista"] = [p.strip() for p in re.split(r"\s{2,}|\t", status_raw) if p.strip()] if status_raw else None
+
+    # Liberações (ENTRADA/SAÍDA)
+    m = get(r"LIBERA[ÇC][AÃ]O\s*DE\s*ENTRADA\s*([^\n]*)", acc=True)
+    liber_entr = (m.group(1).strip() or None) if m else None
+    data["liberacao_entrada"] = liber_entr
+    data["liberacao_entrada_responsavel"] = _normalize_person_name(liber_entr) if liber_entr else None
+    data["liberacao_entrada_flag"] = bool(liber_entr)
+
+    m = get(r"LIBERA[ÇC][AÃ]O\s*DE\s*SA[IÍ]DA\s*([^\n]*)", acc=True)
+    liber_saida = (m.group(1).strip() or None) if m else None
+    data["liberacao_saida"] = liber_saida
+    data["liberacao_saida_responsavel"] = _normalize_person_name(liber_saida) if liber_saida else None
+    data["liberacao_saida_flag"] = bool(liber_saida)
+
+    m = get(r"RG\s*ou\s*CPF\s*do\s*MOTORISTA\s*([0-9.\-]+)")
+    data["rg_cpf_motorista"] = m.group(1) if m else None
+
+    # Placa do veículo
+    data["placa"] = _extract_plate_from_text(text)
+
+    # Horários
+    m = get(r"HR\s*ENTRADA\s*:?\s*([0-9]{2}:[0-9]{2})")
+    data["hr_entrada"] = m.group(1) if m else None
+
+    m = get(r"HR\s*SA[IÍ]DA\s*:?\s*([0-9]{2}:[0-9]{2})", acc=True)
+    data["hr_saida"] = m.group(1) if m else None
+    edit_saida = get(r"HR\s*SA[IÍ]DA.*?\bEditado\b", acc=True, flags=re.IGNORECASE | re.DOTALL)
+    data["hr_saida_editado"] = bool(edit_saida)
+
+    m = get(r"DATA\s*DA\s*OPERA[ÇC][AÃ]O\s*([0-9]{2}/[0-9]{2}/[0-9]{4})", acc=True)
+    data["data_operacao"] = m.group(1) if m else None
+
+    m = get(r"Palavras[- ]chave\s*Corporativas\s*([^\n]*)", acc=True)
+    data["palavras_chave"] = (m.group(1).strip() or None) if m else None
+
+    m = get(r"AGENDAMENTO\s*(SIM|N[ÃA]O)", acc=True)
+    agend = m.group(1).upper() if m else None
+    data["agendamento"] = {"SIM": True, "NAO": False, "NÃO": False}.get(agend, None)
+
+    data["status_editado"] = any("editado" in p.lower() for p in (data["status_lista"] or []))
+    data["Status_join"] = " | ".join(data["status_lista"]) if isinstance(data.get("status_lista"), list) else (data.get("status_lista") or "")
+    return data
+
+# ==============================
+# Outlook Desktop — listagem / leitura
+# ==============================
+def _list_inbox_paths(ns) -> list[str]:
+    """Inbox da caixa padrão (para retrocompatibilidade)."""
+    paths = ["Inbox"]
+    try:
+        olFolderInbox = 6
+        inbox = ns.GetDefaultFolder(olFolderInbox)
+    except Exception:
+        return []
+
+    def _walk(folder, prefix="Inbox"):
+        try:
+            for i in range(1, folder.Folders.Count + 1):
+                f = folder.Folders.Item(i)
+                full_path = prefix + "\\" + f.Name
+                paths.append(full_path)
+                _walk(f, full_path)
+        except Exception:
+            pass
+
+    _walk(inbox, "Inbox")
+    return paths
+
+def _list_all_inbox_paths(ns) -> list[str]:
+    """Lista caminhos de Inbox para TODAS as stores (caixas), ex.: 'Minha Caixa\\Inbox\\Sub'."""
+    paths: list[str] = []
+    olFolderInbox = 6
+    try:
+        for i in range(1, ns.Folders.Count + 1):
+            store = ns.Folders.Item(i)
+            root_name = str(store.Name).strip()
+            try:
+                inbox = store.GetDefaultFolder(olFolderInbox)
+            except Exception:
+                continue
+            inbox_display = str(inbox.Name).strip()
+            root_prefix = f"{root_name}\\{inbox_display}"
+            paths.append(root_prefix)
+
+            def _walk(folder, prefix):
+                try:
+                    for j in range(1, folder.Folders.Count + 1):
+                        f2 = folder.Folders.Item(j)
+                        full_path = prefix + "\\" + f2.Name
+                        paths.append(full_path)
+                        _walk(f2, full_path)
+                except Exception:
+                    pass
+
+            _walk(inbox, root_prefix)
+    except Exception:
+        pass
+    return sorted(set(paths))
+
+def _get_folder_by_path_any_store(ns, path: str):
+    """
+    Resolve caminho de pasta começando por:
+      - 'Inbox\\...' (ou nome local, ex.: 'Caixa de Entrada\\...')
+      - 'Sent Items\\...' (ou nome local, ex.: 'Itens Enviados\\...')
+      - 'NomeDaStore\\Inbox\\...' OU 'NomeDaStore\\<NomeLocalInbox>\\...'
+      - 'NomeDaStore\\Sent Items\\...' OU 'NomeDaStore\\<NomeLocalSent>\\...'
+    Faz match case-insensitive nas subpastas.
+    """
+    OL_INBOX = 6
+    OL_SENT = 5
+
+    p = (path or "").strip().replace("/", "\\")
+    parts = [x for x in p.split("\\") if x]
+    if not parts:
+        raise RuntimeError("Caminho da pasta vazio. Ex.: Inbox\\Financeiro, Sent Items\\Faturamento ou Minha Caixa\\Inbox\\Operacional")
+
+    # Nomes locais (ex.: PT-BR)
+    try:
+        inbox_local = ns.GetDefaultFolder(OL_INBOX).Name
+    except Exception:
+        inbox_local = "Inbox"
+    try:
+        sent_local = ns.GetDefaultFolder(OL_SENT).Name
+    except Exception:
+        sent_local = "Sent Items"
+
+    inbox_names = {"inbox", str(inbox_local).strip().lower()}
+    sent_names = {"sent items", str(sent_local).strip().lower()}
+
+    def _descend_from(root_folder, segs):
+        folder = root_folder
+        for seg in segs:
+            target = seg.strip().lower()
+            found = None
+            for i in range(1, folder.Folders.Count + 1):
+                cand = folder.Folders.Item(i)
+                if str(cand.Name).strip().lower() == target:
+                    found = cand
+                    break
+            if not found:
+                raise RuntimeError(f"Subpasta não encontrada: '{seg}' em '{folder.Name}'")
+            folder = found
+        return folder
+
+    # 1) Tenta como 'Store\\(Inbox|Sent Items)\\...'
+    if len(parts) >= 2:
+        store_name_candidate = parts[0].strip().lower()
+        for i in range(1, ns.Folders.Count + 1):
+            store = ns.Folders.Item(i)
+            if str(store.Name).strip().lower() == store_name_candidate:
+                first_seg = parts[1].strip().lower()
+                if first_seg in inbox_names:
+                    root = store.GetDefaultFolder(OL_INBOX)
+                    return _descend_from(root, parts[2:])
+                if first_seg in sent_names:
+                    root = store.GetDefaultFolder(OL_SENT)
+                    return _descend_from(root, parts[2:])
+                raise RuntimeError(
+                    f"Segundo segmento deve ser 'Inbox'/'{inbox_local}' ou 'Sent Items'/'{sent_local}' para a store '{store.Name}'."
+                )
+
+    # 2) Caso contrário, usa a store padrão (Inbox ou Sent Items conforme o primeiro segmento)
+    first = parts[0].strip().lower()
+    if first in inbox_names:
+        root = ns.GetDefaultFolder(OL_INBOX)
+        return _descend_from(root, parts[1:])
+    if first in sent_names:
+        root = ns.GetDefaultFolder(OL_SENT)
+        return _descend_from(root, parts[1:])
+
+    raise RuntimeError(
+        f"O caminho deve começar por 'Inbox' (ou '{inbox_local}') ou 'Sent Items' (ou '{sent_local}'), "
+        f"ou por 'NomeDaStore\\Inbox' / 'NomeDaStore\\Sent Items'."
+    )
+
+def _read_folder_dataframe(folder, path: str, dias: int, filtro_remetente: str, extrair_campos: bool) -> pd.DataFrame:
+    """
+    Lê e-mails de uma pasta específica e retorna DataFrame.
+    ✅ Fallback: se Restrict retornar 0 itens, volta para iteração completa + filtro por data.
+    """
+    items = folder.Items
+    items.Sort("[ReceivedTime]", True)  # decrescente
+    cutoff = datetime.now() - timedelta(days=dias)
+
+    iter_items = items
+    restricted_ok = False
+    restricted_count = None
+    try:
+        # Formato recomendado pelo Outlook MAPI: US locale "mm/dd/yyyy hh:mm AM/PM"
+        dt_from = cutoff.strftime("%m/%d/%Y %I:%M %p")
+        iter_items = items.Restrict(f"[ReceivedTime] >= '{dt_from}'")
+        restricted_ok = True
+        try:
+            restricted_count = iter_items.Count
+        except Exception:
+            restricted_count = None
+    except Exception:
+        restricted_ok = False
+
+    # ✅ Se Restrict "funcionou" mas não retornou nada, aplica fallback
+    if restricted_ok and (restricted_count is None or restricted_count == 0):
+        iter_items = items
+        restricted_ok = False
+
+    rows = []
+    total_lidos = 0
+    for mail in iter_items:
+        total_lidos += 1
+        try:
+            if getattr(mail, "Class", None) != 43:  # 43 = MailItem
+                continue
+
+            # Filtro manual de data quando Restrict não foi usado
+            if not restricted_ok:
+                try:
+                    if getattr(mail, "ReceivedTime", None) and mail.ReceivedTime < cutoff:
+                        continue
+                except Exception:
+                    pass
+
+            try:
+                sender = mail.SenderEmailAddress or mail.Sender.Name
+            except Exception:
+                sender = getattr(mail, "SenderName", None)
+
+            if filtro_remetente and sender:
+                if filtro_remetente.lower() not in str(sender).lower():
+                    continue
+
+            base = {
+                "Pasta": folder.Name,
+                "PastaPath": path,
+                "Assunto": mail.Subject,
+                "Remetente": sender,
+                "RecebidoEm": mail.ReceivedTime.strftime("%Y-%m-%d %H:%M"),
+                "Anexos": mail.Attachments.Count if hasattr(mail, "Attachments") else 0,
+                "TamanhoKB": round(mail.Size / 1024, 1) if hasattr(mail, "Size") else None,
+                "Importancia": str(getattr(mail, "Importance", "")),
+                "Categoria": getattr(mail, "Categories", "") or "",
+                "Lido": bool(getattr(mail, "UnRead", False) == False),
+            }
+
+            if extrair_campos:
+                raw_body = ""
+                try:
+                    raw_body = mail.Body or ""
+                except Exception:
+                    raw_body = ""
+                if not raw_body:
+                    try:
+                        raw_body = _html_to_text(mail.HTMLBody)
+                    except Exception:
+                        raw_body = ""
+
+                parsed = _parse_email_body(raw_body)
+                base.update(parsed)
+
+                try:
+                    base["__corpo__"] = _strip_accents(raw_body)[:800]
+                except Exception:
+                    base["__corpo__"] = ""
+
+            rows.append(base)
+        except Exception as e:
+            rows.append({"Pasta": folder.Name, "PastaPath": path, "Assunto": f"[ERRO] {e}"})
+
+    df = pd.DataFrame(rows)
+    with st.expander(f"🔎 Diagnóstico • {path}", expanded=False):
+        st.caption(
+            f"Itens enumerados: **{total_lidos}** "
+            f"| Restrict aplicado: **{restricted_ok}** "
+            f"{'| Restrict.Count=' + str(restricted_count) if restricted_count is not None else ''} "
+            f"| Registros DF: **{df.shape[0]}**"
+        )
+    return df
+
+def gerar_relatorio_outlook_desktop_multi(
+    pastas: list[str],
+    dias: int,
+    filtro_remetente: str = "",
+    extrair_campos: bool = True
+) -> pd.DataFrame:
+    """Inicializa COM, conecta ao Outlook, lê múltiplas pastas (todas as stores) e finaliza COM."""
+    try:
+        import win32com.client
+        pythoncom.CoInitialize()
+        ns = win32com.client.Dispatch("Outlook.Application").GetNamespace("MAPI")
+    except Exception as e:
+        st.error(f"Falha ao conectar ao Outlook/pywin32: {e}")
+        return pd.DataFrame()
+
+    frames = []
+    try:
+        for path in pastas:
+            try:
+                folder = _get_folder_by_path_any_store(ns, path)
+                df = _read_folder_dataframe(folder, path, dias, filtro_remetente, extrair_campos)
+                frames.append(df)
+            except Exception as e:
+                st.warning(f"Não foi possível ler a pasta '{path}': {e}")
+
+        return pd.concat(frames, ignore_index=True) if frames else pd.DataFrame()
+    finally:
+        try:
+            pythoncom.CoUninitialize()
+        except Exception:
+            pass
+
+# ==============================
+# Cache / refresh control
+# ==============================
+@st.cache_data(show_spinner=False, ttl=60)
+def _cache_outlook_df(pastas: tuple, dias: int, filtro_remetente: str, extrair_campos: bool, _v: int = 1) -> pd.DataFrame:
+    """Cache com TTL para reduzir leituras do Outlook."""
+    return gerar_relatorio_outlook_desktop_multi(list(pastas), dias, filtro_remetente=filtro_remetente, extrair_campos=extrair_campos)
+
+def _read_outlook_fresh(pastas: list[str], dias: int, filtro_remetente: str, extrair_campos: bool) -> pd.DataFrame:
+    """Leitura direta, sem cache (para 'Atualizar agora')."""
+    return gerar_relatorio_outlook_desktop_multi(pastas, dias, filtro_remetente=filtro_remetente, extrair_campos=extrair_campos)
+
+# ==============================
+# Filtros dinâmicos (persistentes) + aplicação manual
+# ==============================
+def _sanitize_default(options: list[str], default_list: list[str]) -> list[str]:
+    if not options or not default_list:
+        return []
+    opts_set = set(options)
+    return [v for v in default_list if v in opts_set]
+
+def _build_dynamic_filters(df: pd.DataFrame):
+    """
+    Constrói UI de filtros e retorna (df_filtrado, cols_topn).
+    """
+    if df.empty:
+        return df, []
+
+    df_f = df.copy()
+    try:
+        df_f["RecebidoEm_dt"] = pd.to_datetime(df_f.get("RecebidoEm"), errors="coerce")
+    except Exception:
+        df_f["RecebidoEm_dt"] = pd.NaT
+
+    total_inicial = len(df_f)
+
+    state_keys = {
+        "f_dt_ini": "flt_dt_ini",
+        "f_dt_fim": "flt_dt_fim",
+        "f_lido": "flt_lido",
+        "f_status": "flt_status",
+        "f_saida_flag": "flt_saida_flag",
+        "f_entrada_flag": "flt_entrada_flag",
+        "f_anexos_equal": "flt_anexos_equal",
+        "f_anexos_apply_equal": "flt_anexos_apply_equal",
+        "f_tamanho_equal": "flt_tamanho_equal",
+        "f_tamanho_apply_equal": "flt_tamanho_apply_equal",
+        "f_assunto": "flt_assunto",
+        "f_cols_topn": "flt_cols_topn",
+        "f_pasta": "flt_pasta",
+        "f_pasta_path": "flt_pasta_path",
+        "f_portaria": "flt_portaria",
+        "f_cliente": "flt_cliente",
+        "f_tipo": "flt_tipo",
+        "f_placa": "flt_placa",
+        "f_importancia": "flt_importancia",
+        "f_categoria": "flt_categoria",
+        "f_resp_saida": "flt_resp_saida",
+        "f_resp_entrada": "flt_resp_entrada",
+    }
+    for k in state_keys.values():
+        st.session_state.setdefault(k, None)
+
+    with st.expander("🔎 Filtros do relatório (por colunas retornadas)", expanded=True):
+        with st.form("form_filtros_outlook"):
+            # Período
+            min_dt = df_f["RecebidoEm_dt"].min()
+            max_dt = df_f["RecebidoEm_dt"].max()
+            if pd.notna(min_dt) and pd.notna(max_dt):
+                col_d1, col_d2 = st.columns(2)
+                dt_ini = col_d1.date_input("Data inicial (RecebidoEm)", value=st.session_state[state_keys["f_dt_ini"]] or min_dt.date(), key="f_dt_ini_widget")
+                dt_fim = col_d2.date_input("Data final (RecebidoEm)", value=st.session_state[state_keys["f_dt_fim"]] or max_dt.date(), key="f_dt_fim_widget")
+            else:
+                dt_ini, dt_fim = None, None
+
+            def _multi_select(col_name, label, state_key):
+                if col_name in df_f.columns:
+                    options = sorted([v for v in df_f[col_name].dropna().astype(str).unique() if v != ""])
+                    default_raw = st.session_state[state_keys[state_key]] or []
+                    default = _sanitize_default(options, default_raw)
+                    sel = st.multiselect(label, options=options, default=default, key=f"{state_key}_widget")
+                    st.session_state[state_keys[state_key]] = sel
+
+            # ✅ Pasta (caminho completo) — preferido
+            _multi_select("PastaPath", "Pasta (caminho completo)", "f_pasta_path")
+            # Opcional — nome curto
+            _multi_select("Pasta", "Pasta (apenas nome)", "f_pasta")
+
+            _multi_select("portaria", "Portaria", "f_portaria")
+
+            # Clientes (múltiplos)
+            if "cliente_lista" in df_f.columns:
+                clientes_opts = sorted({
+                    c.strip() for lst in df_f["cliente_lista"]
+                    if isinstance(lst, list) for c in lst if c and str(c).strip()
+                })
+                default_raw = st.session_state[state_keys["f_cliente"]] or []
+                default = _sanitize_default(clientes_opts, default_raw)
+                cliente_sel = st.multiselect("Cliente", options=clientes_opts, default=default, key="f_cliente_widget")
+                st.session_state[state_keys["f_cliente"]] = cliente_sel
+            else:
+                _multi_select("cliente", "Cliente", "f_cliente")
+
+            _multi_select("tipo", "Tipo", "f_tipo")
+            _multi_select("placa", "Placa (veículo)", "f_placa")
+            _multi_select("Importancia", "Importância (0=baixa,1=normal,2=alta)", "f_importancia")
+            _multi_select("Categoria", "Categoria", "f_categoria")
+            _multi_select("liberacao_saida_responsavel", "Responsável (Liberação de Saída)", "f_resp_saida")
+            _multi_select("liberacao_entrada_responsavel", "Responsável (Liberação de Entrada)", "f_resp_entrada")
+
+            # Lido?
+            if "Lido" in df_f.columns:
+                options_lido = ["True", "False"]
+                default_raw = st.session_state[state_keys["f_lido"]] or []
+                default_lido = _sanitize_default(options_lido, default_raw)
+                lido_sel = st.multiselect("Lido?", options=options_lido, default=default_lido, key="f_lido_widget")
+                st.session_state[state_keys["f_lido"]] = lido_sel
+
+            # Status
+            if "status_lista" in df_f.columns:
+                all_status = sorted(set(s for v in df_f["status_lista"] if isinstance(v, list) for s in v))
+                default_raw = st.session_state[state_keys["f_status"]] or []
+                default_status = _sanitize_default(all_status, default_raw)
+                status_sel = st.multiselect("Status (qualquer dos selecionados)", options=all_status, default=default_status, key="f_status_widget")
+                st.session_state[state_keys["f_status"]] = status_sel
+
+            # Flags
+            if "liberacao_saida_flag" in df_f.columns:
+                opt_saida = st.selectbox("Teve Liberação de Saída?", ["(todas)", "Sim", "Não"],
+                                         index=(0 if st.session_state[state_keys["f_saida_flag"]] is None else ["(todas)", "Sim", "Não"].index(st.session_state[state_keys["f_saida_flag"]])),
+                                         key="f_saida_flag_widget")
+                st.session_state[state_keys["f_saida_flag"]] = opt_saida
+            if "liberacao_entrada_flag" in df_f.columns:
+                opt_entr = st.selectbox("Teve Liberação de Entrada?", ["(todas)", "Sim", "Não"],
+                                        index=(0 if st.session_state[state_keys["f_entrada_flag"]] is None else ["(todas)", "Sim", "Não"].index(st.session_state[state_keys["f_entrada_flag"]])),
+                                        key="f_entrada_flag_widget")
+                st.session_state[state_keys["f_entrada_flag"]] = opt_entr
+
+            # Numéricos
+            col_n1, col_n2 = st.columns(2)
+            if "Anexos" in df_f.columns:
+                col_vals = df_f["Anexos"].dropna()
+                if col_vals.empty:
+                    col_n1.info("Sem valores para **Anexos** nesta seleção.")
+                else:
+                    min_ax = int(col_vals.min()); max_ax = int(col_vals.max())
+                    if min_ax == max_ax:
+                        col_n1.info(f"Todos os registros têm **{min_ax}** anexos.")
+                        eq_val = col_n1.number_input("Filtrar por Anexos = (opcional)", min_value=min_ax, max_value=max_ax,
+                                                     value=st.session_state[state_keys["f_anexos_equal"]] or min_ax, step=1, key="f_anexos_equal_widget")
+                        apply_eq = col_n1.checkbox("Aplicar igualdade de Anexos", value=bool(st.session_state[state_keys["f_anexos_apply_equal"]]), key="f_anexos_apply_equal_widget")
+                        st.session_state[state_keys["f_anexos_equal"]] = eq_val
+                        st.session_state[state_keys["f_anexos_apply_equal"]] = apply_eq
+                    else:
+                        rng_ax = col_n1.slider("Anexos (intervalo)", min_value=min_ax, max_value=max_ax,
+                                               value=st.session_state.get("__rng_anexos__", (min_ax, max_ax)), key="__rng_anexos__widget")
+                        st.session_state["__rng_anexos__"] = rng_ax
+
+            if "TamanhoKB" in df_f.columns:
+                col_vals = df_f["TamanhoKB"].dropna()
+                if col_vals.empty:
+                    col_n2.info("Sem valores para **TamanhoKB** nesta seleção.")
+                else:
+                    min_sz = float(col_vals.min()); max_sz = float(col_vals.max())
+                    if abs(min_sz - max_sz) < 1e-9:
+                        col_n2.info(f"Todos os registros têm **{min_sz:.1f} KB**.")
+                        eq_sz = col_n2.number_input("Filtrar por TamanhoKB = (opcional)", min_value=float(min_sz), max_value=float(max_sz),
+                                                    value=st.session_state[state_keys["f_tamanho_equal"]] or float(min_sz), step=0.1, format="%.1f", key="f_tamanho_equal_widget")
+                        apply_sz = col_n2.checkbox("Aplicar igualdade de TamanhoKB", value=bool(st.session_state[state_keys["f_tamanho_apply_equal"]]), key="f_tamanho_apply_equal_widget")
+                        st.session_state[state_keys["f_tamanho_equal"]] = eq_sz
+                        st.session_state[state_keys["f_tamanho_apply_equal"]] = apply_sz
+                    else:
+                        rng_sz = col_n2.slider("Tamanho (KB)", min_value=float(min_sz), max_value=float(max_sz),
+                                               value=st.session_state.get("__rng_tamanho__", (float(min_sz), float(max_sz))), key="__rng_tamanho__widget")
+                        st.session_state["__rng_tamanho__"] = rng_sz
+
+            # Texto — Assunto contém
+            txt_default = st.session_state[state_keys["f_assunto"]] or ""
+            txt = st.text_input("Assunto contém (opcional)", value=txt_default, key="f_assunto_widget")
+            st.session_state[state_keys["f_assunto"]] = txt
+
+            # Indicadores — Top N
+            possiveis_cols = [c for c in ["Pasta", "PastaPath", "portaria", "cliente", "cliente_lista", "tipo", "placa",
+                                          "Importancia", "Categoria", "Remetente", "Status_join",
+                                          "liberacao_saida_responsavel", "liberacao_entrada_responsavel"] if c in df_f.columns]
+            desired_default = st.session_state[state_keys["f_cols_topn"]] or ["cliente", "Status_join"]
+            default_cols = _sanitize_default(possiveis_cols, desired_default)
+            cols_for_topn = st.multiselect("Colunas para indicadores (Top N)", options=possiveis_cols, default=default_cols, key="f_cols_topn_widget")
+            st.session_state[state_keys["f_cols_topn"]] = cols_for_topn
+
+            # Botões
+            col_b1, col_b2 = st.columns(2)
+            aplicar = col_b1.form_submit_button("✅ Aplicar filtros")
+            limpar = col_b2.form_submit_button("🧹 Limpar filtros")
+
+        if limpar:
+            for k in state_keys.values():
+                st.session_state[k] = None
+            st.session_state.pop("__rng_anexos__", None)
+            st.session_state.pop("__rng_tamanho__", None)
+            st.info("Filtros limpos.")
+            return df, []
+
+        if aplicar:
+            # período
+            if pd.notna(df_f["RecebidoEm_dt"]).any() and dt_ini and dt_fim:
+                mask_dt = (df_f["RecebidoEm_dt"].dt.date >= dt_ini) & (df_f["RecebidoEm_dt"].dt.date <= dt_fim)
+                df_f = df_f[mask_dt]
+
+            def _apply_multi(col_name, session_key):
+                sel = st.session_state.get(session_key)
+                nonlocal df_f
+                if sel and col_name in df_f.columns:
+                    df_f = df_f[df_f[col_name].astype(str).isin(sel)]
+
+            # ✅ aplica pelo caminho completo (preciso)
+            _apply_multi("PastaPath", state_keys["f_pasta_path"])
+            # (opcional) nome curto
+            _apply_multi("Pasta", state_keys["f_pasta"])
+            _apply_multi("portaria", state_keys["f_portaria"])
+            _apply_multi("tipo", state_keys["f_tipo"])
+            _apply_multi("placa", state_keys["f_placa"])
+            _apply_multi("Importancia", state_keys["f_importancia"])
+            _apply_multi("Categoria", state_keys["f_categoria"])
+            _apply_multi("liberacao_saida_responsavel", state_keys["f_resp_saida"])
+            _apply_multi("liberacao_entrada_responsavel", state_keys["f_resp_entrada"])
+
+            # cliente (lista ou string)
+            cliente_sel = st.session_state[state_keys["f_cliente"]]
+            if cliente_sel:
+                if "cliente_lista" in df_f.columns:
+                    df_f = df_f[df_f["cliente_lista"].apply(lambda lst: isinstance(lst, list) and any(c in lst for c in cliente_sel))]
+                elif "cliente" in df_f.columns:
+                    df_f = df_f[df_f["cliente"].astype(str).isin(cliente_sel)]
+
+            # lido
+            lido_sel = st.session_state[state_keys["f_lido"]]
+            if lido_sel and "Lido" in df_f.columns:
+                df_f = df_f[df_f["Lido"].astype(str).isin(lido_sel)]
+
+            # status
+            status_sel = st.session_state[state_keys["f_status"]]
+            if status_sel and "status_lista" in df_f.columns:
+                df_f = df_f[df_f["status_lista"].apply(lambda lst: isinstance(lst, list) and any(s in lst for s in status_sel))]
+
+            # flags
+            opt_saida = st.session_state[state_keys["f_saida_flag"]]
+            if opt_saida in ("Sim", "Não") and "liberacao_saida_flag" in df_f.columns:
+                df_f = df_f[df_f["liberacao_saida_flag"] == (opt_saida == "Sim")]
+            opt_entr = st.session_state[state_keys["f_entrada_flag"]]
+            if opt_entr in ("Sim", "Não") and "liberacao_entrada_flag" in df_f.columns:
+                df_f = df_f[df_f["liberacao_entrada_flag"] == (opt_entr == "Sim")]
+
+            # numéricos
+            if st.session_state.get("__rng_anexos__") and "Anexos" in df_f.columns:
+                a0, a1 = st.session_state["__rng_anexos__"]
+                df_f = df_f[(df_f["Anexos"] >= a0) & (df_f["Anexos"] <= a1)]
+            if st.session_state.get("__rng_tamanho__") and "TamanhoKB" in df_f.columns:
+                s0, s1 = st.session_state["__rng_tamanho__"]
+                df_f = df_f[(df_f["TamanhoKB"] >= s0) & (df_f["TamanhoKB"] <= s1)]
+
+            # igualdade
+            if st.session_state.get(state_keys["f_anexos_apply_equal"]) and "Anexos" in df_f.columns:
+                eq_val = st.session_state.get(state_keys["f_anexos_equal"])
+                if eq_val is not None:
+                    df_f = df_f[df_f["Anexos"] == int(eq_val)]
+            if st.session_state.get(state_keys["f_tamanho_apply_equal"]) and "TamanhoKB" in df_f.columns:
+                eq_sz = st.session_state.get(state_keys["f_tamanho_equal"])
+                if eq_sz is not None:
+                    df_f = df_f[df_f["TamanhoKB"].round(1) == round(float(eq_sz), 1)]
+
+            # texto
+            txt = st.session_state[state_keys["f_assunto"]]
+            if txt and "Assunto" in df_f.columns:
+                df_f = df_f[df_f["Assunto"].astype(str).str.contains(txt.strip(), case=False, na=False)]
+
+            cols_for_topn = st.session_state[state_keys["f_cols_topn"]] or []
+
+            total_final = len(df_f)
+            st.caption(f"🧮 **Diagnóstico**: antes dos filtros = {total_inicial} | depois dos filtros = {total_final}")
+
+            return df_f, cols_for_topn
+
+        possiveis_cols_init = [c for c in ["Pasta", "PastaPath", "portaria", "cliente", "cliente_lista", "tipo", "placa",
+                                           "Importancia", "Categoria", "Remetente", "Status_join",
+                                           "liberacao_saida_responsavel", "liberacao_entrada_responsavel"] if c in df_f.columns]
+        desired_default_init = st.session_state[state_keys["f_cols_topn"]] or ["cliente", "Status_join"]
+        default_cols_init = _sanitize_default(possiveis_cols_init, desired_default_init)
+
+        st.caption(f"🧮 **Diagnóstico**: registros disponíveis (sem aplicar filtros) = {total_inicial}")
+        return df, default_cols_init
+
+# ==============================
+# UI — módulo (com buffer/caching + UX simplificada)
+# ==============================
+def main():
+    st.title("📧 Relatório • Outlook Desktop (Estruturado)")
+    st.caption("Escolha a Caixa (Entrada ou Itens Enviados), defina o período e extraia campos estruturados do e‑mail.")
+    st.markdown(_STYLES, unsafe_allow_html=True)
+
+    # Buffer de dados
+    st.session_state.setdefault("__outlook_df__", None)
+    st.session_state.setdefault("__outlook_meta__", None)
+
+    with st.expander("⚙️ Configurações", expanded=True):
+        with st.form("form_execucao_outlook"):
+            col_a, col_b, col_c = st.columns([1, 1, 1])
+            dias = col_a.slider("Período (últimos N dias)", min_value=1, max_value=365, value=30)
+            filtro_remetente = col_b.text_input("Filtrar por remetente (opcional)", value="", placeholder='Ex.: "@fornecedor.com" ou "Fulano"')
+            extrair_campos = col_c.checkbox("Extrair campos do e‑mail (modelo padrão)", value=True)
+
+            # Seletor simplificado
+            tipo_pasta = st.selectbox(
+                "Tipo de Caixa:",
+                ["📥 Caixa de Entrada", "📤 Itens Enviados"],
+                help="Escolha se deseja ler a Caixa de Entrada ou os Itens Enviados."
+            )
+
+            mapa_caminho = {
+                "📥 Caixa de Entrada": "Inbox",
+                "📤 Itens Enviados": "Sent Items"
+            }
+            pasta_base = mapa_caminho[tipo_pasta]
+
+            subpasta_manual = st.text_input(
+                "Subpasta (opcional)",
+                value="",
+                placeholder="Ex.: Financeiro\\Operacional"
+            )
+
+            if subpasta_manual.strip():
+                pasta_final = f"{pasta_base}\\{subpasta_manual.strip()}"
+            else:
+                pasta_final = pasta_base
+
+            pastas_escolhidas = [pasta_final]
+
+            # Botões
+            col_btn1, col_btn2, col_btn3, col_btn4 = st.columns([1, 1, 1, 1])
+            submit_cache = col_btn1.form_submit_button("🔍 Gerar (com cache)")
+            submit_fresh = col_btn2.form_submit_button("⚡ Atualizar agora (sem cache)")
+            submit_clear = col_btn3.form_submit_button("🧹 Limpar cache")
+            submit_test = col_btn4.form_submit_button("🧪 Teste de conexão")
+
+        # Ações pós-submit
+        if submit_clear:
+            try:
+                _cache_outlook_df.clear()
+            except Exception:
+                try:
+                    st.cache_data.clear()
+                except Exception:
+                    pass
+            st.session_state["__outlook_df__"] = None
+            st.session_state["__outlook_meta__"] = None
+            st.success("Cache limpo. Gere novamente os dados.")
+
+        if submit_test:
+            try:
+                import win32com.client
+                pythoncom.CoInitialize()
+                ns = win32com.client.Dispatch("Outlook.Application").GetNamespace("MAPI")
+                stores = ns.Folders.Count
+                inbox_def = ns.GetDefaultFolder(6)
+                sent_def = ns.GetDefaultFolder(5)
+                st.info(f"Stores detectadas: **{stores}** | Inbox padrão: **{inbox_def.Name}** | Sent: **{sent_def.Name}**")
+                if pastas_escolhidas:
+                    for p in pastas_escolhidas:
+                        try:
+                            f = _get_folder_by_path_any_store(ns, p)
+                            st.write(f"📁 {p} → '{f.Name}' itens: {f.Items.Count}")
+                        except Exception as e:
+                            st.warning(f"[Teste] Falha ao acessar '{p}': {e}")
+            except Exception as e:
+                st.error(f"[Teste] Erro ao conectar: {e}")
+            finally:
+                try:
+                    pythoncom.CoUninitialize()
+                except Exception:
+                    pass
+
+        if submit_fresh:
+            if not pastas_escolhidas:
+                st.error("Selecione ao menos uma pasta.")
+            else:
+                with st.spinner("Lendo e-mails do Outlook (sem cache)..."):
+                    df_fresh = _read_outlook_fresh(pastas_escolhidas, dias, filtro_remetente, extrair_campos)
+                st.session_state["__outlook_df__"] = df_fresh
+                st.session_state["__outlook_meta__"] = {
+                    "pastas": list(pastas_escolhidas),
+                    "dias": dias,
+                    "filtro_remetente": filtro_remetente,
+                    "extrair_campos": extrair_campos,
+                    "loaded_at": datetime.now().strftime("%d/%m/%Y %H:%M"),
+                    "source": "fresh"
+                }
+
+        if submit_cache:
+            if not pastas_escolhidas:
+                st.error("Selecione ao menos uma pasta.")
+            else:
+                with st.spinner("Lendo e-mails do Outlook (com cache)..."):
+                    df = _cache_outlook_df(tuple(pastas_escolhidas), dias, filtro_remetente, extrair_campos, _v=1)
+                st.session_state["__outlook_df__"] = df
+                st.session_state["__outlook_meta__"] = {
+                    "pastas": list(pastas_escolhidas),
+                    "dias": dias,
+                    "filtro_remetente": filtro_remetente,
+                    "extrair_campos": extrair_campos,
+                    "loaded_at": datetime.now().strftime("%d/%m/%Y %H:%M"),
+                    "source": "cache"
+                }
+
+    # Usa o buffer se disponível
+    df_src = st.session_state.get("__outlook_df__")
+    meta = st.session_state.get("__outlook_meta__")
+
+    if isinstance(df_src, pd.DataFrame):
+        origem = (meta or {}).get("source", "cache/buffer")
+        if df_src.empty:
+            st.info("Nenhum e-mail encontrado para os parâmetros informados. Use o botão 🧪 Teste de conexão para diagnosticar.")
+            return
+
+        # 🎛️ Barra de Status
+        pastas_lbl = ", ".join(meta.get("pastas") or [])
+        extra_flag = "SIM" if meta.get("extrair_campos") else "NÃO"
+        st.markdown(
+            f"""
+            <div class="status-bar">
+              <div class="status-line">
+                <div class="badge">📂 Pastas: <strong>{pastas_lbl}</strong></div>
+                <div class="badge gray">🗓️ Dias: <strong>{meta.get('dias')}</strong></div>
+                <div class="badge green">🔍 Origem: <strong>{origem}</strong></div>
+                <div class="badge amber">🧩 Extração: <strong>{extra_flag}</strong></div>
+                <div class="badge gray">⏱️ Em: <strong>{meta.get('loaded_at')}</strong></div>
+              </div>
+            </div>
+            """, unsafe_allow_html=True
+        )
+
+        # Filtros dinâmicos
+        df_filtrado, cols_for_topn = _build_dynamic_filters(df_src)
+
+        # Alias visual para colunas úteis
+        if "placa" in df_filtrado.columns and "Placa" not in df_filtrado.columns:
+            df_filtrado = df_filtrado.copy()
+            df_filtrado["Placa"] = df_filtrado["placa"]
+        if "cliente_lista" in df_filtrado.columns and "ClienteLista" not in df_filtrado.columns:
+            df_filtrado = df_filtrado.copy()
+            df_filtrado["ClienteLista"] = df_filtrado["cliente_lista"].apply(lambda lst: "; ".join(lst) if isinstance(lst, list) else "")
+
+        # 🔖 Abas de visualização
+        tab_geral, tab_tabela, tab_kpis, tab_inds, tab_diag = st.tabs(
+            ["🧭 Visão Geral", "📄 Tabela", "📈 KPIs & Gráficos", "🏆 Indicadores (Top N)", "🛠️ Diagnóstico"]
+        )
+
+        with tab_geral:
+            # Mini-resumo
+            qtd = len(df_filtrado)
+            unicos_pastas = df_filtrado["PastaPath"].nunique() if "PastaPath" in df_filtrado.columns else df_filtrado["Pasta"].nunique() if "Pasta" in df_filtrado.columns else None
+            dt_min = pd.to_datetime(df_filtrado["RecebidoEm"], errors="coerce").min()
+            dt_max = pd.to_datetime(df_filtrado["RecebidoEm"], errors="coerce").max()
+            st.write(f"**Registros após filtros:** {qtd} "
+                     + (f"• **Pastas (únicas)**: {unicos_pastas}" if unicos_pastas is not None else "")
+                     + (f" • **Intervalo**: {dt_min.strftime('%d/%m/%Y %H:%M')} → {dt_max.strftime('%d/%m/%Y %H:%M')}" if pd.notna(dt_min) and pd.notna(dt_max) else "")
+                     )
+
+            # Série temporal simples
+            if "RecebidoEm" in df_filtrado.columns:
+                try:
+                    dts = pd.to_datetime(df_filtrado["RecebidoEm"], errors="coerce")
+                    series = dts.dt.date.value_counts().sort_index()
+                    fig = px.bar(series, x=series.index, y=series.values, labels={"x":"Data", "y":"Qtd"},
+                                 title="Mensagens por dia", template="plotly_white")
+                    fig.update_layout(height=360)
+                    st.plotly_chart(fig, use_container_width=True)
+                except Exception:
+                    pass
+
+        # ==============================
+        # ✅ ABA TABELA — Cliente único + Data/Hora + ícones
+        # ==============================
+        with tab_tabela:
+            df_show = _build_table_view_unique_client(df_filtrado)
+
+            # 🎛️ Configurações de colunas (tipos e rótulos)
+            colcfg = {}
+
+            # Data e Hora: tenta usar tipos nativos; fallback para texto
+            if "Data" in df_show.columns:
+                try:
+                    colcfg["Data"] = st.column_config.DateColumn("Data", format="DD/MM/YYYY")
+                except Exception:
+                    colcfg["Data"] = st.column_config.TextColumn("Data")
+
+            if "Hora" in df_show.columns:
+                # Alguns builds do Streamlit não possuem TimeColumn — fallback automático
+                try:
+                    colcfg["Hora"] = st.column_config.TimeColumn("Hora", format="HH:mm")
+                except Exception:
+                    colcfg["Hora"] = st.column_config.TextColumn("Hora")
+
+            if "Cliente" in df_show.columns:
+                colcfg["Cliente"] = st.column_config.TextColumn("Cliente")
+
+            if "Placa" in df_show.columns:
+                colcfg["Placa"] = st.column_config.TextColumn("Placa")
+
+            if "tipo" in df_show.columns:
+                colcfg["tipo"] = st.column_config.TextColumn("Tipo")
+
+            if "Status_join" in df_show.columns:
+                colcfg["Status_join"] = st.column_config.TextColumn("Status")
+
+            if "Anexos" in df_show.columns:
+                colcfg["Anexos"] = st.column_config.NumberColumn("Anexos", format="%d")
+
+            if "TamanhoKB" in df_show.columns:
+                colcfg["TamanhoKB"] = st.column_config.NumberColumn("Tamanho (KB)", format="%.1f")
+
+            if "Remetente" in df_show.columns:
+                colcfg["Remetente"] = st.column_config.TextColumn("Remetente")
+
+            if "PastaPath" in df_show.columns:
+                colcfg["PastaPath"] = st.column_config.TextColumn("Caminho da Pasta")
+
+            if "Pasta" in df_show.columns:
+                colcfg["Pasta"] = st.column_config.TextColumn("Pasta")
+
+            if "portaria" in df_show.columns:
+                colcfg["portaria"] = st.column_config.TextColumn("Portaria")
+
+            # Colunas visuais
+            if "📎" in df_show.columns:
+                colcfg["📎"] = st.column_config.TextColumn("Anexo")
+            if "🔔" in df_show.columns:
+                colcfg["🔔"] = st.column_config.TextColumn("Importância")
+            if "👁️" in df_show.columns:
+                colcfg["👁️"] = st.column_config.TextColumn("Lido")
+
+            st.dataframe(
+                df_show,
+                use_container_width=True,
+                hide_index=True,
+                column_config=colcfg,
+                height=560
+            )
+
+            st.caption("🔎 A Tabela está em visão **por cliente** (uma linha por cliente) e com **Data** e **Hora** separadas.")
+
+        with tab_kpis:
+            _render_kpis(df_filtrado)
+
+        with tab_inds:
+            _render_indicators_custom(df_filtrado, dt_col_name="RecebidoEm", cols_for_topn=cols_for_topn, topn_default=10)
+
+        with tab_diag:
+            st.write("**Colunas disponíveis**:", list(df_src.columns))
+            st.write("**Linhas (antes filtros)**:", len(df_src))
+            st.write("**Linhas (após filtros)**:", len(df_filtrado))
+            if "PastaPath" in df_src.columns:
+                st.write("**Pastas distintas**:", df_src["PastaPath"].nunique())
+            if "__corpo__" in df_src.columns:
+                st.text_area("Amostra de corpo (debug, 1ª linha):", value=str(df_src["__corpo__"].dropna().head(1).values[0]) if df_src["__corpo__"].dropna().any() else "", height=120)
+
+        # ==============================
+        # ✅ Downloads — exporta a mesma visão da Tabela (explodida + Data/Hora)
+        # ==============================
+        base_name = f"relatorio_outlook_desktop_{date.today()}"
+        df_to_export = _build_table_view_unique_client(df_filtrado)
+        _build_downloads(df_to_export, base_name=base_name)
+
+        # Auditoria
+        if _HAS_AUDIT and meta:
+            try:
+                registrar_log(
+                    usuario=st.session_state.get("usuario"),
+                    acao=f"Relatório Outlook (pastas={len(meta['pastas'])}, dias={meta['dias']}, extrair={origem}) — filtros aplicados",
+                    tabela="outlook_relatorio",
+                    registro_id=None
+                )
+            except Exception:
+                pass
+
+    else:
+        st.info("👉 Selecione a caixa (Entrada/Saída), opcionalmente uma subpasta, e clique em **🔍 Gerar (com cache)** ou **⚡ Atualizar agora (sem cache)**. Use **🧪 Teste de conexão** se vier vazio.")
+
+# if __name__ == "__main__":
+#     main()

passenger_wsgi.py

@@ -0,0 +1,13 @@
+import os
+import sys
+
+# Ensure the application root is in the import path
+APP_ROOT = os.path.dirname(os.path.abspath(__file__))
+if APP_ROOT not in sys.path:
+    sys.path.insert(0, APP_ROOT)
+
+# Import the starter that launches Streamlit as a subprocess
+import start_streamlit  # noqa: F401
+
+# Expose a minimal WSGI callable so Passenger is satisfied
+application = start_streamlit.application

quiz.py

@@ -0,0 +1,188 @@
+
+import streamlit as st
+import random
+from banco import SessionLocal
+from models import QuizPontuacao, QuizPergunta, QuizResposta
+from datetime import datetime
+from utils_auditoria import registrar_log
+
+# ==========================
+# CARREGAR PERGUNTAS DO BANCO
+# ==========================
+def carregar_perguntas_do_banco():
+    db = SessionLocal()
+    perguntas = []
+    try:
+        q_perguntas = db.query(QuizPergunta).filter(QuizPergunta.ativo == True).all()
+        for p in q_perguntas:
+            respostas = db.query(QuizResposta).filter(QuizResposta.pergunta_id == p.id).all()
+            if len(respostas) < 3:
+                continue  # garante pelo menos 3 opções
+            opcoes = [r.texto for r in respostas]
+            correta_idx = next((i for i, r in enumerate(respostas) if r.correta), 0)
+            perguntas.append({
+                "pergunta": p.pergunta,
+                "opcoes": opcoes,
+                "resposta": correta_idx
+            })
+    finally:
+        db.close()
+    return perguntas
+
+# ==========================
+# SALVAR PONTUAÇÃO
+# ==========================
+def salvar_pontuacao(usuario, pontos):
+    db = SessionLocal()
+    try:
+        registro = QuizPontuacao(usuario=usuario, pontos=pontos, data=datetime.now())
+        db.add(registro)
+        db.commit()
+        db.refresh(registro)  # garante que registro.id está populado
+        registrar_log(usuario=usuario, acao=f"Finalizou quiz com {pontos} pontos", tabela="quiz_pontuacao", registro_id=registro.id)
+        return registro.id
+    finally:
+        db.close()
+
+# ==========================
+# EXCLUIR PONTUAÇÃO (quando rejogar)
+# ==========================
+def excluir_pontuacao(registro_id):
+    if not registro_id:
+        return
+    db = SessionLocal()
+    try:
+        registro = db.query(QuizPontuacao).filter(QuizPontuacao.id == registro_id).first()
+        if registro:
+            db.delete(registro)
+            db.commit()
+            # (Opcional) registro de auditoria da exclusão, se desejar:
+            # registrar_log(usuario=registro.usuario, acao=f"Excluiu pontuação da tentativa anterior ({registro.pontos} pontos)", tabela="quiz_pontuacao", registro_id=registro_id)
+    finally:
+        db.close()
+
+# ==========================
+# VERIFICAR EXISTÊNCIA DE REGISTRO
+# ==========================
+def registro_existe(registro_id):
+    """Retorna True se o registro de pontuação ainda existe na base."""
+    if not registro_id:
+        return False
+    db = SessionLocal()
+    try:
+        return db.query(QuizPontuacao.id).filter(QuizPontuacao.id == registro_id).first() is not None
+    finally:
+        db.close()
+
+# ==========================
+# FUNÇÃO PRINCIPAL
+# ==========================
+def main():
+    st.title("🧠 Quiz – FPSO | WMS | IFS")
+
+    usuario = st.session_state.get("usuario")
+    if not usuario:
+        st.error("Usuário não identificado.")
+        return
+
+    # Inicialização de estado
+    if "quiz_indice" not in st.session_state:
+        st.session_state.quiz_indice = 0
+    if "quiz_pontos" not in st.session_state:
+        st.session_state.quiz_pontos = 0
+    if "quiz_salvo" not in st.session_state:
+        st.session_state.quiz_salvo = False
+    # Guarda o ID do registro salvo para permitir exclusão ao rejogar
+    if "quiz_registro_id" not in st.session_state:
+        st.session_state.quiz_registro_id = None
+
+    # Carregar perguntas
+    TODAS_PERGUNTAS = carregar_perguntas_do_banco()
+    NUM_PERGUNTAS_RODADA = 2
+    k = min(NUM_PERGUNTAS_RODADA, len(TODAS_PERGUNTAS))
+
+    # Caso não haja perguntas, permitir voltar ao sistema
+    if k == 0:
+        st.warning("⚠️ Nenhuma pergunta ativa disponível. Cadastre perguntas para jogar.")
+        if st.button("⬅️ Voltar ao sistema"):
+            st.session_state.quiz_verificado = True
+            st.session_state.quiz_pendente = False
+            st.rerun()
+        return
+
+    # Sorteio de perguntas
+    if "perguntas_rodada" not in st.session_state:
+        st.session_state.perguntas_rodada = random.sample(TODAS_PERGUNTAS, k=k)
+
+    PERGUNTAS = st.session_state.perguntas_rodada
+    indice = st.session_state.quiz_indice
+
+    # Final do quiz
+    if indice >= len(PERGUNTAS):
+        st.success("🎉 Quiz finalizado!")
+        st.metric("🏆 Pontuação", st.session_state.quiz_pontos)
+
+        # --- Novo: Se a app acha que já salvou, mas o ranking foi resetado, permita salvar de novo ---
+        if st.session_state.quiz_salvo and st.session_state.quiz_registro_id and not registro_existe(st.session_state.quiz_registro_id):
+            # O ranking foi resetado e o registro sumiu => reabrir para salvar novamente
+            st.info("ℹ️ O ranking foi resetado. Você pode registrar esta pontuação novamente.")
+            st.session_state.quiz_salvo = False
+            st.session_state.quiz_registro_id = None
+
+        # Salvar a pontuação apenas uma vez e guardar o ID para potencial exclusão ao rejogar
+        if not st.session_state.quiz_salvo:
+            registro_id = salvar_pontuacao(usuario, st.session_state.quiz_pontos)
+            st.session_state.quiz_salvo = True
+            st.session_state.quiz_registro_id = registro_id
+            st.success("✅ Pontuação registrada com sucesso.")
+
+        col1, col2 = st.columns(2)
+        if col1.button("🔄 Jogar novamente"):
+            # Ao rejogar: remover a pontuação anterior do ranking (não contar tentativa anterior)
+            if registro_existe(st.session_state.quiz_registro_id):
+                excluir_pontuacao(st.session_state.quiz_registro_id)
+
+            # Resetar estado para nova rodada
+            st.session_state.quiz_indice = 0
+            st.session_state.quiz_pontos = 0
+            st.session_state.quiz_salvo = False
+            st.session_state.quiz_registro_id = None
+            st.session_state.perguntas_rodada = random.sample(TODAS_PERGUNTAS, k=min(NUM_PERGUNTAS_RODADA, len(TODAS_PERGUNTAS)))
+            st.rerun()
+
+        if col2.button("⬅️ Voltar ao sistema"):
+            st.session_state.quiz_verificado = True
+            st.session_state.quiz_pendente = False
+            st.rerun()
+        return
+
+    # Pergunta atual
+    pergunta_atual = PERGUNTAS[indice]
+
+    st.progress((indice + 1) / len(PERGUNTAS))
+    st.caption(f"Pergunta {indice + 1} de {len(PERGUNTAS)}")
+
+    with st.form(key=f"form_pergunta_{indice}"):
+        st.write(f"**{pergunta_atual['pergunta']}**")
+        resposta = st.radio("Escolha uma opção:", pergunta_atual["opcoes"])
+        enviar = st.form_submit_button("Responder")
+
+    if enviar:
+        correta = pergunta_atual["opcoes"][pergunta_atual["resposta"]]
+        if resposta == correta:
+            st.success("✅ Resposta correta!")
+            st.session_state.quiz_pontos += 10
+        else:
+            st.error(f"❌ Resposta incorreta. Correta: {correta}")
+        st.session_state.quiz_indice += 1
+        st.rerun()
+
+if __name__ == "__main__":
+    main()
+
+
+
+
+
+
+