@danhachuel/thunderbolt 0.3.36 → 0.3.38

package/.streamlit/config.toml

@@ -1,5 +1,4 @@
 [theme]
-base = "dark"
 font = "sans serif"
 
 [theme.dark]

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.36
+> **Versão deste manual:** 0.3.38
 > **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.36 install
+npx.cmd --yes @danhachuel/thunderbolt@0.3.38 install
 ```
 
 Linux/macOS:
 
 ```bash
-npx --yes @danhachuel/thunderbolt@0.3.36 install
+npx --yes @danhachuel/thunderbolt@0.3.38 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.
@@ -200,7 +200,7 @@ Todas as subabas internas e o conteúdo das páginas também são traduzidos nos
 
 ### Temas Light e Dark
 
-A aplicação usa o mecanismo nativo de temas do Streamlit e é distribuída com `.streamlit/config.toml`, seguindo o padrão de configuração do [MoneyPrinterTurbo](https://github.com/harry0703/MoneyPrinterTurbo). O ficheiro define **Dark** como base inicial. A alternância para **Light** e o regresso a **Dark** ficam exclusivamente no menu nativo de três pontos do Streamlit, no local original do toolbar; não existe um selector Theme dentro da página. Os componentes próprios da UI herdam as cores do tema activo através de `currentColor` e `color-mix`. O toolbar nativo, o indicador de execução, **Deploy** e o menu principal continuam sem sobreposições CSS.
+A aplicação usa o mecanismo nativo de temas do Streamlit e é distribuída com `.streamlit/config.toml`, seguindo o padrão de configuração do [MoneyPrinterTurbo](https://github.com/harry0703/MoneyPrinterTurbo). O ficheiro disponibiliza as variantes nomeadas **Dark** e **Light**. A alternância entre elas fica exclusivamente no menu nativo de três pontos do Streamlit, no local original do toolbar; não existe um selector Theme dentro da página. Os componentes próprios da UI herdam as cores do tema activo através de `currentColor` e `color-mix`. O toolbar nativo, o indicador de execução, **Deploy** e o menu principal continuam sem sobreposições CSS.
 
 ## 4. Diagnóstico antes de iniciar
 
@@ -386,6 +386,16 @@ Na primeira execução, a barra lateral apresenta **Início**, **Niche Finder**,
 | Telegram Proxy | Proxy HTTP/HTTPS/SOCKS opcional para ambientes sem acesso directo |
 | Telegram timeout | Limite de espera de cada envio, entre 5 e 120 segundos |
 
+### Execução do pipeline de vídeos e acompanhamento
+
+Ao clicar em **Start** no **Backlog Vídeos**, a tarefa passa para `doing` e é processada pelo worker de pipeline iniciado pelo launcher normal. O worker grava o estado em `storage/state/pipeline_worker.json` e actualiza `updated_at`, a etapa e a percentagem em `storage/state/tasks.json`. O painel do Backlog consulta esse estado automaticamente a cada cinco segundos e mostra o worker, a etapa corrente, a percentagem, a idade da actualização e a mensagem de erro quando existe.
+
+A percentagem representa o avanço conhecido do pipeline: tema, roteiro, título/keywords, thumbnail, vídeo e upload. Durante a chamada longa ao MoneyPrinterTurbo, a UI mantém um heartbeat a cada cinco segundos e avança apenas dentro da faixa reservada à geração do vídeo; não apresenta 100% antes de existir um MP4 válido. O worker passa explicitamente a **Pasta do motor de vídeo** configurada na UI ao helper, por isso o clone usado, os logs e o manifesto pertencem à instalação seleccionada pelo utilizador.
+
+Uma execução da etapa Vídeo tem limite de 20 minutos. Se o processo externo terminar com erro, exceder o limite, devolver um resultado inválido ou ocorrer uma excepção inesperada, a tarefa é marcada como `failed`, com a etapa em `failed_stage`. As últimas linhas devolvidas pelo helper, sem as credenciais configuradas, são guardadas num artefacto `video-diagnostics` e as referências `video_log`/`video_result` ficam associadas à tarefa. Se o utilizador clicar em **Stop**, a tarefa passa para `blocked`, o subprocesso é terminado cooperativamente e o worker não substitui esse estado por `failed`.
+
+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.
+
 ### 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.
@@ -449,11 +459,11 @@ A subaba de fontes não é um painel de tuning: endpoints, proxy, qualidade, cor
 
 ## Gestão de Canais, edição e vídeos recentes
 
-Na página **Configurações > Canais Youtube**, cada canal cadastrado aparece num cartão com o botão **Editar**. O editor permite alterar o nome, URL, handle, idioma, estilo wide, **Canais de Referência / Nicho**, **Prompts do Canal** (Blueprint padrão), **Narrador** (Voz padrão), conta Google do Upload directo, descrição e Automação ON/horário. Guardar alterações actualiza o mesmo registo local; não é necessário apagar e criar o canal novamente.
+Na página **Configurações > Canais Youtube**, cada canal cadastrado aparece num cartão com o botão **Editar**. O editor permite alterar o 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. Guardar alterações actualiza o mesmo registo local; não é necessário apagar e criar o canal novamente.
 
-O cartão mostra o nicho ou Canais de Referência imediatamente abaixo do nome. Os três blocos de gestão usam os rótulos **Prompts do Canal**, **Canais de Referência** e **Narrador**, com botões que abrem o editor do próprio canal.
+O cartão mostra o nicho imediatamente abaixo do nome. Os quatro blocos compactos de gestão usam os rótulos **Blueprint Padrão**, **Nicho**, **Narrador/Voz Padrão** e **Idioma**, com os botões de edição correspondentes; o idioma é apenas apresentado a partir da configuração já guardada no canal.
 
-A secção **Últimos 10 vídeos publicados** fica abaixo das configurações do canal e não dentro de Criação de Vídeos. Clique 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 vista **Lista** apresenta título, data, URL, estado e botão **Editar vídeo**; a vista **Kanban** separa Planejamento, Produção, Finalizado e Agendado/Publicado. 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 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.
 
 ## Canais em lote por conta Google/YouTube
 
@@ -471,7 +481,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.36 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.38 install`; o instalador detecta e reutiliza o que já estiver válido.
 
 ### Niche Finder Apify
 
@@ -509,7 +519,7 @@ O modo `Pexels/Pixabay` representa materiais de stock. Ao seleccionar `full_ia`,
 
 A aba **Roteiros**, colocada entre **Criação de Músicas** e **Upload**, permite seleccionar um canal opcional, um Blueprint, **Roteiro de vídeo** ou **Letra de música**, idioma, tema e estrutura. O botão **Gerar com IA a partir do Blueprint** usa o provider LLM configurado e devolve um rascunho Markdown editável; o utilizador deve rever e clicar em **Guardar documento no storage**. Os ficheiros são guardados em `storage/scripts/` e o índice em `storage/state/scripts.json`; o caminho absoluto aparece no topo da página. Na subaba **Vídeos** de **Criação de Vídeos**, a aplicação mostra a frase `Os vídeos são guardados em <storage>/videos`, que identifica a pasta local dos vídeos.
 
-A aba **Automação Youtube**, dentro do menu expansível **Automação**, lista os canais e vídeos, permite escolher e guardar **Blueprint padrão** e **Voz padrão** por canal, guarda **Automação ON** e valida horários diários no formato `HH:MM`. Os valores ficam sincronizados com o editor existente no cartão da aba **Canais Youtube** e são copiados para novas tarefas. O launcher inicia o worker local, que consulta o relógio do computador, gera um briefing, título e pacote de thumbnail específicos com o provider LLM configurado, cria o lote agendado na fila e evita duplicar o mesmo canal no mesmo dia. Se a geração não puder ser executada, o erro fica registado e o placeholder antigo não é usado.
+A aba **Automação Youtube**, dentro do menu expansível **Automação**, lista os canais e vídeos e apresenta nos cards os mesmos quatro elementos do cadastro: **Idioma Padrão**, **Blueprint Padrão**, **Nicho Padrão** e **Narrador/Voz Padrão**. Blueprint e Narrador/Voz continuam editáveis no card; Idioma e Nicho são mostrados a partir da configuração guardada no canal. A aba também guarda **Automação ON** e valida horários diários no formato `HH:MM`. Os valores ficam sincronizados com o editor existente no cartão da aba **Canais Youtube** e são copiados para novas tarefas. O launcher inicia o worker local, que consulta o relógio do computador, gera um briefing, título e pacote de thumbnail específicos com o provider LLM configurado, cria o lote agendado na fila e evita duplicar o mesmo canal no mesmo dia. Se a geração não puder ser executada, o erro fica registado e o placeholder antigo não é usado.
 
 A área **Teste de vozes**, dentro de **Configurações > Configuração API**, é isolada da pipeline. O preview pode ser reproduzido e descarregado de `storage/voice_previews/`. Caminhos vazios, directórios, ficheiros vazios e previews sem permissões de leitura são ignorados com uma mensagem clara, sem traceback. Se uma instalação antiga mostrar que `edge-tts` está em falta, execute `npx.cmd --yes @danhachuel/thunderbolt install`; o detector reinstala apenas a dependência ausente.
 

package/README.md

@@ -12,6 +12,7 @@ A primeira versão implementa a camada UI independente com:
 |---|---|
 | Início | Resumo de canais, tarefas, backlog, execução e falhas, com as filas do Pipeline inline |
 | Pipeline Vídeos | Menu expansível com Criação de Vídeos, Backlog Vídeos, Roteiros, Thumbnails e Upload |
+| Worker de vídeo | Heartbeat persistido, barra de progresso por etapas, timeout de 20 minutos, recuperação de tarefas abandonadas e diagnóstico bounded do helper MoneyPrinterTurbo |
 | Pipeline Música | Menu expansível com Criação de Músicas e Upload Música |
 | Blueprints Youtube | Leitura da pasta `storage/blueprints/`, upload/validação de JSON e criação a partir de link YouTube |
 | Brandings | Subaba própria dentro de Blueprints, upload/listagem de Brandings e criação conjunta com Blueprint |
@@ -66,9 +67,9 @@ No topo da área principal da aplicação existe o menu nativo de idioma no padr
 
 ## Temas claro e escuro
 
-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` define **Dark** como base inicial 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.
+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.36
+## Navegação da UI 0.3.38
 
 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.
 
@@ -90,11 +91,11 @@ A página **Edição > Download Mídia** utiliza a API Python do [yt-dlp](https:
 
 ## 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, **Canais de Referência / Nicho**, **Prompts do Canal** (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**.
+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**.
 
-Os blocos do cartão usam a nomenclatura solicitada: **Prompts do Canal**, **Canais de Referência** e **Narrador**. Os botões de acção abrem o mesmo editor persistente, sem criar um segundo canal nem perder as associações existentes.
+Os quatro blocos compactos do cartão usam a nomenclatura solicitada: **Blueprint Padrão**, **Nicho**, **Narrador/Voz Padrão** e **Idioma**. Os botões de acção abrem o mesmo editor persistente, sem criar um segundo canal nem perder as associações existentes.
 
-Abaixo do cartão, a secção **Últimos 10 vídeos publicados** usa o feed público RSS do YouTube, sem Data API Key. O carregamento ocorre quando se clica em **Actualizar últimos 10 vídeos**, evitando chamadas automáticas ao abrir a página. Os vídeos ficam guardados em `storage/state/channel_videos.json` e podem ser apresentados em **Lista** ou **Kanban**, nos grupos Planejamento, Produção, Finalizado e Agendado/Publicado. Cada vídeo tem **Editar vídeo** para alterar localmente o título, estado, data, URL e notas. A fonte pública não substitui o vídeo nem publica alterações no YouTube; os campos editáveis são overrides locais de gestão.
+Abaixo do cartão, a secção **Últimos 10 vídeos publicados** fica num expander fechado por defeito e usa o feed público RSS do YouTube, sem Data API Key. O carregamento ocorre quando se clica em **Actualizar últimos 10 vídeos**, evitando chamadas automáticas ao abrir a página. Os vídeos ficam guardados em `storage/state/channel_videos.json` e são apresentados apenas no modo **Lista**. Cada vídeo tem **Editar vídeo** para alterar localmente o título, estado, data, URL e notas. A fonte pública não substitui o vídeo nem publica alterações no YouTube; os campos editáveis são overrides locais de gestão.
 
 ## Criação de Vídeos — geração editorial por canal
 

package/app/main.py

@@ -1,12 +1,11 @@
 from __future__ import annotations
 
 import hashlib
-import html
 import json
 import mimetypes
 import re
 from contextlib import nullcontext
-from datetime import date, datetime
+from datetime import date, datetime, timezone
 import sys
 import uuid
 from pathlib import Path
@@ -26,6 +25,7 @@ except (OSError, json.JSONDecodeError):
 from hermes_ui.domain import STAGES, create_batch, create_channel, create_tasks_for_batch, delete_channel, pipeline_summary, set_channel_defaults, transition_task, update_channel, update_channel_video
 from hermes_ui.drafts import list_drafts, save_draft
 from hermes_ui.automation_worker import load_worker_status
+from hermes_ui.pipeline_worker import load_pipeline_worker_status, recover_stale_tasks, STALE_TASK_SECONDS, WORKER_HEARTBEAT_TIMEOUT_SECONDS
 from hermes_ui.storage import BLUEPRINTS, DEFAULT_LLM_PROVIDER, MEDIA_DOWNLOADS, STORAGE, TIKTOK_PROMPT_MASTERS, ensure_storage, get_display_name, list_blueprint_files, list_prompt_master_files, load_blueprint_file, load_prompt_master_file, now, read_json, set_display_name, write_json
 from app.modules.niche_finder.apify import ApifyError, DEFAULT_ACTOR_ID, abort_actor_run, build_actor_input, get_dataset_items, normalize_video_items, start_actor_run, wait_for_actor_run
 from app.modules.niche_finder.core import NicheAnalysisError, run_niche_analysis
@@ -207,30 +207,6 @@ st.markdown("""
 [data-testid="stSidebar"] [data-testid="stExpander"] summary p { margin:0; line-height:1; }
 [data-testid="stSidebar"] [data-testid="stExpander"] > div { padding:0 0 0 0.42rem !important; }
 [data-testid="stSidebar"] [data-testid="stExpander"] > div [data-testid="stButton"] button { padding-left:0.92rem; font-size:0.83rem; min-height:1.62rem; height:1.62rem; }
-.tb-channel-kanban-card { box-sizing:border-box; min-height:330px; height:330px; padding:0.85rem 0.9rem; border:1px solid color-mix(in srgb, currentColor 18%, transparent); border-radius:14px; background:color-mix(in srgb, currentColor 5%, transparent); color:inherit; box-shadow:0 4px 14px color-mix(in srgb, currentColor 12%, transparent); overflow:hidden; }
-.tb-channel-kanban-card__header { display:flex; align-items:center; gap:0.58rem; min-width:0; }
-.tb-channel-kanban-card__avatar { width:46px; height:46px; flex:0 0 46px; border-radius:10px; object-fit:cover; background:color-mix(in srgb, var(--tb-accent) 14%, transparent); }
-.tb-channel-kanban-card__avatar--fallback { display:flex; align-items:center; justify-content:center; font-weight:800; color:var(--tb-accent); }
-.tb-channel-kanban-card__identity { min-width:0; flex:1 1 auto; }
-.tb-channel-kanban-card__name { font-size:1rem; font-weight:750; line-height:1.18; white-space:nowrap; overflow:hidden; text-overflow:ellipsis; }
-.tb-channel-kanban-card__niche { margin-top:0.22rem; font-size:0.76rem; opacity:.66; white-space:nowrap; overflow:hidden; text-overflow:ellipsis; }
-.tb-channel-kanban-card__badges { display:flex; gap:0.28rem; flex:0 0 auto; align-items:center; }
-.tb-channel-kanban-card__badge { padding:0.18rem 0.42rem; border-radius:6px; font-size:0.67rem; font-weight:750; line-height:1.1; white-space:nowrap; }
-.tb-channel-kanban-card__badge--youtube { background:#dc2626; color:#fff; }
-.tb-channel-kanban-card__badge--active { background:color-mix(in srgb, #22c55e 25%, transparent); color:#16a34a; border:1px solid color-mix(in srgb, #22c55e 50%, transparent); }
-.tb-channel-kanban-card__badge--inactive { background:color-mix(in srgb, #ef4444 18%, transparent); color:#dc2626; border:1px solid color-mix(in srgb, #ef4444 45%, transparent); }
-.tb-channel-kanban-card__rule { height:1px; margin:0.72rem 0 0.62rem; background:color-mix(in srgb, currentColor 13%, transparent); }
-.tb-channel-kanban-card__metrics { display:grid; grid-template-columns:repeat(3, minmax(0, 1fr)); gap:0.34rem; }
-.tb-channel-kanban-card__metric { min-width:0; min-height:67px; padding:0.48rem 0.28rem 0.36rem; border-radius:8px; text-align:center; background:color-mix(in srgb, currentColor 4%, transparent); }
-.tb-channel-kanban-card__metric-value { font-size:1.12rem; font-weight:800; line-height:1.15; white-space:nowrap; overflow:hidden; text-overflow:ellipsis; }
-.tb-channel-kanban-card__metric-label { margin-top:0.3rem; font-size:0.66rem; opacity:.64; white-space:nowrap; overflow:hidden; text-overflow:ellipsis; }
-.tb-channel-kanban-card__status-row { display:grid; grid-template-columns:repeat(2, minmax(0, 1fr)); gap:0.34rem; margin-top:0.6rem; }
-.tb-channel-kanban-card__status { min-width:0; padding:0.42rem 0.28rem; border-radius:8px; text-align:center; font-size:0.71rem; white-space:nowrap; overflow:hidden; text-overflow:ellipsis; }
-.tb-channel-kanban-card__status strong { font-size:0.92rem; margin-right:0.18rem; }
-.tb-channel-kanban-card__status--doing { color:#d97706; background:color-mix(in srgb, #f59e0b 14%, transparent); border:1px solid color-mix(in srgb, #f59e0b 35%, transparent); }
-.tb-channel-kanban-card__status--done { color:#16a34a; background:color-mix(in srgb, #22c55e 11%, transparent); border:1px solid color-mix(in srgb, #22c55e 30%, transparent); }
-.tb-channel-kanban-card__titles { margin-top:0.58rem; font-size:0.73rem; opacity:.7; white-space:nowrap; overflow:hidden; text-overflow:ellipsis; }
-@media (max-width: 900px) { .tb-channel-kanban-card { min-height:310px; height:310px; } .tb-channel-kanban-card__name { font-size:.9rem; } }
 .content-card { box-sizing:border-box; padding:1rem 1.1rem; border:1px solid rgba(128,128,128,.28); border-radius:14px; background:rgba(128,128,128,.10); color:inherit; min-height:110px; box-shadow:0 4px 14px rgba(0,0,0,.12); }
 .content-card { border:1px solid color-mix(in srgb, currentColor 18%, transparent); background:color-mix(in srgb, currentColor 5%, transparent); box-shadow:0 4px 14px color-mix(in srgb, currentColor 12%, transparent); }
 .content-label { color:inherit; opacity:.72; font-size:.8rem; text-transform:uppercase; letter-spacing:.07em; }
@@ -967,38 +943,38 @@ def render_channel_video_editor(video: dict, channel_id: str) -> None:
 
 def render_channel_videos(channel: dict) -> None:
     channel_id = str(channel.get("id") or "")
-    st.markdown("### Últimos 10 vídeos publicados")
-    st.caption("A lista usa o feed público do YouTube, sem Data API Key. Pode actualizar manualmente e editar os metadados locais apresentados.")
-    refresh_col = st.columns(1)[0]
-    with refresh_col:
-        if st.button("Actualizar últimos 10 vídeos", key=f"refresh_channel_videos_{channel_id}", use_container_width=True):
-            result = fetch_channel_videos_public(channel, limit=10)
-            if result.ok:
-                videos = _merge_channel_videos(channel_id, result.data.get("videos", []))
-                st.session_state[f"channel_videos_{channel_id}"] = videos
-                st.success(result.message)
-                st.rerun()
-            else:
-                st.warning(result.message)
-    videos = st.session_state.get(f"channel_videos_{channel_id}") or channel_videos_for(channel, limit=10)
-    if not videos:
-        st.info("Ainda não existem vídeos sincronizados. Clique em **Actualizar últimos 10 vídeos**.")
-        return
-    for video in videos[:10]:
-        with st.container(border=True):
-            cols = st.columns([0.7, 3.4, 1.4, 1.1])
-            with cols[0]:
-                if video.get("thumbnail_url"):
-                    st.image(video["thumbnail_url"], width=64)
+    with st.expander("Últimos 10 vídeos publicados", expanded=False):
+        st.caption("A lista usa o feed público do YouTube, sem Data API Key. Pode actualizar manualmente e editar os metadados locais apresentados.")
+        refresh_col = st.columns(1)[0]
+        with refresh_col:
+            if st.button("Actualizar últimos 10 vídeos", key=f"refresh_channel_videos_{channel_id}", use_container_width=True):
+                result = fetch_channel_videos_public(channel, limit=10)
+                if result.ok:
+                    videos = _merge_channel_videos(channel_id, result.data.get("videos", []))
+                    st.session_state[f"channel_videos_{channel_id}"] = videos
+                    st.success(result.message)
+                    st.rerun()
                 else:
-                    st.markdown("### YT")
-            with cols[1]:
-                st.write(f"**{video.get('title', 'Vídeo sem título')}**")
-                st.caption(f"{video.get('published_at') or 'Sem data'} · {video.get('url') or 'Sem URL'}")
-            with cols[2]:
-                st.caption(str(video.get("status") or "publicado").title())
-            with cols[3]:
-                render_channel_video_editor(video, channel_id)
+                    st.warning(result.message)
+        videos = st.session_state.get(f"channel_videos_{channel_id}") or channel_videos_for(channel, limit=10)
+        if not videos:
+            st.info("Ainda não existem vídeos sincronizados. Clique em **Actualizar últimos 10 vídeos**.")
+            return
+        for video in videos[:10]:
+            with st.container(border=True):
+                cols = st.columns([0.7, 3.4, 1.4, 1.1])
+                with cols[0]:
+                    if video.get("thumbnail_url"):
+                        st.image(video["thumbnail_url"], width=64)
+                    else:
+                        st.markdown("### YT")
+                with cols[1]:
+                    st.write(f"**{video.get('title', 'Vídeo sem título')}**")
+                    st.caption(f"{video.get('published_at') or 'Sem data'} · {video.get('url') or 'Sem URL'}")
+                with cols[2]:
+                    st.caption(str(video.get("status") or "publicado").title())
+                with cols[3]:
+                    render_channel_video_editor(video, channel_id)
 
 
 def render_channel_edit_form(channel: dict, youtube_account_ids: list[str], youtube_account_labels: dict[str, str], youtube_accounts_by_id: dict[str, dict[str, Any]]) -> None:
@@ -1020,10 +996,10 @@ def render_channel_edit_form(channel: dict, youtube_account_ids: list[str], yout
             style_options = ["Pexels/Pixabay", "full_ia", "Apenas Música"]
             style_value = {"pexels": "Pexels/Pixabay", "music": "Apenas Música"}.get(str(channel.get("style_wide") or "pexels"), str(channel.get("style_wide") or "Pexels/Pixabay"))
             edited_style = st.selectbox("Estilo wide", style_options, index=style_options.index(style_value) if style_value in style_options else 0)
-            edited_niche = st.text_input("Canais de Referência / Nicho", value=str(channel.get("niche") or channel_niche_label(channel) if channel_niche_label(channel) != "SEM NICHO CONFIGURADO" else "") )
+            edited_niche = st.text_input("Nicho", value=str(channel.get("niche") or channel_niche_label(channel) if channel_niche_label(channel) != "SEM NICHO CONFIGURADO" else "") )
         with edit_cols[1]:
-            edited_blueprint = st.selectbox("Prompts do Canal", blueprint_ids, index=blueprint_ids.index(current_blueprint) if current_blueprint in blueprint_ids else 0, format_func=lambda item: blueprint_labels.get(item, item or "Sem Blueprint padrão"))
-            edited_voice = st.selectbox("Narrador", voice_options, index=voice_options.index(current_voice) if current_voice in voice_options else 0, format_func=lambda item: item or "Sem voz padrão")
+            edited_blueprint = st.selectbox("Blueprint Padrão", blueprint_ids, index=blueprint_ids.index(current_blueprint) if current_blueprint in blueprint_ids else 0, format_func=lambda item: blueprint_labels.get(item, item or "Sem Blueprint padrão"))
+            edited_voice = st.selectbox("Narrador/Voz Padrão", voice_options, index=voice_options.index(current_voice) if current_voice in voice_options else 0, format_func=lambda item: item or "Sem voz padrão")
             edited_account = st.selectbox("Conta Google para Upload directo", account_ids, index=account_ids.index(current_account) if current_account in account_ids else 0, format_func=lambda item: youtube_account_labels.get(item, item or "Sem conta Google associada"))
             edited_description = st.text_area("Descrição", value=str(channel.get("description") or ""), height=100)
             edited_automation = st.toggle("Automação ON", value=bool(channel.get("automation_on", False)), key=f"edit_automation_{channel_id}")
@@ -1437,101 +1413,6 @@ def render_tiktok_prompt_masters():
                     st.error(str(exc))
 
 
-def _format_channel_metric(value: Any) -> str:
-    """Format a channel metric compactly for the Kanban card."""
-    if value is None or value == "":
-        return "—"
-    try:
-        number = int(value)
-    except (TypeError, ValueError):
-        return html.escape(str(value))
-    if abs(number) >= 1_000_000:
-        return f"{number / 1_000_000:.1f}M".replace(".0M", "M")
-    if abs(number) >= 1_000:
-        return f"{number / 1_000:.1f}K".replace(".0K", "K")
-    return f"{number:,}".replace(",", ".")
-
-
-def _channel_pipeline_counts(channel: dict[str, Any]) -> tuple[int, int, int]:
-    """Return in-production, completed and titled task counts for one channel."""
-    channel_id = str(channel.get("id") or "")
-    tasks = read_json("tasks.json", [])
-    if not channel_id or not isinstance(tasks, list):
-        return 0, 0, 0
-    related = [
-        task for task in tasks
-        if isinstance(task, dict) and str(task.get("channel_id") or "") == channel_id
-    ]
-    in_production = sum(1 for task in related if str(task.get("state") or "").lower() == "doing")
-    completed = sum(1 for task in related if str(task.get("state") or "").lower() == "done")
-    titled = sum(1 for task in related if str(task.get("title") or "").strip() or task.get("title_candidates"))
-    return in_production, completed, titled
-
-
-def _render_channel_kanban_card(channel: dict[str, Any]) -> None:
-    """Render one compact, square-style channel card for the global Kanban view."""
-    ui_language = current_ui_language()
-    name = html.escape(str(channel.get("name") or "Sem nome"))
-    niche = html.escape(channel_niche_label(channel))
-    thumbnail_url = str(channel.get("thumbnail_url") or "").strip()
-    if thumbnail_url:
-        avatar = f'<img class="tb-channel-kanban-card__avatar" src="{html.escape(thumbnail_url, quote=True)}" alt="">'
-    else:
-        avatar = '<div class="tb-channel-kanban-card__avatar tb-channel-kanban-card__avatar--fallback">YT</div>'
-    active = bool(channel.get("active", True))
-    active_label = ui_text("Activo" if active else "Inactivo", ui_language)
-    active_class = "active" if active else "inactive"
-    subscribers = _format_channel_metric(channel.get("subscriber_count"))
-    views = _format_channel_metric(channel.get("view_count"))
-    videos = _format_channel_metric(channel.get("video_count"))
-    in_production, completed, titled = _channel_pipeline_counts(channel)
-    youtube_label = ui_text("YouTube", ui_language)
-    subscribers_label = ui_text("Inscritos", ui_language)
-    views_label = ui_text("Visualizações", ui_language)
-    videos_label = ui_text("Vídeos", ui_language)
-    production_label = ui_text("Em produção", ui_language)
-    completed_label = ui_text("Finalizados", ui_language)
-    titles_label = ui_text("Títulos", ui_language)
-    st.markdown(
-        f"""
-        <div class="tb-channel-kanban-card">
-          <div class="tb-channel-kanban-card__header">
-            {avatar}
-            <div class="tb-channel-kanban-card__identity">
-              <div class="tb-channel-kanban-card__name">{name}</div>
-              <div class="tb-channel-kanban-card__niche">{niche}</div>
-            </div>
-            <div class="tb-channel-kanban-card__badges">
-              <span class="tb-channel-kanban-card__badge tb-channel-kanban-card__badge--youtube">{youtube_label}</span>
-              <span class="tb-channel-kanban-card__badge tb-channel-kanban-card__badge--{active_class}">{active_label}</span>
-            </div>
-          </div>
-          <div class="tb-channel-kanban-card__rule"></div>
-          <div class="tb-channel-kanban-card__metrics">
-            <div class="tb-channel-kanban-card__metric"><div class="tb-channel-kanban-card__metric-value">{subscribers}</div><div class="tb-channel-kanban-card__metric-label">{subscribers_label}</div></div>
-            <div class="tb-channel-kanban-card__metric"><div class="tb-channel-kanban-card__metric-value">{views}</div><div class="tb-channel-kanban-card__metric-label">{views_label}</div></div>
-            <div class="tb-channel-kanban-card__metric"><div class="tb-channel-kanban-card__metric-value">{videos}</div><div class="tb-channel-kanban-card__metric-label">{videos_label}</div></div>
-          </div>
-          <div class="tb-channel-kanban-card__status-row">
-            <div class="tb-channel-kanban-card__status tb-channel-kanban-card__status--doing"><strong>{in_production}</strong>{production_label}</div>
-            <div class="tb-channel-kanban-card__status tb-channel-kanban-card__status--done"><strong>{completed}</strong>{completed_label}</div>
-          </div>
-          <div class="tb-channel-kanban-card__titles">▣ <strong>{titled}</strong> {titles_label}</div>
-        </div>
-        """,
-        unsafe_allow_html=True,
-    )
-
-
-def render_registered_channels_kanban(channels: list[dict[str, Any]]) -> None:
-    """Render all registered channels in a responsive three-column Kanban grid."""
-    for row_start in range(0, len(channels), 3):
-        channel_columns = st.columns(3)
-        for column, channel in zip(channel_columns, channels[row_start:row_start + 3]):
-            with column:
-                _render_channel_kanban_card(channel)
-
-
 def render_channels():
     st.title("Canais Youtube")
     st.caption("Escolha entre importar dados públicos do YouTube ou preencher o canal manualmente.")
@@ -1551,7 +1432,7 @@ def render_channels():
         with lookup_cols[0]:
             lookup_mode = st.radio("Método de consulta", ["Página pública — sem API Key", "YouTube Data API — API Key opcional"], horizontal=True, key="youtube_channel_lookup_mode")
         with lookup_cols[1]:
-            st.radio("Apresentação dos canais", ["Lista", "Kanban"], horizontal=True, key="youtube_channels_view_mode")
+            st.caption("Os canais cadastrados são apresentados apenas em lista.")
         col1, col2 = st.columns([1, 1])
         with col1:
             if st.button("Buscar no YouTube", type="primary", use_container_width=True, key="youtube_channel_lookup"):
@@ -1587,17 +1468,17 @@ def render_channels():
                 handle = st.text_input("Handle", value=imported.get("handle", ""), key="yt_import_handle")
                 language = st.selectbox("Idioma", list(LANGUAGE_CODES), index=list(LANGUAGE_CODES).index(language_code(imported.get("language") or "pt")), format_func=language_label, key="yt_import_language")
                 style = st.selectbox("Estilo wide", ["Pexels/Pixabay", "full_ia", "Apenas Música"], index=0, key="yt_import_style")
-                blueprint = st.selectbox("Blueprint padrão do canal", blueprint_ids, index=blueprint_ids.index(imported_blueprint) if imported_blueprint in blueprint_ids else 0, format_func=lambda item: blueprint_labels.get(item, item or "Sem Blueprint padrão"), key="yt_import_blueprint")
+                blueprint = st.selectbox("Blueprint Padrão", blueprint_ids, index=blueprint_ids.index(imported_blueprint) if imported_blueprint in blueprint_ids else 0, format_func=lambda item: blueprint_labels.get(item, item or "Sem Blueprint padrão"), key="yt_import_blueprint")
                 voice_options = voice_catalog(imported.get("default_voice") or imported.get("voice", ""))
                 current_voice = imported.get("default_voice") or imported.get("voice", "")
-                voice = st.selectbox("Voz padrão do canal", voice_options, index=voice_options.index(current_voice) if current_voice in voice_options else 0, format_func=lambda item: item or "Sem voz padrão", key="yt_import_voice")
+                voice = st.selectbox("Narrador/Voz Padrão", voice_options, index=voice_options.index(current_voice) if current_voice in voice_options else 0, format_func=lambda item: item or "Sem voz padrão", key="yt_import_voice")
                 imported_account_id = str(imported.get("google_account_id", ""))
                 google_account_id = st.selectbox("Conta Google para Upload directo", youtube_account_ids, index=youtube_account_ids.index(imported_account_id) if imported_account_id in youtube_account_ids else 0, format_func=lambda item: youtube_account_labels.get(item, item), key="yt_import_google_account_id")
                 st.caption("O DELEGATED_SESSION_ID é lido exclusivamente do documento JSON da conta Google associada.")
                 automation_on = st.toggle("Automação ON", value=bool(imported.get("automation_on", False)), key="yt_import_automation_on")
                 automation_time = st.text_input("Horário diário (HH:MM)", value=imported.get("automation_time", "00:00"), key="yt_import_automation_time")
                 description = st.text_area("Descrição", value=imported.get("description", ""), key="yt_import_description")
-                niche = st.text_input("Canais de Referência / Nicho", value=imported.get("niche", ""), key="yt_import_niche")
+                niche = st.text_input("Nicho", value=imported.get("niche", ""), key="yt_import_niche")
                 metrics = st.columns(3)
                 with metrics[0]: subscriber_count = st.number_input("Inscritos", min_value=0, value=int(imported.get("subscriber_count") or 0), key="yt_import_subscribers")
                 with metrics[1]: video_count = st.number_input("Vídeos", min_value=0, value=int(imported.get("video_count") or 0), key="yt_import_videos")
@@ -1733,15 +1614,15 @@ def render_channels():
             url = st.text_input("URL do canal", placeholder="https://youtube.com/@seucanal", key="manual_channel_url")
             handle = st.text_input("Handle", placeholder="@seucanal", key="manual_channel_handle")
             description = st.text_area("Descrição", key="manual_channel_description")
-            niche = st.text_input("Canais de Referência / Nicho", placeholder="Ex.: História militar, mistérios, ciência", key="manual_channel_niche")
+            niche = st.text_input("Nicho", placeholder="Ex.: História militar, mistérios, ciência", key="manual_channel_niche")
             language = st.selectbox("Idioma", list(LANGUAGE_CODES), index=list(LANGUAGE_CODES).index("pt"), format_func=language_label, key="manual_channel_language")
             style = st.selectbox("Estilo wide", ["Pexels/Pixabay", "full_ia", "Apenas Música"], index=0, key="manual_channel_style")
             manual_blueprint_items = blueprint_catalog()
             manual_blueprint_ids = [item[0] for item in manual_blueprint_items]
             manual_blueprint_labels = {item[0]: item[1] for item in manual_blueprint_items}
-            blueprint = st.selectbox("Blueprint padrão do canal", manual_blueprint_ids, format_func=lambda item: manual_blueprint_labels.get(item, item or "Sem Blueprint padrão"), key="manual_channel_blueprint")
+            blueprint = st.selectbox("Blueprint Padrão", manual_blueprint_ids, format_func=lambda item: manual_blueprint_labels.get(item, item or "Sem Blueprint padrão"), key="manual_channel_blueprint")
             voice_options = voice_catalog()
-            voice = st.selectbox("Voz padrão do canal", voice_options, format_func=lambda item: item or "Sem voz padrão", key="manual_channel_voice")
+            voice = st.selectbox("Narrador/Voz Padrão", voice_options, format_func=lambda item: item or "Sem voz padrão", key="manual_channel_voice")
             google_account_id = st.selectbox("Conta Google para Upload directo", youtube_account_ids, format_func=lambda item: youtube_account_labels.get(item, item), key="manual_channel_google_account_id")
             st.caption("O DELEGATED_SESSION_ID é lido exclusivamente do documento JSON da conta Google associada.")
             automation_on = st.toggle("Automação ON", value=False, key="manual_channel_automation_on")
@@ -1787,9 +1668,6 @@ def render_channels():
     if not channels:
         st.info("Nenhum canal cadastrado.")
         return
-    if st.session_state.get("youtube_channels_view_mode", "Lista") == "Kanban":
-        render_registered_channels_kanban(channels)
-        return
     for channel in channels:
         channel_id = str(channel["id"])
         edit_key = f"edit_channel_{channel_id}"
@@ -1827,22 +1705,25 @@ def render_channels():
                 render_channel_edit_form(channel, youtube_account_ids, youtube_account_labels, youtube_accounts_by_id)
             else:
                 summary = channel_blueprint_summary(channel)
-                block_cols = st.columns(3)
+                channel_language = language_label(channel.get("language") or "pt")
+                block_cols = st.columns(4, gap="small")
                 with block_cols[0]:
-                    st.markdown(f"**Prompts do Canal**\n\n{summary['name']}")
-                    if st.button("Editar Prompts", key=f"edit_prompts_{channel_id}", use_container_width=True):
+                    st.markdown(f"**Blueprint Padrão**\n\n{summary['name']}")
+                    if st.button("Editar Blueprint", key=f"edit_prompts_{channel_id}", use_container_width=True):
                         st.session_state[edit_key] = True
                         st.rerun()
                 with block_cols[1]:
-                    st.markdown(f"**Canais de Referência**\n\n{channel_niche_label(channel)}")
+                    st.markdown(f"**Nicho**\n\n{channel_niche_label(channel)}")
                     if st.button("Editar Nicho", key=f"edit_niche_{channel_id}", use_container_width=True):
                         st.session_state[edit_key] = True
                         st.rerun()
                 with block_cols[2]:
-                    st.markdown(f"**Narrador**\n\n{summary['voice'] or 'Sem voz padrão'}")
-                    if st.button("Configurar Narrador", key=f"edit_voice_{channel_id}", use_container_width=True):
+                    st.markdown(f"**Narrador/Voz Padrão**\n\n{summary['voice'] or 'Sem voz padrão'}")
+                    if st.button("Configurar Narrador/Voz", key=f"edit_voice_{channel_id}", use_container_width=True):
                         st.session_state[edit_key] = True
                         st.rerun()
+                with block_cols[3]:
+                    st.markdown(f"**Idioma**\n\n{channel_language}")
 
             channel_account_ids = list(youtube_account_ids)
             current_channel_account_id = str(channel.get("google_account_id", ""))
@@ -2449,6 +2330,7 @@ def render_new_video(page_title: str = "Criação de Vídeos", prefix: str = "ne
                         tasks = create_tasks_for_batch(batch)
                         st.success(f"Lote {batch['id']} criado com {len(tasks)} tarefa(s). Abra {ui_text('Backlog Vídeos', current_ui_language())} para acompanhar.")
 
+    _render_pipeline_progress_panel()
     if draft_tab is not None:
         with draft_tab:
             render_video_from_draft()
@@ -3315,10 +3197,106 @@ def render_python_editor():
                 st.error(str(exc))
 
 
+_PIPELINE_STAGE_LABELS = {
+    "niche": "Tema",
+    "blueprint": "Blueprint",
+    "brand": "Branding",
+    "topic": "Tema",
+    "script": "Roteiro",
+    "title": "Título",
+    "keywords": "Keywords",
+    "thumbnail_prompt": "Prompt da thumbnail",
+    "thumbnail": "Thumbnail",
+    "video": "Vídeo",
+    "edit": "Edição",
+    "upload": "Upload",
+    "idle": "A aguardar",
+}
+
+
+def _pipeline_progress_value(task: dict[str, Any]) -> int:
+    try:
+        return max(0, min(100, int(task.get("progress") or 0)))
+    except (TypeError, ValueError):
+        return 0
+
+
+def _pipeline_stage_label(task: dict[str, Any]) -> str:
+    stage = str(task.get("stage") or "pipeline")
+    return _PIPELINE_STAGE_LABELS.get(stage, stage.replace("_", " ").title())
+
+
+def _pipeline_time_age(value: Any) -> str:
+    text = str(value or "").strip()
+    if not text:
+        return "sem actualização registada"
+    try:
+        parsed = datetime.fromisoformat(text)
+        if parsed.tzinfo is None:
+            parsed = parsed.replace(tzinfo=timezone.utc)
+        seconds = max(0, int((datetime.now(timezone.utc) - parsed.astimezone(timezone.utc)).total_seconds()))
+    except ValueError:
+        return f"última actualização: {text}"
+    if seconds < 60:
+        return f"actualizado há {seconds}s"
+    if seconds < 3600:
+        return f"actualizado há {seconds // 60}min"
+    return f"actualizado há {seconds // 3600}h"
+
+
+def _render_pipeline_worker_banner(worker_status: dict[str, Any], active_count: int) -> None:
+    if worker_status.get("alive"):
+        stage = _PIPELINE_STAGE_LABELS.get(str(worker_status.get("stage") or "idle"), str(worker_status.get("stage") or "idle"))
+        progress = max(0, min(100, int(worker_status.get("progress") or 0)))
+        st.success(f"Worker de vídeo activo · {active_count} tarefa(s) em execução · {stage} · {progress}%")
+    else:
+        st.warning("Worker de vídeo sem heartbeat recente. O launcher deve estar aberto para processar as tarefas.")
+    heartbeat = worker_status.get("last_heartbeat_at") or worker_status.get("updated_at")
+    if heartbeat:
+        st.caption(f"{_pipeline_time_age(heartbeat)} · timeout de execução: {STALE_TASK_SECONDS // 60} minutos")
+    if worker_status.get("last_error"):
+        st.error(f"Último erro do worker: {worker_status['last_error']}")
+
+
+@st.fragment(run_every=5.0)
+def _render_pipeline_progress_live() -> None:
+    """Poll the persisted pipeline state only while video tasks are active."""
+    worker_status = load_pipeline_worker_status()
+    tasks = read_json("tasks.json", [])
+    active = [task for task in tasks if isinstance(task, dict) and str(task.get("state") or "") == "doing"]
+    if not worker_status.get("alive") and active:
+        recovered = recover_stale_tasks()
+        if recovered:
+            tasks = read_json("tasks.json", [])
+            active = [task for task in tasks if isinstance(task, dict) and str(task.get("state") or "") == "doing"]
+            worker_status = load_pipeline_worker_status()
+    if not active:
+        # A fragment that was already polling must stop itself after the worker
+        # reaches done/failed; otherwise Streamlit keeps refreshing an obsolete
+        # fragment even though the page no longer renders an active task.
+        st.rerun(scope="app")
+        return
+    _render_pipeline_worker_banner(worker_status, len(active))
+    for task in active:
+        progress = _pipeline_progress_value(task)
+        label = str(task.get("title") or task.get("topic") or task.get("id") or "Vídeo")
+        st.progress(progress, text=f"{label} · {_pipeline_stage_label(task)} · {progress}%")
+        st.caption(f"{task.get('channel_name') or 'Canal'} · {_pipeline_time_age(task.get('updated_at'))}")
+        if task.get("error"):
+            st.error(str(task.get("error")))
+
+
+def _render_pipeline_progress_panel() -> None:
+    tasks = read_json("tasks.json", [])
+    if any(isinstance(task, dict) and str(task.get("state") or "") == "doing" for task in tasks):
+        _render_pipeline_progress_live()
+
+
 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", [])
     if not tasks:
         st.info("Nenhum vídeo criado.")
@@ -3341,8 +3319,16 @@ def render_videos():
                     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[2]: st.write(task.get("stage", "—"))
-            with cols[3]: st.write(task.get("state", "—"))
+            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])
+
             with cols[4]:
                 state = str(task.get("state") or "")
                 start_col, stop_col = st.columns(2)
@@ -3585,20 +3571,25 @@ def render_automation():
             with cols[1]:
                 st.write(f"**{channel.get('name', 'Sem nome')}**")
                 st.caption(channel.get("handle") or channel.get("url") or "sem URL")
-                st.caption(f"Blueprint actual: {channel.get('default_blueprint_id') or channel.get('blueprint_id') or '—'} · Voz actual: {channel.get('default_voice') or channel.get('voice') or '—'}")
             blueprint_ids, blueprint_labels, current_blueprint, voice_options, current_voice = channel_default_options(channel)
-            default_cols = st.columns(2)
+            default_cols = st.columns(4, gap="small")
             with default_cols[0]:
+                st.markdown("**Idioma Padrão**")
+                st.caption(language_label(channel.get("language") or "pt"))
+            with default_cols[1]:
                 automation_blueprint = st.selectbox(
-                    "Blueprint padrão",
+                    "Blueprint Padrão",
                     blueprint_ids,
                     index=blueprint_ids.index(current_blueprint) if current_blueprint in blueprint_ids else 0,
                     format_func=lambda item: blueprint_labels.get(item, item or "Sem Blueprint padrão"),
                     key=f"automation_blueprint_{channel_id}",
                 )
-            with default_cols[1]:
+            with default_cols[2]:
+                st.markdown("**Nicho Padrão**")
+                st.caption(channel_niche_label(channel))
+            with default_cols[3]:
                 automation_voice = st.selectbox(
-                    "Voz padrão",
+                    "Narrador/Voz Padrão",
                     voice_options,
                     index=voice_options.index(current_voice) if current_voice in voice_options else 0,
                     format_func=lambda item: item or "Sem voz padrão",

package/hermes_ui/pipeline_worker.py

@@ -2,8 +2,10 @@ from __future__ import annotations
 
 import json
 import os
+import queue
 import re
 import subprocess
+import threading
 import time
 from datetime import datetime, timezone
 from pathlib import Path
@@ -20,13 +22,18 @@ from hermes_ui.thumbnail_generation import generate_thumbnail_image
 PIPELINE_LOCK_FILENAME = "pipeline_worker.lock"
 PIPELINE_LOG_FILENAME = "pipeline_worker.json"
 VIDEO_TIMEOUT_SECONDS = 20 * 60
-STALE_TASK_SECONDS = 2 * 60 * 60
+STALE_TASK_SECONDS = VIDEO_TIMEOUT_SECONDS + 5 * 60
+WORKER_HEARTBEAT_TIMEOUT_SECONDS = 15
 
 
 class PipelineError(RuntimeError):
     """Raised when a pipeline stage cannot complete with an actionable error."""
 
 
+class PipelineStopped(PipelineError):
+    """Raised when the user stops a task while the worker is processing it."""
+
+
 def _now() -> str:
     return datetime.now(timezone.utc).isoformat()
 
@@ -41,16 +48,45 @@ def _lock_path() -> Path:
     return STORAGE / "state" / PIPELINE_LOCK_FILENAME
 
 
+def _pid_alive(pid: int) -> bool:
+    if pid <= 0:
+        return False
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    except OSError:
+        return False
+    return True
+
+
 def _acquire_lock() -> Path | None:
     path = _lock_path()
     path.parent.mkdir(parents=True, exist_ok=True)
     try:
         descriptor = os.open(path, os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+    except FileExistsError:
+        try:
+            old_pid = int(path.read_text(encoding="utf-8").strip())
+        except (OSError, ValueError):
+            old_pid = 0
+        if _pid_alive(old_pid):
+            return None
+        try:
+            path.unlink()
+        except OSError:
+            return None
+        try:
+            descriptor = os.open(path, os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+        except FileExistsError:
+            return None
+    try:
         os.write(descriptor, str(os.getpid()).encode("ascii"))
+    finally:
         os.close(descriptor)
-        return path
-    except FileExistsError:
-        return None
+    return path
 
 
 def _write_worker_state(**updates: Any) -> None:
@@ -62,6 +98,71 @@ def _write_worker_state(**updates: Any) -> None:
     write_json(PIPELINE_LOG_FILENAME, state)
 
 
+def _worker_heartbeat(**updates: Any) -> None:
+    _write_worker_state(
+        worker_pid=os.getpid(),
+        last_heartbeat_at=_now(),
+        **updates,
+    )
+
+
+def _parse_timestamp(value: Any) -> datetime | None:
+    text = str(value or "").strip()
+    if not text:
+        return None
+    try:
+        parsed = datetime.fromisoformat(text)
+    except ValueError:
+        return None
+    return parsed if parsed.tzinfo else parsed.replace(tzinfo=timezone.utc)
+
+
+def load_pipeline_worker_status() -> dict[str, Any]:
+    """Return the persisted worker heartbeat for the Backlog UI."""
+    status = read_json(PIPELINE_LOG_FILENAME, {})
+    if not isinstance(status, dict):
+        status = {}
+    heartbeat_at = _parse_timestamp(status.get("last_heartbeat_at"))
+    status["alive"] = bool(
+        heartbeat_at
+        and (datetime.now(timezone.utc) - heartbeat_at.astimezone(timezone.utc)).total_seconds()
+        <= WORKER_HEARTBEAT_TIMEOUT_SECONDS
+    )
+    return status
+
+
+def _recover_stale_tasks() -> list[str]:
+    """Convert abandoned doing tasks to failed after the worker timeout window."""
+    from hermes_ui.domain import update_task
+
+    recovered: list[str] = []
+    current_time = datetime.now(timezone.utc)
+    for task in read_json("tasks.json", []):
+        if not isinstance(task, dict) or str(task.get("state") or "") != "doing":
+            continue
+        updated_at = _parse_timestamp(task.get("updated_at"))
+        if not updated_at:
+            continue
+        age_seconds = (current_time - updated_at.astimezone(timezone.utc)).total_seconds()
+        if age_seconds <= STALE_TASK_SECONDS:
+            continue
+        task_id = str(task.get("id") or "")
+        if not task_id:
+            continue
+        message = (
+            f"A tarefa ficou sem heartbeat durante mais de {STALE_TASK_SECONDS // 60} minutos. "
+            "Foi marcada como falhada para evitar execução eterna; reveja o log do worker."
+        )
+        update_task(task_id, {"state": "failed", "error": message, "failed_stage": task.get("stage") or "pipeline"})
+        recovered.append(task_id)
+    return recovered
+
+
+def recover_stale_tasks() -> list[str]:
+    """Public wrapper used by the UI to recover tasks after an abrupt worker exit."""
+    return _recover_stale_tasks()
+
+
 def _task_by_id(task_id: str) -> dict[str, Any] | None:
     return next((task for task in read_json("tasks.json", []) if isinstance(task, dict) and task.get("id") == task_id), None)
 
@@ -69,9 +170,20 @@ def _task_by_id(task_id: str) -> dict[str, Any] | None:
 def _update(task_id: str, **updates: Any) -> dict[str, Any]:
     from hermes_ui.domain import update_task
 
+    current = _task_by_id(task_id)
+    if not current:
+        raise PipelineError(f"Tarefa {task_id} deixou de existir durante a execução.")
+    if str(current.get("state") or "") in {"blocked", "cancelled"}:
+        raise PipelineStopped("A tarefa foi parada pelo utilizador.")
     updated = update_task(task_id, updates)
     if not updated:
         raise PipelineError(f"Tarefa {task_id} deixou de existir durante a execução.")
+    _worker_heartbeat(
+        task_id=task_id,
+        status="running",
+        stage=str(updated.get("stage") or "pipeline"),
+        progress=int(updated.get("progress") or 0),
+    )
     return updated
 
 
@@ -111,6 +223,75 @@ def _save_json_artifact(task_id: str, name: str, payload: dict[str, Any]) -> str
     return str(path)
 
 
+def _configured_moneyprinter_root(settings: dict[str, Any]) -> Path | None:
+    """Resolve the installed MoneyPrinterTurbo project selected by the user."""
+    configured = str(settings.get("moneyprinter_path") or os.environ.get("MONEYPRINTER_PATH") or "").strip()
+    if not configured:
+        return None
+    root = Path(configured).expanduser().resolve()
+    if not (root / "cli.py").is_file():
+        raise PipelineError(f"A pasta configurada do MoneyPrinterTurbo não contém cli.py: {root}")
+    if not ((root / "config.toml").is_file() or (root / "config.example.toml").is_file()):
+        raise PipelineError(f"A pasta configurada do MoneyPrinterTurbo não contém config.toml: {root}")
+    return root
+
+
+def _helper_output_value(output: str, key: str) -> str:
+    match = re.search(rf"(?m)^{re.escape(key)}=(.+)$", output)
+    return match.group(1).strip() if match else ""
+
+
+def _redact_helper_output(text: str) -> str:
+    for key in ("MPT_LLM_API_KEY", "MPT_PEXELS_API_KEY"):
+        secret = os.environ.get(key, "").strip()
+        if secret:
+            text = text.replace(secret, "[redacted]")
+    return text
+
+
+def _persist_video_diagnostics(task: dict[str, Any], output: str) -> dict[str, str]:
+    """Persist only bounded helper diagnostics and return its declared file paths."""
+    task_id = str(task.get("id") or "").strip()
+    if not task_id:
+        return {}
+    log_file = _helper_output_value(output, "LOG_FILE")
+    result_file = _helper_output_value(output, "RESULT_FILE")
+    try:
+        payload: dict[str, Any] = {
+            "captured_at": _now(),
+            "log_file": log_file,
+            "result_file": result_file,
+            "output_tail": _redact_helper_output(output[-6000:]),
+        }
+        artifact_path = _save_json_artifact(task_id, "video-diagnostics", payload)
+        current = _task_by_id(task_id) or task
+        artifacts = dict(current.get("artifacts") or {})
+        artifacts["video_diagnostics"] = artifact_path
+        updates: dict[str, Any] = {"artifacts": artifacts}
+        if log_file:
+            updates["video_log"] = log_file
+            artifacts["video_log"] = log_file
+        if result_file:
+            updates["video_result"] = result_file
+            artifacts["video_result"] = result_file
+        from hermes_ui.domain import update_task
+        update_task(task_id, updates)
+        return {"log_file": log_file, "result_file": result_file, "artifact": artifact_path}
+    except Exception:
+        # Diagnostics must never hide the actual generation error.
+        return {"log_file": log_file, "result_file": result_file}
+
+
+def _stop_process(process: subprocess.Popen[str]) -> None:
+    if process.poll() is None:
+        process.kill()
+    try:
+        process.wait(timeout=5)
+    except subprocess.TimeoutExpired:
+        process.kill()
+        process.wait()
+
+
 def _run_video_helper(task: dict[str, Any]) -> Path:
     helper_dir = Path(__file__).resolve().parents[1] / "seed" / "skills"
     helper = helper_dir / "mpt_agent.py"
@@ -120,6 +301,10 @@ def _run_video_helper(task: dict[str, Any]) -> Path:
     if not subject:
         raise PipelineError("A etapa Vídeo não recebeu um tema válido.")
     settings = _settings()
+    configured_root = _configured_moneyprinter_root(settings)
+    task_id = str(task.get("id") or "").strip()
+    if not task_id:
+        raise PipelineError("A tarefa de vídeo não tem um identificador válido.")
     env = os.environ.copy()
     card = active_llm_card(settings)
     provider = str(card.get("provider") or "openai").strip()
@@ -134,23 +319,97 @@ def _run_video_helper(task: dict[str, Any]) -> Path:
     for key, value in env_values.items():
         if value:
             env[key] = value
-    command = ["uv", "run", "--no-project", "--python", "3.11", "python", "mpt_agent.py", "--subject", subject]
+    command = ["uv", "run", "--no-project", "--python", "3.11", "python", "mpt_agent.py"]
+    if configured_root:
+        command.extend(["--root", str(configured_root)])
+    command.extend(["--subject", subject])
+    output_lines: list[str] = []
+    line_queue: queue.Queue[str | None] = queue.Queue()
+    started_at = time.monotonic()
+    process: subprocess.Popen[str] | None = None
+
+    def _read_output() -> None:
+        if process is None or process.stdout is None:
+            line_queue.put(None)
+            return
+        for line in iter(process.stdout.readline, ""):
+            line_queue.put(line.rstrip())
+        process.stdout.close()
+        line_queue.put(None)
+
     try:
-        result = subprocess.run(command, cwd=helper_dir, env=env, capture_output=True, text=True, timeout=VIDEO_TIMEOUT_SECONDS, check=False)
+        process = subprocess.Popen(
+            command,
+            cwd=helper_dir,
+            env=env,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+        )
     except FileNotFoundError as exc:
         raise PipelineError("O comando uv não está instalado; não foi possível iniciar a geração de vídeo.") from exc
-    except subprocess.TimeoutExpired as exc:
-        raise PipelineError(f"A etapa Vídeo excedeu o limite de {VIDEO_TIMEOUT_SECONDS // 60} minutos e foi encerrada.") from exc
-    output = "\n".join(part for part in (result.stdout, result.stderr) if part)
-    if result.returncode == 10:
+
+    reader = threading.Thread(target=_read_output, name=f"mpt-output-{task.get('id', 'video')}", daemon=True)
+    reader.start()
+    output_finished = False
+    last_heartbeat = 0.0
+    try:
+        while True:
+            try:
+                line = line_queue.get(timeout=0.5)
+                if line is None:
+                    output_finished = True
+                elif line:
+                    output_lines.append(line)
+            except queue.Empty:
+                pass
+            elapsed = time.monotonic() - started_at
+            if elapsed - last_heartbeat >= 5:
+                # O helper expõe o resultado final, mas não uma percentagem estável.
+                # Mantemos uma faixa reservada para a etapa de vídeo e avançamos-a
+                # lentamente enquanto o processo responde, sem fingir conclusão.
+                video_progress = min(79, 68 + int(elapsed // 15))
+                current_task = _task_by_id(task_id)
+                if current_task and str(current_task.get("state") or "") in {"blocked", "cancelled"}:
+                    _stop_process(process)
+                    raise PipelineStopped("A tarefa foi parada pelo utilizador.")
+                _update(
+                    task_id,
+                    progress=video_progress,
+                    video_elapsed_seconds=int(elapsed),
+                )
+                _worker_heartbeat(
+                    task_id=str(task.get("id") or ""),
+                    status="running",
+                    stage="video",
+                    progress=video_progress,
+                    video_elapsed_seconds=int(elapsed),
+                )
+                last_heartbeat = elapsed
+            if process.poll() is not None and output_finished:
+                break
+            if elapsed >= VIDEO_TIMEOUT_SECONDS:
+                _stop_process(process)
+                raise PipelineError(f"A etapa Vídeo excedeu o limite de {VIDEO_TIMEOUT_SECONDS // 60} minutos e foi encerrada.")
+    finally:
+        reader.join(timeout=2)
+        _persist_video_diagnostics(task, "\n".join(output_lines))
+    if process.returncode is None:
+        process.wait(timeout=5)
+    result_code = process.returncode
+    output = "\n".join(output_lines)
+    _persist_video_diagnostics(task, output)
+    if result_code == 10:
         raise PipelineError("A geração de vídeo precisa de credenciais adicionais do MoneyPrinterTurbo.")
-    if result.returncode != 0:
-        detail = output[-1200:].strip() or "erro sem detalhes devolvidos pelo helper"
+    if result_code != 0:
+        detail = _redact_helper_output(output[-1200:]).strip() or "erro sem detalhes devolvidos pelo helper"
         raise PipelineError(f"MoneyPrinterTurbo falhou na etapa Vídeo: {detail}")
     match = re.search(r"(?m)^VIDEO_FILE=(.+)$", output)
     video_path = Path(match.group(1).strip()).expanduser() if match else None
     if not video_path or not video_path.is_file() or video_path.stat().st_size <= 0:
-        result_file = Path.home() / "MoneyPrinterTurbo" / ".agent-logs" / "moneyprinterturbo-video" / "latest-result.json"
+        result_root = configured_root or (Path.home() / "MoneyPrinterTurbo")
+        result_file = result_root / ".agent-logs" / "moneyprinterturbo-video" / "latest-result.json"
         if result_file.is_file():
             try:
                 payload = json.loads(result_file.read_text(encoding="utf-8"))
@@ -285,23 +544,33 @@ def run_once() -> dict[str, Any]:
     if lock is None:
         return {"ok": True, "busy": True}
     try:
+        recovered = _recover_stale_tasks()
         tasks = read_json("tasks.json", [])
         candidate = next((task for task in tasks if isinstance(task, dict) and task.get("state") in {"to_do", "doing"}), None)
         if not candidate:
-            _write_worker_state(last_task_id=None, last_error="", status="idle")
-            return {"ok": True, "status": "idle"}
+            _worker_heartbeat(last_task_id=None, last_error="", status="idle", stage="idle", progress=0, recovered_task_ids=recovered)
+            return {"ok": True, "status": "idle", "recovered_task_ids": recovered}
         task_id = str(candidate.get("id") or "")
-        _write_worker_state(last_task_id=task_id, status="running", last_error="")
+        _worker_heartbeat(last_task_id=task_id, status="running", stage=str(candidate.get("stage") or "pipeline"), progress=int(candidate.get("progress") or 0), last_error="", recovered_task_ids=recovered)
         try:
             result = _run_task(candidate)
-            _write_worker_state(status="completed", last_error="")
-            return {"ok": True, "task_id": task_id, "task": result}
+            _worker_heartbeat(status="completed", last_error="", stage=str(result.get("stage") or "upload"), progress=100, task_id=task_id)
+            return {"ok": True, "task_id": task_id, "task": result, "recovered_task_ids": recovered}
+        except PipelineStopped as exc:
+            current_task = _task_by_id(task_id) or candidate
+            current_state = str(current_task.get("state") or "")
+            if current_state not in {"blocked", "cancelled"}:
+                from hermes_ui.domain import update_task
+                update_task(task_id, {"state": "blocked", "error": str(exc), "failed_stage": current_task.get("stage") or "pipeline"})
+            _worker_heartbeat(status="stopped", last_error=str(exc), stage=str(current_task.get("stage") or "pipeline"), progress=int(current_task.get("progress") or 0), task_id=task_id)
+            return {"ok": True, "task_id": task_id, "status": "stopped", "recovered_task_ids": recovered}
         except Exception as exc:
             message = str(exc)[:2000]
             from hermes_ui.domain import update_task
-            update_task(task_id, {"state": "failed", "error": message})
-            _write_worker_state(status="failed", last_error=message)
-            return {"ok": False, "task_id": task_id, "error": message}
+            current_task = _task_by_id(task_id) or candidate
+            update_task(task_id, {"state": "failed", "error": message, "failed_stage": current_task.get("stage") or "pipeline"})
+            _worker_heartbeat(status="failed", last_error=message, stage=str(current_task.get("stage") or "pipeline"), progress=int(current_task.get("progress") or 0), task_id=task_id)
+            return {"ok": False, "task_id": task_id, "error": message, "recovered_task_ids": recovered}
     finally:
         try:
             lock.unlink()
@@ -311,6 +580,7 @@ def run_once() -> dict[str, Any]:
 
 def run_worker(interval_seconds: int = 5) -> None:
     ensure_storage()
+    _worker_heartbeat(status="starting", stage="idle", progress=0, last_error="")
     while True:
         run_once()
         time.sleep(max(2, int(interval_seconds)))

package/package.json

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