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)
+