@danhachuel/thunderbolt 0.3.38 → 0.3.40

package/MANUAL-INSTALACAO.md

@@ -2,7 +2,7 @@
 
 Este manual descreve a instalação local da UI Thunderbolt, baseada no MoneyPrinterTurbo, utilizando o pacote npm `@danhachuel/thunderbolt`. O fluxo recomendado instala automaticamente o ambiente Python, as dependências da aplicação, as dependências do MoneyPrinterTurbo, o Streamlit e o suporte FFmpeg através de `imageio-ffmpeg`.
 
-> **Versão deste manual:** 0.3.38
+> **Versão deste manual:** 0.3.39
 > **Pacote npm:** `@danhachuel/thunderbolt`
 > **Porta padrão da UI:** `localhost:3030`  
 > **Repositório:** [github.com/DanHachuel/thunderbolt](https://github.com/DanHachuel/thunderbolt)
@@ -100,13 +100,13 @@ Execute:
 Windows PowerShell ou MobaXterm:
 
 ```powershell
-npx.cmd --yes @danhachuel/thunderbolt@0.3.38 install
+npx.cmd --yes @danhachuel/thunderbolt@0.3.39 install
 ```
 
 Linux/macOS:
 
 ```bash
-npx --yes @danhachuel/thunderbolt@0.3.38 install
+npx --yes @danhachuel/thunderbolt@0.3.39 install
 ```
 
 A instalação normal é **segura para actualizações**: preserva `storage`, Blueprints, Brandings, configurações e artefactos do utilizador. Remove apenas `.venv`, o clone técnico do MoneyPrinterTurbo e dependências que serão recriadas. Uma pasta antiga sem dados do utilizador, como `C:\Users\<utilizador>\AppData\Local\hermes` da tentativa incompleta, pode ser removida; uma pasta antiga que contenha Blueprints, Brandings ou storage é preservada e apenas avisada no terminal. Feche processos Python, Node, Streamlit e MobaXterm que estejam a usar as pastas antes de executar.
@@ -396,6 +396,10 @@ Uma execução da etapa Vídeo tem limite de 20 minutos. Se o processo externo t
 
 Se o launcher ou o worker for encerrado abruptamente, uma tarefa `doing` sem actualização durante 25 minutos é recuperada e marcada como `failed`, evitando estados indefinidos eternos. Para processar novas tarefas, deixe a aplicação iniciada com o comando normal; o painel avisa quando não existe heartbeat recente do worker.
 
+O **Backlog Vídeos** e a lista **Automação > Automação Youtube > Vídeos cadastrados** usam o mesmo catálogo completo de `storage/state/tasks.json`. Por isso, tarefas criadas manualmente e tarefas criadas pelo worker diário aparecem nos dois locais, sem filtragem implícita por origem. O filtro do Backlog mostra os estados conhecidos e inclui automaticamente estados adicionais encontrados nos dados.
+
+Nos dois cards, o bloco de estado apresenta o valor técnico, o rótulo legível, a barra de progresso e a mensagem de erro quando existir. O bloco **Formato** resolve nesta ordem `format`, `style_wide`, `style` e, por fim, `wide`, mantendo a apresentação de formatos como `wide`, `shorts`, `music` ou `full_ia` mesmo em tarefas antigas.
+
 ### Upload Música — JewelMusic, Pushtunes e ytmusicapi
 
 A área **Pipeline Música > Upload Música** separa três métodos com contratos diferentes. Em **JewelMusic**, active a integração, introduza a API Key fornecida pelo dashboard da JewelMusic e confirme a Base URL oficial `https://api.jewelmusic.com` e, se necessário, configure proxy e timeout. Carregue ou seleccione um ficheiro de música, indique artista e título e clique em **Enviar música para JewelMusic**. O teste de ligação consulta `/v1/ping`; o upload envia `multipart/form-data` para `/v1/tracks/upload` com os metadados preenchidos.
@@ -465,6 +469,8 @@ O cartão mostra o nicho imediatamente abaixo do nome. Os quatro blocos compacto
 
 A secção **Últimos 10 vídeos publicados** fica abaixo das configurações do canal, dentro de um expander fechado por defeito, e não dentro de Criação de Vídeos. Clique no expander e depois em **Actualizar últimos 10 vídeos** para consultar o feed RSS público do YouTube sem Data API Key. Os resultados são guardados em `storage/state/channel_videos.json`. A única vista disponível é **Lista**, que apresenta título, data, URL, estado e botão **Editar vídeo**. A edição local permite alterar título, estado, data, URL e notas. Essas alterações são overrides de gestão local e não publicam automaticamente no YouTube.
 
+A página **Configurações > Logs** aparece no menu entre **Notificações** e **Configuração API**. Mostra uma projecção unificada das tarefas e notificações persistentes, com filtro livre por operação, filtros por operação e estado e as colunas mínimas **Operação**, **Estado**, **Data** e **Hora**. A tabela também mostra **Registo**, **Origem**, **Progresso** e **Detalhes**; estados como pendente, em execução, concluído, publicado, falha, cancelado e bloqueado são apresentados quando existirem no storage local.
+
 ## Canais em lote por conta Google/YouTube
 
 A subaba **Canais em lote gmail**, dentro de **Canais Youtube**, não lê e-mails, mensagens, contactos ou a caixa Gmail. O nome identifica a conta Google/Gmail que gere os canais YouTube. Configure cada conta em **Configurações > Contas Google**, preenchendo e-mail, OAuth Client ID, OAuth Client Secret e o `sessionInfo token desta conta Google`.
@@ -481,7 +487,7 @@ Ao abrir a página, o Thunderbolt não prepara dados públicos, não descarrega
 
 Os parâmetros da UI são número de clusters entre 2 e 10, suporte mínimo entre 0,01 e 0,50, país, engagement, intervalo de datas e tags, todos dentro da área principal da aba. O núcleo normaliza os dados, calcula engagement, aplica filtros, faz transformação logarítmica e standardização, executa K-Means e calcula itemsets/regras com FP-Growth. Não são apresentados resultados até ao primeiro clique em **Analisar Nichos**; o mesmo botão aplica alterações posteriores aos filtros. Os resultados são DataFrames de clusters, itemsets frequentes, regras de associação e dados analisados; o gráfico de dispersão é criado nativamente com Plotly.
 
-As dependências adicionais — `scikit-learn`, `mlxtend`, `plotly`, `seaborn`, `matplotlib` e `kagglehub` — são instaladas pelo procedimento normal de `npx`. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.3.38 install`; o instalador detecta e reutiliza o que já estiver válido.
+As dependências adicionais — `scikit-learn`, `mlxtend`, `plotly`, `seaborn`, `matplotlib` e `kagglehub` — são instaladas pelo procedimento normal de `npx`. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.3.39 install`; o instalador detecta e reutiliza o que já estiver válido.
 
 ### Niche Finder Apify
 

package/README.md

@@ -69,9 +69,9 @@ No topo da área principal da aplicação existe o menu nativo de idioma no padr
 
 A UI suporta os temas **Dark** e **Light** através do menu nativo de três pontos do Streamlit, no local original do toolbar. Não existe um selector Theme adicional dentro da página. A configuração distribuída em `.streamlit/config.toml` disponibiliza as variantes nomeadas **Dark** e **Light**, e o menu nativo continua responsável por alternar entre os modos, seguindo o padrão do [MoneyPrinterTurbo](https://github.com/harry0703/MoneyPrinterTurbo). O CSS próprio do Thunderbolt usa cores semânticas, `currentColor` e `color-mix` para acompanhar o tema activo, sem alterar a posição nem a funcionalidade do toolbar, do botão Deploy e do menu principal.
 
-## Navegação da UI 0.3.38
+## Navegação da UI 0.3.40
 
-A barra lateral mantém os níveis principais, nesta ordem: **Início**, **Niche Finder**, **Pipeline**, **Pipeline TikTok**, **Automação**, **Edição**, **AI Influencers** e **Configurações**. **Pipeline Vídeos** é expansível e contém **Criação de Vídeos**, **Backlog Vídeos**, **Roteiros**, **Thumbnails** e **Upload**. **Pipeline Música** é expansível e contém **Criação de Músicas** e **Upload Música**. **Automação** também é expansível e contém **Automação Youtube**. **Edição** é expansível e contém **Limpador de Metadados**, **Cortes**, **Editor Python** e **Download Mídia**, nessa ordem. **AI Influencers** é expansível e contém **Personagens**, **Redes Sociais**, **Tutorial Meta** e **Tutorial Supabase**, nessa ordem. **Niche Finder** é expansível e contém **Niche Finder Kaggle** e **Niche Finder Apify**. **Configurações** é expansível e contém **Canais Youtube**, **Blueprints Youtube**, **MCP**, **Contas Google**, **Configuração API** e **Notificações**. O Início reúne o dashboard e as filas do Pipeline, sem botões de acções rápidas.
+A barra lateral mantém os níveis principais, nesta ordem: **Início**, **Niche Finder**, **Pipeline**, **Pipeline TikTok**, **Automação**, **Edição**, **AI Influencers** e **Configurações**. **Pipeline Vídeos** é expansível e contém **Criação de Vídeos**, **Backlog Vídeos**, **Roteiros**, **Thumbnails** e **Upload**. **Pipeline Música** é expansível e contém **Criação de Músicas** e **Upload Música**. **Automação** também é expansível e contém **Automação Youtube**. **Edição** é expansível e contém **Limpador de Metadados**, **Cortes**, **Editor Python** e **Download Mídia**, nessa ordem. **AI Influencers** é expansível e contém **Personagens**, **Redes Sociais**, **Tutorial Meta** e **Tutorial Supabase**, nessa ordem. **Niche Finder** é expansível e contém **Niche Finder Kaggle** e **Niche Finder Apify**. **Configurações** é expansível e contém **Canais Youtube**, **Blueprints Youtube**, **MCP**, **Contas Google**, **Notificações**, **Logs** e **Configuração API**, nessa ordem. O Início reúne o dashboard e as filas do Pipeline, sem botões de acções rápidas.
 
 A subaba **Tutorial Supabase** apresenta o guia de criação das tabelas `plans` e `posts` e do bucket `instagram-images`, com ligação para a fonte original no GitHub. As duas frases promocionais da comunidade foram omitidas. Todas as subabas internas também são localizadas pelo helper nativo de tabs:
 
@@ -85,10 +85,16 @@ Em **Configuração API > API Keys**, a subaba **Fontes de materiais** segue o p
 
 A subaba **Serviços e modelos** mantém as credenciais de providers e serviços que não são fontes de materiais. A chave `gemini_image_api_key` da Nano Banana continua separada de `gemini_api_key` do LLM textual. `INNERTUBE_API_KEY` permanece exclusivamente em **Configurações > Contas Google**, no bloco de configuração global fora dos cartões, e não é duplicada em API Keys.
 
-A página **AI Influencers > Tutorial Meta** apresenta o guia de configuração de uma conta Instagram profissional e das credenciais Meta para automações com n8n, distribuído localmente em `seed/references/guide-instagram.md` e com ligação para a [fonte original no GitHub](https://github.com/gyoridavid/ai_agents_az/blob/main/episode_8/guide-instagram.md). A página **Configurações > Notificações** mantém um histórico persistente de conclusões e falhas, reconcilia estados escritos por componentes locais e disponibiliza um checkbox independente para cada operação mapeada. A subaba **Geral** mantém esse centro local; a subaba **Telegram** permite configurar Bot Token, Chat ID e proxy opcional e envia as mesmas notificações pela Bot API oficial, sem polling ou mensagens recebidas.
+A página **AI Influencers > Tutorial Meta** apresenta o guia de configuração de uma conta Instagram profissional e das credenciais Meta para automações com n8n, distribuído localmente em `seed/references/guide-instagram.md` e com ligação para a [fonte original no GitHub](https://github.com/gyoridavid/ai_agents_az/blob/main/episode_8/guide-instagram.md). A página **Configurações > Notificações** mantém um histórico persistente de conclusões e falhas, reconcilia estados escritos por componentes locais e disponibiliza um checkbox independente para cada operação mapeada. A subaba **Geral** mantém esse centro local; a subaba **Telegram** permite configurar Bot Token, Chat ID e proxy opcional e envia as mesmas notificações pela Bot API oficial, sem polling ou mensagens recebidas. A página **Configurações > Logs**, colocada imediatamente abaixo de Notificações e acima de Configuração API, apresenta o histórico unificado de tarefas e notificações, com filtro livre por operação, filtros adicionais por operação e estado, e as colunas Operação, Estado, Data, Hora, Registo, Origem, Progresso e Detalhes.
 
 A página **Edição > Download Mídia** utiliza a API Python do [yt-dlp](https://github.com/yt-dlp/yt-dlp) para descarregar vídeos e áudio de URLs públicas, com qualidade, contentor, formato de áudio, legendas, metadados, playlists, progresso e histórico local em `storage/downloads/` e `storage/state/media_downloads.json`. Conversão e combinação de streams podem exigir FFmpeg.
 
+## Catálogo comum do Backlog e da Automação
+
+**Backlog Vídeos** e **Automação Youtube > Vídeos cadastrados** usam o mesmo catálogo completo persistido em `storage/state/tasks.json`. Assim, todas as tarefas criadas manualmente ou pela automação diária aparecem nos dois fluxos, sem duplicação nem filtros implícitos por origem. O filtro de estado do Backlog mantém os estados conhecidos e acrescenta estados novos encontrados no storage.
+
+Os dois cards mostram de forma consistente o estado técnico, o rótulo legível, a barra de progresso, a etapa e o formato do vídeo. São suportados estados como `to_do`, `doing`, `blocked`, `done`, `failed` e `cancelled`; formatos ausentes usam `format`, `style_wide` ou `wide` como fallback.
+
 ## Canais Youtube — edição por cartão e vídeos recentes
 
 A página **Canais Youtube** mantém o cadastro e a importação existentes, mas cada cartão agora tem o botão **Editar**. O editor permite alterar nome, URL, handle, idioma, estilo wide, **Nicho**, **Blueprint Padrão**, **Narrador/Voz Padrão**, conta Google do Upload directo, descrição e Automação ON/horário. O nicho aparece imediatamente abaixo do nome do canal no cartão; quando não existe, a UI mostra **SEM NICHO CONFIGURADO**.

package/app/main.py

@@ -42,6 +42,7 @@ from hermes_ui.llm_providers import LLM_CARDS_KEY, LLM_ACTIVE_CARD_KEY, LLM_PROV
 from hermes_ui.music import list_music_files, materialize_suno_audio, request_suno_generation, store_music_file
 from hermes_ui.media_downloader import AUDIO_FORMATS, VIDEO_CONTAINERS, VIDEO_QUALITY_OPTIONS, MediaDownloadError, build_download_options, clear_media_download_history, dependency_status, download_media, list_media_downloads, media_download_file
 from hermes_ui.notifications import clear_notifications, list_notifications, mark_all_notifications_read, mark_notification_read, notification_event_catalog, notification_preferences, record_notification, reconcile_persisted_notifications, save_notification_preferences, unread_notification_count
+from hermes_ui.logs import list_logs, logs_to_rows
 from hermes_ui.languages import LANGUAGE_CODES, VIDEO_LANGUAGE_CODES, LANGUAGE_FLAG_DATA_URIS, language_code, language_label, ui_language_menu_label, ui_text, video_language_label, video_language_options
 from hermes_ui.api_key_tests import test_apify_credentials, test_kaggle_credentials, test_material_source_credentials, test_nano_banana_credentials, test_postiz_credentials, test_telegram_credentials, test_tiktok_credentials, test_upload_post_credentials, test_voice_provider
 from hermes_ui.tutorials import tutorial_body, tutorial_caption, tutorial_title
@@ -3292,16 +3293,60 @@ def _render_pipeline_progress_panel() -> None:
         _render_pipeline_progress_live()
 
 
+VIDEO_TASK_STATE_LABELS = {
+    "to_do": "Pendente",
+    "doing": "Em execução",
+    "blocked": "Bloqueado",
+    "done": "Concluído",
+    "failed": "Falha",
+    "cancelled": "Cancelado",
+}
+
+
+def load_video_tasks_for_catalog() -> list[dict[str, Any]]:
+    """Return the complete persisted task catalog shared by Backlog and Automation."""
+    saved = read_json("tasks.json", [])
+    if not isinstance(saved, list):
+        return []
+    return [task for task in saved if isinstance(task, dict) and str(task.get("id") or "").strip()]
+
+
+def _video_task_format(task: dict[str, Any]) -> str:
+    value = task.get("format") or task.get("style_wide") or task.get("style") or "wide"
+    return str(value).strip() or "wide"
+
+
+def _video_task_progress(task: dict[str, Any]) -> int:
+    try:
+        return max(0, min(100, int(task.get("progress") or 0)))
+    except (TypeError, ValueError):
+        return 0
+
+
+def _render_video_task_state(task: dict[str, Any]) -> None:
+    """Show the raw state, readable label and progress consistently in both views."""
+    state = str(task.get("state") or "unknown").strip().lower()
+    progress = _video_task_progress(task)
+    st.caption("Estado")
+    st.write(state or "—")
+    st.caption(VIDEO_TASK_STATE_LABELS.get(state, state.replace("_", " ").capitalize() or "Desconhecido"))
+    st.progress(progress, text=f"{progress}%")
+    if task.get("error"):
+        st.caption(str(task.get("error"))[:240])
+
+
 def render_videos():
     st.subheader("Backlog Videos")
     st.caption("Acompanhamento dos vídeos criados, estados da pipeline e controlos de execução.")
     st.caption(f"Os vídeos são guardados em `{STORAGE / 'videos'}`.")
     _render_pipeline_progress_panel()
-    tasks = read_json("tasks.json", [])
+    tasks = load_video_tasks_for_catalog()
     if not tasks:
         st.info("Nenhum vídeo criado.")
         return
-    state_filter = st.selectbox("Filtrar por estado", ["Todos", "to_do", "doing", "blocked", "done", "failed", "cancelled"], key="videos_state_filter")
+    known_states = ["to_do", "doing", "blocked", "done", "failed", "cancelled"]
+    extra_states = sorted({str(task.get("state") or "unknown") for task in tasks if str(task.get("state") or "unknown") not in known_states})
+    state_filter = st.selectbox("Filtrar por estado", ["Todos", *known_states, *extra_states], key="videos_state_filter")
     for task in tasks:
         if state_filter != "Todos" and task.get("state") != state_filter:
             continue
@@ -3318,16 +3363,13 @@ def render_videos():
                     status = task.get('thumbnail_status', 'not_generated')
                     prompt_note = ' · prompt pronto' if task.get('thumbnail_prompt') else ''
                     st.caption(f"Thumbnail: {status}{prompt_note}")
-            with cols[1]: st.write(task.get("format", "wide"))
+            with cols[1]:
+                st.caption("Formato")
+                st.write(_video_task_format(task))
             with cols[2]:
                 st.write(_pipeline_stage_label(task))
-                if str(task.get("state") or "") in {"to_do", "doing", "blocked"}:
-                    progress = _pipeline_progress_value(task)
-                    st.progress(progress, text=f"{progress}%")
             with cols[3]:
-                st.write(task.get("state", "—"))
-                if task.get("error"):
-                    st.caption(str(task.get("error"))[:240])
+                _render_video_task_state(task)
 
             with cols[4]:
                 state = str(task.get("state") or "")
@@ -3614,21 +3656,20 @@ def render_automation():
 
     st.divider()
     st.subheader("Vídeos cadastrados")
-    tasks = read_json("tasks.json", [])
+    tasks = load_video_tasks_for_catalog()
     if not tasks:
         st.info("Ainda não existem vídeos cadastrados.")
     for task in tasks:
         with st.container(border=True):
-            task_cols = st.columns([2.45, 1.15, 1.15, 1.85])
+            task_cols = st.columns([2.25, 1.65, 1.15, 1.85])
             with task_cols[0]:
                 st.write(f"**{task.get('topic', 'Sem tópico')}**")
                 st.caption(f"{task.get('channel_name', 'Canal')} · {task.get('id', '')}")
             with task_cols[1]:
-                st.caption("Estado")
-                st.write(task.get("state", "—"))
+                _render_video_task_state(task)
             with task_cols[2]:
-                st.caption("Estilo")
-                st.write(task.get("style_wide", "—"))
+                st.caption("Formato")
+                st.write(_video_task_format(task))
             with task_cols[3]:
                 state = str(task.get("state") or "")
                 start_col, stop_col = st.columns(2)
@@ -5286,6 +5327,65 @@ def _render_telegram_notification_settings() -> None:
         st.info("Telegram está desactivado. As notificações continuam disponíveis na subaba Geral.")
 
 
+def render_logs():
+    """Render the unified local activity log before the API configuration page."""
+    st.title("Logs")
+    st.caption("Histórico unificado das operações do Thunderbolt. Os registos são reconstruídos a partir das tarefas e notificações persistidas no storage local.")
+    try:
+        reconcile_persisted_notifications()
+    except Exception:
+        pass
+
+    initial_records = list_logs(limit=500)
+    catalog_operations = {str(item.get("label") or "Operação") for item in notification_event_catalog()}
+    logged_operations = {str(item.get("operation") or "Operação") for item in initial_records}
+    operation_options = ["Todas"] + sorted(catalog_operations | logged_operations)
+    status_options = ["Todos"] + sorted({str(item.get("status") or "Desconhecido") for item in initial_records})
+    filter_cols = st.columns([2.2, 1.25, 1.1])
+    with filter_cols[0]:
+        query = st.text_input(
+            "Filtrar operações",
+            placeholder="Pesquisar por operação, registo, canal ou detalhes",
+            key="logs_query_filter",
+        )
+    with filter_cols[1]:
+        selected_operation = st.selectbox("Operação", operation_options, key="logs_operation_filter")
+    with filter_cols[2]:
+        selected_status = st.selectbox("Estado", status_options, key="logs_status_filter")
+
+    action_cols = st.columns([1, 1, 3])
+    with action_cols[0]:
+        if st.button("Actualizar logs", use_container_width=True):
+            st.rerun()
+    with action_cols[1]:
+        st.metric("Registos", len(initial_records))
+    with action_cols[2]:
+        st.caption("São incluídos estados pendentes, em execução, concluídos, publicados, falhados, cancelados e bloqueados quando existirem.")
+
+    operation_filter = "" if selected_operation == "Todas" else selected_operation
+    status_filter = "" if selected_status == "Todos" else selected_status
+    records = list_logs(operation=operation_filter, query=query, status=status_filter, limit=500)
+    if not records:
+        st.info("Ainda não existem logs para os filtros seleccionados.")
+        return
+    rows = logs_to_rows(records)
+    st.dataframe(
+        rows,
+        use_container_width=True,
+        hide_index=True,
+        column_config={
+            "Operação": st.column_config.TextColumn("Operação", width="medium"),
+            "Estado": st.column_config.TextColumn("Estado", width="small"),
+            "Data": st.column_config.TextColumn("Data", width="small"),
+            "Hora": st.column_config.TextColumn("Hora", width="small"),
+            "Registo": st.column_config.TextColumn("Registo", width="medium"),
+            "Origem": st.column_config.TextColumn("Origem", width="small"),
+            "Progresso": st.column_config.TextColumn("Progresso", width="small"),
+            "Detalhes": st.column_config.TextColumn("Detalhes", width="large"),
+        },
+    )
+
+
 def render_notifications():
     st.title("Notificações")
     st.caption("Centro de notificações internas persistentes do Thunderbolt. As conclusões são guardadas no storage local e aparecem quando a aplicação é actualizada.")
@@ -5729,6 +5829,7 @@ def main():
     settings_items = [
         ("MCP", ":material/hub:", "MCP"),
         ("Notificações", ":material/notifications:", "Notificações"),
+        ("Logs", ":material/description:", "Logs"),
         ("Configuração API", ":material/settings:", "Configuração API"),
     ]
     niche_finder_items = [
@@ -5861,6 +5962,7 @@ def main():
         "Contas Google": render_google_accounts,
         "Configuração API": render_settings,
         "Notificações": render_notifications,
+        "Logs": render_logs,
     }
     try:
         reconcile_persisted_notifications()

package/hermes_ui/logs.py

@@ -0,0 +1,233 @@
+"""Unified activity logs projected from Thunderbolt's persisted local state."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any
+
+from . import storage
+from .notifications import EVENTS_BY_CODE, list_notifications, reconcile_persisted_notifications
+
+MAX_LOGS = 500
+
+STATUS_LABELS = {
+    "to_do": "Pendente",
+    "pending": "Pendente",
+    "queued": "Na fila",
+    "doing": "Em execução",
+    "running": "Em execução",
+    "processing": "Em execução",
+    "done": "Concluído",
+    "completed": "Concluído",
+    "complete": "Concluído",
+    "success": "Concluído",
+    "published": "Publicado",
+    "failed": "Falha",
+    "error": "Falha",
+    "cancelled": "Cancelado",
+    "canceled": "Cancelado",
+    "blocked": "Bloqueado",
+}
+
+TASK_OPERATION_CODES = {
+    "video": "video_completed",
+    "music": "music_completed",
+    "automation": "automation_completed",
+}
+
+
+def _status_label(value: Any) -> str:
+    raw = str(value or "unknown").strip().lower()
+    return STATUS_LABELS.get(raw, raw.replace("_", " ").capitalize() or "Desconhecido")
+
+
+def _parse_datetime(value: Any) -> datetime:
+    text = str(value or "").strip()
+    if not text:
+        return datetime.min.replace(tzinfo=timezone.utc)
+    try:
+        parsed = datetime.fromisoformat(text.replace("Z", "+00:00"))
+    except ValueError:
+        return datetime.min.replace(tzinfo=timezone.utc)
+    if parsed.tzinfo is None:
+        return parsed.replace(tzinfo=timezone.utc)
+    return parsed.astimezone(timezone.utc)
+
+
+def format_log_date_time(value: Any) -> tuple[str, str]:
+    """Return a stable local date and time for the Logs table."""
+    parsed = _parse_datetime(value)
+    if parsed == datetime.min.replace(tzinfo=timezone.utc):
+        return "—", "—"
+    local = parsed.astimezone()
+    return local.strftime("%d/%m/%Y"), local.strftime("%H:%M:%S")
+
+
+def _task_operation_code(task: dict[str, Any]) -> str:
+    if bool(task.get("music_mode")) or str(task.get("style_wide") or "").strip().lower() == "music":
+        return TASK_OPERATION_CODES["music"]
+    if str(task.get("creation_mode") or "").strip().lower() == "automation":
+        return TASK_OPERATION_CODES["automation"]
+    return TASK_OPERATION_CODES["video"]
+
+
+def _operation_label(operation_code: str, fallback: str = "Operação") -> str:
+    event = EVENTS_BY_CODE.get(operation_code)
+    return str(event.get("label") if event else fallback or operation_code or "Operação")
+
+
+def _task_log(task: dict[str, Any]) -> dict[str, Any] | None:
+    task_id = str(task.get("id") or "").strip()
+    if not task_id:
+        return None
+    operation_code = _task_operation_code(task)
+    state = str(task.get("state") or "unknown").strip().lower()
+    occurred_at = task.get("updated_at") or task.get("completed_at") or task.get("created_at")
+    date, time = format_log_date_time(occurred_at)
+    title = str(task.get("title") or task.get("topic") or "Actividade").strip()
+    channel = str(task.get("channel_name") or "").strip()
+    stage = str(task.get("stage") or "").strip()
+    progress = task.get("progress")
+    try:
+        progress_value = max(0, min(100, int(progress))) if progress is not None else None
+    except (TypeError, ValueError):
+        progress_value = None
+    details: list[str] = []
+    if channel:
+        details.append(channel)
+    if stage:
+        details.append(f"Etapa: {stage}")
+    if progress_value is not None:
+        details.append(f"Progresso: {progress_value}%")
+    error = str(task.get("error") or "").strip()
+    if error:
+        details.append(error[:500])
+    return {
+        "id": f"task:{task_id}",
+        "operation_code": operation_code,
+        "operation": _operation_label(operation_code),
+        "status_code": state,
+        "status": _status_label(state),
+        "occurred_at": str(occurred_at or ""),
+        "date": date,
+        "time": time,
+        "source": "Tarefas",
+        "record": title,
+        "details": " · ".join(details),
+        "progress": progress_value,
+        "task_id": task_id,
+    }
+
+
+def _notification_status(entry: dict[str, Any]) -> str:
+    metadata = entry.get("metadata") if isinstance(entry.get("metadata"), dict) else {}
+    explicit = metadata.get("status") or entry.get("status")
+    if explicit:
+        return str(explicit)
+    event_type = str(entry.get("event_type") or "").lower()
+    label = str(entry.get("label") or "").lower()
+    return "failed" if event_type.endswith("_failed") or "falhou" in label or "erro" in label else "completed"
+
+
+def _notification_log(entry: dict[str, Any]) -> dict[str, Any] | None:
+    entry_id = str(entry.get("id") or "").strip()
+    if not entry_id:
+        return None
+    event_type = str(entry.get("event_type") or "").strip()
+    if not event_type:
+        return None
+    status_code = _notification_status(entry).strip().lower()
+    occurred_at = entry.get("created_at") or ""
+    date, time = format_log_date_time(occurred_at)
+    metadata = entry.get("metadata") if isinstance(entry.get("metadata"), dict) else {}
+    public_metadata = [f"{key}: {value}" for key, value in metadata.items() if value not in (None, "")]
+    return {
+        "id": f"notification:{entry_id}",
+        "operation_code": event_type,
+        "operation": str(entry.get("label") or _operation_label(event_type)),
+        "status_code": status_code,
+        "status": _status_label(status_code),
+        "occurred_at": str(occurred_at),
+        "date": date,
+        "time": time,
+        "source": "Notificações",
+        "record": str(entry.get("title") or entry.get("label") or "Notificação"),
+        "details": " · ".join([str(entry.get("message") or "").strip(), *public_metadata]).strip(" ·")[:1000],
+        "progress": None,
+        "task_id": str(metadata.get("task_id") or ""),
+    }
+
+
+def _should_skip_notification(entry: dict[str, Any], task_ids: set[str]) -> bool:
+    """Avoid duplicating the canonical task completion/failure with its notification."""
+    event_type = str(entry.get("event_type") or "")
+    metadata = entry.get("metadata") if isinstance(entry.get("metadata"), dict) else {}
+    task_id = str(metadata.get("task_id") or "")
+    return bool(task_id and task_id in task_ids and event_type in {"video_completed", "music_completed", "activity_failed"})
+
+
+def list_logs(*, operation: str = "", query: str = "", status: str = "", limit: int = MAX_LOGS) -> list[dict[str, Any]]:
+    """Return a unified, newest-first projection of local activity records."""
+    try:
+        reconcile_persisted_notifications()
+    except Exception:
+        # A diagnostic page must remain available even if one source is malformed.
+        pass
+    tasks = storage.read_json("tasks.json", [])
+    tasks = [item for item in tasks if isinstance(item, dict)] if isinstance(tasks, list) else []
+    task_ids = {str(item.get("id") or "") for item in tasks if item.get("id")}
+    records = [item for item in (_task_log(task) for task in tasks) if item]
+    notifications = list_notifications(limit=MAX_LOGS)
+    records.extend(
+        item
+        for entry in notifications
+        if not _should_skip_notification(entry, task_ids)
+        for item in [_notification_log(entry)]
+        if item
+    )
+    operation_filter = str(operation or "").strip().casefold()
+    query_filter = str(query or "").strip().casefold()
+    status_filter = str(status or "").strip().casefold()
+    if operation_filter:
+        records = [item for item in records if str(item.get("operation") or "").casefold() == operation_filter]
+    if status_filter:
+        records = [item for item in records if str(item.get("status") or "").casefold() == status_filter]
+    if query_filter:
+        records = [
+            item
+            for item in records
+            if query_filter in " ".join(str(item.get(key) or "") for key in ("operation", "status", "record", "details", "source")).casefold()
+        ]
+    records.sort(key=lambda item: _parse_datetime(item.get("occurred_at")), reverse=True)
+    try:
+        requested_limit = int(limit)
+    except (TypeError, ValueError):
+        requested_limit = MAX_LOGS
+    return records[: max(1, min(requested_limit, MAX_LOGS))]
+
+
+def log_operation_options() -> list[str]:
+    records = list_logs(limit=MAX_LOGS)
+    return ["Todas"] + sorted({str(item.get("operation") or "Operação") for item in records})
+
+
+def log_status_options() -> list[str]:
+    records = list_logs(limit=MAX_LOGS)
+    return ["Todos"] + sorted({str(item.get("status") or "Desconhecido") for item in records})
+
+
+def logs_to_rows(records: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Convert the internal projection into safe scalar rows for Streamlit."""
+    return [
+        {
+            "Operação": item.get("operation") or "Operação",
+            "Estado": item.get("status") or "Desconhecido",
+            "Data": item.get("date") or "—",
+            "Hora": item.get("time") or "—",
+            "Registo": item.get("record") or "—",
+            "Origem": item.get("source") or "—",
+            "Progresso": f"{item['progress']}%" if item.get("progress") is not None else "—",
+            "Detalhes": item.get("details") or "—",
+        }
+        for item in records
+    ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danhachuel/thunderbolt",
-  "version": "0.3.38",
+  "version": "0.3.40",
   "description": "Thunderbolt — interface local para operação de canais faceless e motor MoneyPrinterTurbo",
   "license": "MIT",
   "main": "scripts/cli.mjs",