@danhachuel/thunderbolt 0.3.44 → 0.3.46

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.44
+> **Versão deste manual:** 0.3.46
 > **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 --prefer-online @danhachuel/thunderbolt@0.3.44 install
+npx.cmd --yes --prefer-online @danhachuel/thunderbolt@0.3.46 install
 ```
 
 Linux/macOS:
 
 ```bash
-npx --yes --prefer-online @danhachuel/thunderbolt@0.3.44 install
+npx --yes --prefer-online @danhachuel/thunderbolt@0.3.46 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.
@@ -114,7 +114,7 @@ A instalação normal é **segura para actualizações**: preserva `storage`, Bl
 Se quiser apagar absolutamente tudo de forma intencional, use o comando destrutivo separado:
 
 ```powershell
-npx.cmd --yes --prefer-online @danhachuel/thunderbolt@0.3.44 install --purge-data
+npx.cmd --yes --prefer-online @danhachuel/thunderbolt@0.3.46 install --purge-data
 ```
 
 O parâmetro `--purge-data` apaga Blueprints, Brandings, configurações, storage e artefactos locais. Não o use numa actualização normal.
@@ -363,11 +363,11 @@ Em **Configuração API > API Keys**, o expander **LLM — providers e modelos**
 
 O bloco **Limite LLM NVIDIA NIM** permite ligar **Activar limitador NVIDIA NIM — 40 RPM**. O valor padrão é 40 pedidos numa janela de 60 segundos. O contador é persistido localmente por cartão/chave e aplica-se à criação manual, aos workers e às automações. A opção vem desligada para não alterar instalações existentes; ligue-a quando o endpoint activo for NVIDIA NIM e a sua conta tiver esse limite.
 
-O expander **Imagem e Video** substitui o antigo bloco isolado da Nano Banana. Os cartões disponíveis são **Nano Banana**, **Pollinations.ai**, **Agnes AI**, **Hugging Face Inference API**, **Cloudflare Workers AI**, **InferencePort Proxy**, **阿里云 (Alibaba Cloud Model Studio)**, **KIE AI** e **FAL AI**. Em cada cartão, configure a API key/token, o modelo, a Base URL, o estado **Provider activo**, a participação no **Pool Imagem**, a participação no **Pool Vídeo** e a prioridade. O botão **Testar Chamada API** faz apenas uma verificação read-only; não inicia geração de imagem ou vídeo.
+O expander **Imagem e Video** substitui o antigo bloco isolado da Nano Banana. Os cartões disponíveis são **Nano Banana**, **Pollinations.ai**, **Agnes AI**, **Hugging Face Inference API**, **Cloudflare Workers AI**, **InferencePort Proxy**, **阿里云 (Alibaba Cloud Model Studio)**, **KIE AI** e **FAL AI**. Em cada cartão, configure a API key/token, o modelo, a Base URL, o estado **Provider activo**, a participação no **Pool Imagem**, a participação no **Pool Vídeo** e a prioridade. **Image Size** e **Aspect Ratio** não aparecem nos cartões e não são editáveis: são defaults internos aplicados automaticamente no prompt da geração. O botão **Testar Chamada API** faz apenas uma verificação read-only; não inicia geração de imagem ou vídeo.
 
 | Provider | Configuração mínima | Pool suportado |
 |---|---|---|
-| Nano Banana | API key, modelo Gemini e parâmetros da imagem | Imagem |
+| Nano Banana | API key e modelo Gemini; composição aplicada internamente | Imagem |
 | Pollinations.ai | API key/token, modelo e Base URL | Imagem e vídeo |
 | Agnes AI | API key, modelo e Base URL | Imagem e vídeo |
 | Hugging Face Inference API | Token, modelo e `https://router.huggingface.co/v1` | Imagem |
@@ -425,9 +425,9 @@ Na primeira execução, a barra lateral apresenta **Início**, **Niche Finder**,
 
 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.
+A percentagem representa o avanço conhecido do pipeline: tema, roteiro, título/keywords, vídeo, prompt da thumbnail, thumbnail 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; quando o MP4 é devolvido, o artefacto é persistido antes da geração de imagem. 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`.
+Uma execução da etapa Vídeo tem limite de 20 minutos. Depois de um MP4 válido, a tarefa fica marcada com `video_ready` e o artefacto é guardado antes da chamada de imagem. Se a quota do provider de thumbnail for excedida, a tarefa pode ser marcada como `failed` na etapa `thumbnail`, mas o vídeo mantém-se disponível em `artifacts.video` para descarga no Backlog, utilização no Upload ou publicação directa depois de carregar uma thumbnail manual. Se o processo externo de vídeo 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.
 
@@ -473,8 +473,8 @@ Após iniciar a aplicação, valide o seguinte percurso:
 4. **Canais:** em **Importar do YouTube**, use o método **Página pública — sem API Key** com um URL `/channel/UC...`, um handle ou uma subpágina `/videos`; o parser resolve o ID, consulta a página pública e tenta o RSS quando necessário. Confirme que o resultado abre o formulário de revisão sem Data API Key. Se o canal não existir ou não fornecer metadados, confirme a mensagem clara e que o formulário de uma pesquisa anterior desaparece. A Data API é opcional e fica separada; em **Cadastro manual**, preencha os dados sem qualquer consulta externa.
 5. **Niche Finder Kaggle:** abra o menu expansível **Niche Finder**, seleccione **Niche Finder Kaggle**, defina os parâmetros dentro do conteúdo principal e confirme que não há preparação automática. Antes do clique, não deve existir download de dataset nem análise. Clique em **Analisar Nichos** para iniciar a preparação dos dados e a análise; depois altere país, engagement, datas e tags e clique novamente para aplicar os novos parâmetros. Em seguida, abra a alternativa independente **Niche Finder Apify**, configure as palavras-chave e filtros na própria aba e confirme que nada é executado antes de clicar em **Pesquisar no Apify**.
 6. **Pipeline > Criação de Vídeos:** teste primeiro o modo **Canal específico** e depois os modos de lote. O campo **Tópico ou briefing** pode ser escrito manualmente ou preenchido pelo botão **Gerar tópico/briefing com IA**; a geração só ocorre após o clique e usa o provider configurado em **Configuração API > API Keys > Serviços e modelos**.
-7. **Criação de Vídeos:** depois de seleccionar o canal, confirme que o painel entre **Canal** e **Estilo wide** mostra o Blueprint, a voz e o idioma, ou **SEM BLUEPRINT CONFIGURADO**. Confirme as quatro áreas fechadas por defeito: **Configurações de vídeo**, **Configurações de áudio**, **Configurações de legendas** e **Gerar Thumbnail com IA**. Depois de existir um tópico e um título inicial, clique em **Gerar Thumbnail com IA**, confirme que apenas o prompt/briefing de thumbnail é criado e que o título permanece igual. Em lote no mesmo canal, confirme uma variante independente para cada vídeo; escolha uma variante, gere a imagem se houver provider configurado e verifique o prompt guardado. Na subaba **Vídeos**, verifique o estado `to_do`, o título escolhido, o estado da thumbnail e os botões **Iniciar** e **Parar**. Confirme também que **Criação de Músicas** mostra o mesmo fluxo com título próprio.
-8. **Lote geral:** confirme que não existe **Canais incluídos** nem selector parcial. A UI deve listar todos os canais cadastrados e criar exactamente uma tarefa por canal, com briefing, título, thumbnail e Blueprint próprios. Use **Gerar tópicos individuais para todos os canais** e depois **Gerar Thumbnail com IA para todos os vídeos**; confirme que a segunda acção não regenera títulos.
+7. **Criação de Vídeos:** depois de seleccionar o canal, confirme que o painel entre **Canal** e **Estilo wide** mostra o Blueprint, a voz e o idioma, ou **SEM BLUEPRINT CONFIGURADO**. Confirme as quatro áreas fechadas por defeito: **Configurações de vídeo**, **Configurações de áudio**, **Configurações de legendas** e **Gerar Thumbnail com IA**. A execução do worker deve seguir **Tema → Roteiro → Título → Keywords → Vídeo → Prompt da thumbnail em JSON → Thumbnail → Upload**. Inicie a tarefa e confirme no Backlog que o MP4 é guardado e descarregável antes da etapa de imagem; se a quota da thumbnail falhar, a tarefa deve conservar `artifacts.video` e `video_ready`. Depois, carregue manualmente a imagem em **Thumbnails** ou gere-a quando houver provider disponível. Em lote no mesmo canal, confirme uma variante independente por vídeo. Confirme também que **Criação de Músicas** mostra o mesmo fluxo com título próprio.
+8. **Lote geral:** confirme que não existe **Canais incluídos** nem selector parcial. A UI deve listar todos os canais cadastrados e criar exactamente uma tarefa por canal, com briefing, título e Blueprint próprios; o prompt e a imagem da thumbnail podem ser preparados depois de o vídeo existir. Use **Gerar tópicos individuais para todos os canais** e, quando desejado, **Gerar Thumbnail com IA para todos os vídeos**; confirme que a segunda acção não regenera títulos.
 9. **Upload:** configure o OAuth Client ID e Secret, autorize primeiro o **youtube-automation-agent** na própria aba, confirme o estado **pronto para publicar**, preencha título/descrição/tags e publique um MP4 real. O botão **Autorizar fallback OAuth** existe apenas para redundância; a Data API Key, se configurada, é exclusivamente para consultas oficiais públicas e nunca substitui OAuth.
 10. **Edição > Limpador de Metadados:** suba um vídeo de terceiro, preencha título, preview, links, timestamps e tags, aplique a limpeza e descarregue a cópia limpa e o manifesto JSON. O original fica preservado e vídeos das páginas de criação não são aceites nesta área.
 11. **Configurações > Configuração API:** confirme que as credenciais ficam locais e não aparecem no Git. Em **API Keys > Fontes de materiais**, seleccione Pexels, Pixabay, Coverr, WaveSpeed AI, LoomLoom, TwelveLabs ou Ficheiros locais. Para uma fonte com API, preencha a primeira chave e use **Adicionar outra chave** para criar quantas linhas forem necessárias; clique em **Guardar fonte e chaves**. Cada fonte mantém a sua própria lista, com deduplicação e rotação interna. Não são pedidos endpoint, proxy, qualidade, codec, FFmpeg, Whisper, directório ou filtros nesta subaba. Na secção **Contas Google/YouTube — canais em lote**, adicione cada conta com o seu e-mail/Gmail, OAuth Client ID, OAuth Client Secret e `sessionInfo` próprios; use **Repetir campos para nova conta** para preparar contas adicionais e o ícone **Apagar conta** para eliminar individualmente a conta, tokens, documento JSON e associações de canais.
@@ -522,7 +522,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 --prefer-online @danhachuel/thunderbolt@0.3.44 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 --prefer-online @danhachuel/thunderbolt@0.3.46 install`; o instalador detecta e reutiliza o que já estiver válido.
 
 ### Niche Finder Apify
 

package/README.md

@@ -69,7 +69,7 @@ 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.44
+## Navegação da UI 0.3.46
 
 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.
 
@@ -85,7 +85,7 @@ 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.
 
-O expander **Imagem e Video** reúne cartões independentes para **Nano Banana**, **Pollinations.ai**, **Agnes AI**, **Hugging Face Inference API**, **Cloudflare Workers AI**, **InferencePort Proxy**, **阿里云 (Alibaba Cloud Model Studio)**, **KIE AI** e **FAL AI**. Cada cartão permite configurar API key/token quando necessário, modelo, Base URL, activar o provider, escolher participação no **Pool Imagem** e/ou **Pool Vídeo**, definir prioridade e executar **Testar Chamada API**. O InferencePort usa por defeito `http://localhost:8080/v1` e não exige chave; o Cloudflare requer Account ID; os restantes providers devem ser preenchidos de acordo com a conta e endpoint disponibilizados pelo serviço.
+O expander **Imagem e Video** reúne cartões independentes para **Nano Banana**, **Pollinations.ai**, **Agnes AI**, **Hugging Face Inference API**, **Cloudflare Workers AI**, **InferencePort Proxy**, **阿里云 (Alibaba Cloud Model Studio)**, **KIE AI** e **FAL AI**. Cada cartão permite configurar API key/token quando necessário, modelo, Base URL, activar o provider, escolher participação no **Pool Imagem** e/ou **Pool Vídeo**, definir prioridade e executar **Testar Chamada API**. Os parâmetros técnicos de composição, como **Image Size** e **Aspect Ratio**, não são apresentados nem editáveis nos cartões: ficam como defaults internos e são acrescentados automaticamente ao prompt da geração de imagem e/ou vídeo. O InferencePort usa por defeito `http://localhost:8080/v1` e não exige chave; o Cloudflare requer Account ID; os restantes providers devem ser preenchidos de acordo com a conta e endpoint disponibilizados pelo serviço.
 
 O router mantém três pools independentes: **LLM textual**, **imagem** e **vídeo**. O failover só passa ao cartão seguinte em quota, timeout, erro de transporte ou HTTP transitório; erros de credencial, endpoint/modelo inexistente ou payload inválido ficam registados e não são mascarados por um provider diferente. O pool de vídeo externo é opcional: quando desligado, o worker continua a usar o motor local MoneyPrinterTurbo; quando ligado, usa apenas os cartões marcados para Pool Vídeo.
 
@@ -101,7 +101,7 @@ A página **Edição > Download Mídia** utiliza a API Python do [yt-dlp](https:
 
 **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.
+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. Quando existe `artifacts.video`, o Backlog mostra que o vídeo está pronto e disponibiliza a descarga do MP4 mesmo que a thumbnail esteja pendente.
 
 ## Canais Youtube — edição por cartão e vídeos recentes
 
@@ -117,7 +117,9 @@ A aba **Criação de Vídeos** permite escrever manualmente o **Tópico ou brief
 
 Entre **Canal** e **Estilo wide**, a UI mostra o Blueprint padrão resolvido do canal, a voz associada e o **Idioma** configurado nesse canal. Ao trocar o canal, o selector **Script Language** é sincronizado automaticamente com o código canónico do novo canal, incluindo a conversão de rótulos legados como `Português` ou `36 – Português (Brasil)`. O valor sincronizado é usado no roteiro, keywords, geração criativa e payload da tarefa; o idioma global só serve como fallback quando não existe canal seleccionado. Quando não existe configuração, apresenta **SEM BLUEPRINT CONFIGURADO** e mantém o idioma do canal visível. Depois do tópico e do título inicial, **Gerar Thumbnail com IA** gera apenas um briefing/prompt de thumbnail e preserva o título existente, sem chamar o gerador de títulos. Em lotes no mesmo canal, é gerada uma variante independente por vídeo e o payload correspondente é atribuído a cada task. A geração da imagem final passa pelo **Pool Imagem**, com failover para os cartões activos elegíveis; as thumbnails guardam conceito, overlay de até quatro palavras, composição, cores, prompt e sinergia com o título.
 
-O pacote criativo é persistido na task. O título escolhido fica pré-preenchido no Upload e a thumbnail é usada quando existe um ficheiro em `artifacts.thumbnail`. Sem provider de imagem configurado, a aplicação conserva o prompt e apresenta **Prompt de thumbnail pronto — imagem pendente de provider de imagem**, sem criar um PNG falso.
+A cascata de criação no worker segue agora a ordem **Tema → Roteiro → Título → Keywords → Vídeo → Prompt da thumbnail em JSON → Thumbnail (gerar imagem) → Upload**. O vídeo é guardado em `artifacts.video` e marcado como `video_ready` antes de qualquer chamada ao provider de imagem. Se a quota da imagem for excedida, a tarefa pode ficar em falha na etapa Thumbnail, mas o MP4 permanece pronto no Backlog para descarregar, utilizar no Upload ou editar a thumbnail posteriormente.
+
+O pacote editorial é persistido na task. O título e as keywords são preparados antes do vídeo; o prompt JSON e a variante visual são criados depois de existir um MP4 válido. A thumbnail é usada no Upload quando existe um ficheiro em `artifacts.thumbnail`. Sem provider de imagem configurado, a aplicação conserva o prompt e apresenta **Prompt de thumbnail pronto — imagem pendente de provider de imagem**, sem criar um PNG falso. A página **Thumbnails** continua a permitir gerar a imagem ou carregar manualmente uma PNG, JPG, JPEG ou WEBP para a tarefa.
 
 No modo **Lote geral**, o Thunderbolt remove a selecção parcial e processa automaticamente todos os canais cadastrados. **Gerar Thumbnail com IA para todos os vídeos** percorre os tópicos individuais já preparados e gera apenas uma thumbnail por canal/vídeo, sem regenerar títulos. É criada exactamente uma tarefa por canal, com briefing, título, thumbnail, Blueprint, voz e contexto próprios; o mesmo tópico nunca é reutilizado para todos os canais. A Automação diária usa o mesmo serviço no horário local de cada canal e não cria o placeholder antigo quando o provider LLM não está configurado.
 

package/app/main.py

@@ -62,7 +62,7 @@ from hermes_ui.thumbnails import (
     upload_thumbnail_image,
 )
 from hermes_ui.draft_video import DRAFT_SETTING_SECTIONS, missing_content_fields, missing_setting_sections, normalise_saved_script, setting_widget_suffixes
-from hermes_ui.creative_generation import CreativeGenerationError, generate_creative_package, generate_thumbnail_prompt, generate_topic_for_channel, generate_video_keywords
+from hermes_ui.creative_generation import CreativeGenerationError, generate_creative_package, generate_thumbnail_prompt, generate_title_and_keywords, generate_topic_for_channel, generate_video_keywords
 from integrations.platforms import IntegrationResult, TikTokAdapter, YouTubeAdapter, fetch_channel_videos_public
 from integrations.tiktok_public import fetch_public_tiktok_profile, normalize_tiktok_reference
 from integrations.postiz import PostizAdapter
@@ -530,6 +530,7 @@ def creative_payload_from_result(channel: dict, topic: str, creative: dict, topi
         "topic_source": topic_source,
         "title": str(creative.get("title") or topic).strip(),
         "title_candidates": creative.get("title_candidates") or [],
+        "keywords": creative.get("keywords") or [],
         "thumbnail_variant": variant,
         "thumbnail_variants": creative.get("thumbnail_variants") or [],
         "thumbnail_prompt": str(variant.get("image_prompt") or ""),
@@ -718,6 +719,32 @@ def generate_creative_for_ui(settings: dict[str, Any], channel: dict, topic: str
     return payload
 
 
+def generate_editorial_for_ui(settings: dict[str, Any], channel: dict, topic: str, topic_source: str = "manual") -> dict[str, Any]:
+    """Generate title and keywords only; thumbnail prompt/image stay in the later pipeline stages."""
+    editorial = generate_title_and_keywords(
+        settings,
+        channel,
+        topic,
+        blueprint_for_channel(channel),
+        language=str(channel.get("language") or "Português"),
+    )
+    keywords = [str(item).strip() for item in editorial.get("keywords", []) if str(item).strip()]
+    return {
+        "topic": topic.strip(),
+        "topic_source": topic_source or "manual",
+        "title": str(editorial.get("title") or topic).strip(),
+        "title_candidates": editorial.get("title_candidates") or [],
+        "keywords": keywords[:15],
+        "thumbnail_variant": {},
+        "thumbnail_variants": [],
+        "thumbnail_prompt": "",
+        "thumbnail_text": "",
+        "thumbnail_status": "pending_prompt",
+        "generation_settings": {"video_keywords": keywords[:15]},
+        "ai_generation": {"editorial": editorial},
+    }
+
+
 def generate_thumbnail_for_ui(
     settings: dict[str, Any],
     channel: dict[str, Any],
@@ -2383,7 +2410,7 @@ def render_new_video(page_title: str = "Criação de Vídeos", prefix: str = "ne
                                         edited_topic = topic_result["topic"]
                                     else:
                                         topic_result = {**topic_result, "topic": edited_topic, "topic_source": topic_result.get("topic_source", "manual")}
-                                    generated = generate_creative_for_ui(settings, channel, edited_topic, topic_source=topic_result.get("topic_source", "llm"))
+                                    generated = generate_editorial_for_ui(settings, channel, edited_topic, topic_source=topic_result.get("topic_source", "llm"))
                                     generated["ai_generation"]["topic"] = topic_result
                                     generated_payloads[channel_id] = generated
                                 except CreativeGenerationError as exc:
@@ -2414,14 +2441,14 @@ def render_new_video(page_title: str = "Criação de Vídeos", prefix: str = "ne
                         payload = dict(st.session_state.get(f"{prefix}_creative_payload") or {})
                         if not payload.get("title") or not payload.get("thumbnail_variants"):
                             try:
-                                payload = generate_creative_for_ui(
+                                payload = generate_editorial_for_ui(
                                     read_json("settings.json", {}),
                                     selected_one or {},
                                     topic_value,
                                     topic_source=_video_topic_source(topic_value, prefix),
                                 )
                             except CreativeGenerationError as exc:
-                                st.warning(f"Título/thumbnail automáticos pendentes: {exc} A tarefa será criada com o tópico como título e sem ficheiro de thumbnail.")
+                                st.warning(f"Título/keywords automáticos pendentes: {exc} A tarefa será criada com o tópico como título; o prompt e a imagem da thumbnail serão gerados depois do vídeo.")
                                 payload = {"topic": topic_value, "title": topic_value, "topic_source": "manual", "thumbnail_status": "pending_provider", "thumbnail_variants": [], "thumbnail_variant": {}, "thumbnail_prompt": "", "thumbnail_text": ""}
                         payload.update({"topic": topic_value, "topic_source": payload.get("topic_source") or _video_topic_source(topic_value), "language": language, "format": fmt, "style_wide": style, "style_ia": style_ia, "music_mode": style == "music", "background_mode": "none" if style == "music" else ("ai" if style == "full_ia" else "stock"), "music_path": music_path, "music_source": music_source, "generation_settings": generation_settings})
                         batch = create_batch(mode, selected, topic_value, quantity_value, {"language": language, "format": fmt, "style_wide": style, "style_ia": style_ia, "music_mode": style == "music", "background_mode": "none" if style == "music" else ("ai" if style == "full_ia" else "stock"), "music_path": music_path, "music_source": music_source, "generation_settings": generation_settings, "topic_source": payload.get("topic_source", "manual"), "channel_payloads": {selected[0]: payload}})
@@ -3453,13 +3480,28 @@ def render_videos():
                 st.write(f"**{task.get('title') or task.get('topic', 'Sem título')}**")
                 st.caption(f"Tópico: {task.get('topic', 'Sem tópico')}")
                 st.caption(f"{task.get('channel_name')} · {task.get('id')}")
-                thumbnail_path = (task.get('artifacts') or {}).get('thumbnail', '')
+                artifacts = task.get('artifacts') or {}
+                thumbnail_path = artifacts.get('thumbnail', '')
                 if thumbnail_path and Path(thumbnail_path).is_file():
                     st.image(thumbnail_path, width=180)
                 else:
                     status = task.get('thumbnail_status', 'not_generated')
                     prompt_note = ' · prompt pronto' if task.get('thumbnail_prompt') else ''
                     st.caption(f"Thumbnail: {status}{prompt_note}")
+                video_path = str(artifacts.get('video') or '').strip()
+                if video_path and Path(video_path).is_file():
+                    video_file = Path(video_path)
+                    st.success('Vídeo pronto; a thumbnail pode ser criada ou carregada depois.')
+                    st.download_button(
+                        'Descarregar vídeo pronto',
+                        data=video_file.read_bytes(),
+                        file_name=video_file.name,
+                        mime='video/mp4',
+                        key=f"pipeline_video_download_{task['id']}",
+                        use_container_width=True,
+                    )
+                elif video_path:
+                    st.caption(f'Vídeo registado: {video_path}')
             with cols[1]:
                 st.caption("Formato")
                 st.write(_video_task_format(task))

package/hermes_ui/automation_worker.py

@@ -8,7 +8,7 @@ from pathlib import Path
 from typing import Any
 
 from . import storage
-from .creative_generation import generate_creative_package, generate_topic_for_channel
+from .creative_generation import generate_title_and_keywords, generate_topic_for_channel
 from .domain import create_batch, create_tasks_for_batch
 from .notifications import record_notification
 
@@ -149,28 +149,28 @@ def _creative_payload(channel: dict[str, Any]) -> tuple[str, dict[str, Any]]:
     blueprint = _blueprint_for_channel(channel)
     user_context = str(channel.get("automation_topic") or "").strip()
     topic_package = generate_topic_for_channel(settings, channel, blueprint, user_context=user_context)
-    creative = generate_creative_package(
+    editorial = generate_title_and_keywords(
         settings,
         channel,
         topic_package["topic"],
         blueprint,
         language=str(channel.get("language") or "Português"),
     )
-    variant = creative["thumbnail_variant"]
     payload = {
         "topic": topic_package["topic"],
         "topic_source": "llm",
-        "title": creative["title"],
-        "title_candidates": creative["title_candidates"],
-        "thumbnail_variant": variant,
-        "thumbnail_variants": creative["thumbnail_variants"],
-        "thumbnail_prompt": variant.get("image_prompt", ""),
-        "thumbnail_text": variant.get("overlay_text", ""),
-        "thumbnail_status": creative.get("thumbnail_status", "prompt_ready"),
+        "title": editorial["title"],
+        "title_candidates": editorial["title_candidates"],
+        "thumbnail_variant": {},
+        "thumbnail_variants": [],
+        "thumbnail_prompt": "",
+        "thumbnail_text": "",
+        "thumbnail_status": "pending_prompt",
         "blueprint_id": str(channel.get("default_blueprint_id") or channel.get("blueprint_id") or ""),
         "blueprint_name": str(blueprint.get("name") or "SEM BLUEPRINT CONFIGURADO"),
         "voice": str(channel.get("default_voice") or channel.get("voice") or ""),
-        "ai_generation": {"topic": topic_package, "creative": creative},
+        "generation_settings": {"video_keywords": editorial.get("keywords", [])},
+        "ai_generation": {"topic": topic_package, "editorial": editorial},
     }
     return topic_package["topic"], payload
 

package/hermes_ui/creative_generation.py

@@ -299,6 +299,76 @@ def generate_thumbnail_prompt(
     }
 
 
+def generate_title_and_keywords(
+    settings: dict[str, Any],
+    channel: dict[str, Any],
+    topic: str,
+    blueprint: dict[str, Any] | None = None,
+    language: str = "",
+) -> dict[str, Any]:
+    """Generate the editorial title and SEO keywords without generating thumbnail prompts."""
+    if not topic.strip():
+        raise CreativeGenerationError("É necessário um tópico ou briefing antes de gerar título e keywords.")
+    context = channel_context(channel, blueprint)
+    system = (
+        "És um director editorial para YouTube. Cria apenas o pacote editorial do vídeo: títulos candidatos e keywords SEO. "
+        "Não cries prompts, conceitos ou variantes de thumbnail. Gera exactamente pelo menos 20 títulos candidatos, "
+        "um título seleccionado e entre 8 e 15 keywords curtas. O título deve carregar keywords no início, ter curiosidade, "
+        "especificidade e emoção, sem clickbait falso. Responde apenas com JSON válido nas chaves selected_title, "
+        "title_candidates e keywords."
+    )
+    user = json.dumps(
+        {
+            "channel": context,
+            "language": language or context["language"],
+            "topic": topic.strip(),
+            "reference_rules": reference_bundle(),
+            "keywords_schema": ["lista de 8 a 15 keywords SEO curtas, sem hashtags"],
+            "title_candidates_schema": {
+                "title": "string",
+                "formula": "string",
+                "curiosity_score": "integer 0-3",
+                "specificity_score": "integer 0-3",
+                "emotional_score": "integer 0-3",
+            },
+        },
+        ensure_ascii=False,
+    )
+    result = _chat_json(settings, system, user)
+    raw_titles = result.get("title_candidates")
+    if not isinstance(raw_titles, list) or len(raw_titles) < 20:
+        raise CreativeGenerationError("O provider deve devolver pelo menos 20 títulos candidatos.")
+    titles: list[dict[str, Any]] = []
+    for item in raw_titles[:30]:
+        if not isinstance(item, dict) or not str(item.get("title") or "").strip():
+            continue
+        titles.append(
+            {
+                "title": str(item["title"]).strip(),
+                "formula": str(item.get("formula") or "custom").strip(),
+                "curiosity_score": _score(item.get("curiosity_score")),
+                "specificity_score": _score(item.get("specificity_score")),
+                "emotional_score": _score(item.get("emotional_score")),
+            }
+        )
+    if len(titles) < 20:
+        raise CreativeGenerationError("Os títulos devolvidos pelo provider não têm conteúdo suficiente.")
+    selected_title = str(result.get("selected_title") or titles[0]["title"]).strip()
+    if selected_title not in {item["title"] for item in titles}:
+        selected_title = titles[0]["title"]
+    raw_keywords = result.get("keywords")
+    keywords = [str(item).strip() for item in raw_keywords if str(item).strip()] if isinstance(raw_keywords, list) else []
+    if not keywords:
+        keywords = _keywords_from_text(topic, selected_title)
+    return {
+        "title": selected_title,
+        "title_candidates": titles,
+        "keywords": keywords[:15],
+        "topic_source": "llm",
+        "generated_by": "configured_llm",
+    }
+
+
 def generate_creative_package(
     settings: dict[str, Any],
     channel: dict[str, Any],

package/hermes_ui/domain.py

@@ -7,7 +7,8 @@ from typing import Any
 from .notifications import record_notification
 from .storage import append_json, now, read_json, write_json
 
-STAGES = ["niche", "blueprint", "brand", "topic", "script", "title", "keywords", "thumbnail_prompt", "thumbnail", "video", "edit", "upload"]
+STAGES = ["niche", "blueprint", "brand", "topic", "script", "title", "keywords", "video", "thumbnail_prompt", "thumbnail", "upload"]
+LEGACY_STAGES = {"edit"}
 VALID_STATES = {"to_do", "doing", "blocked", "done", "failed", "cancelled"}
 
 
@@ -176,10 +177,12 @@ def create_tasks_for_batch(batch: dict[str, Any]) -> list[dict[str, Any]]:
                 "thumbnail_text": thumbnail_text,
                 "thumbnail_status": thumbnail_status,
                 "title_candidates": payload.get("title_candidates", []),
+                "keywords": payload.get("keywords", options.get("keywords", [])),
                 "ai_generation": payload.get("ai_generation", {}),
                 "stage": "script",
                 "state": "to_do",
                 "progress": 0,
+                "video_ready": bool(artifacts.get("video")),
                 "artifacts": artifacts,
                 "error": None,
                 "created_at": now(),
@@ -266,7 +269,7 @@ def transition_task(task_id: str, state: str | None = None, stage: str | None =
             if state:
                 task["state"] = state
             if stage:
-                if stage not in STAGES:
+                if stage not in STAGES and stage not in LEGACY_STAGES:
                     raise ValueError(f"Etapa inválida: {stage}")
                 task["stage"] = stage
             if error is not None:

package/hermes_ui/media_generation.py

@@ -16,7 +16,14 @@ from urllib.parse import urljoin
 
 import requests
 
-from .media_providers import media_cards_for_pool, media_provider_definition
+from .media_providers import (
+    INTERNAL_IMAGE_ASPECT_RATIO,
+    INTERNAL_IMAGE_SIZE,
+    INTERNAL_VIDEO_ASPECT_RATIO,
+    INTERNAL_VIDEO_SIZE,
+    media_cards_for_pool,
+    media_provider_definition,
+)
 from .provider_routing import (
     POOL_IMAGE,
     POOL_VIDEO,
@@ -52,6 +59,28 @@ def _headers(card: Mapping[str, Any], *, fal: bool = False) -> dict[str, str]:
     return headers
 
 
+def _append_generation_constraints(
+    prompt: str,
+    *,
+    kind: str,
+    aspect_ratio: str = "",
+    size: str = "",
+) -> str:
+    """Append controlled rendering constraints without exposing editable UI fields."""
+    clean = str(prompt or "").strip()
+    if kind == "image":
+        ratio = str(aspect_ratio or INTERNAL_IMAGE_ASPECT_RATIO).strip()
+        resolution = str(size or INTERNAL_IMAGE_SIZE).strip()
+        constraints = f"Target image composition: {ratio} aspect ratio, {resolution} resolution."
+    else:
+        ratio = str(aspect_ratio or INTERNAL_VIDEO_ASPECT_RATIO).strip()
+        resolution = str(size or INTERNAL_VIDEO_SIZE).strip()
+        constraints = f"Target video composition: {ratio} aspect ratio, {resolution} resolution."
+    if not clean:
+        return constraints
+    return f"{clean}\n\n{constraints}"
+
+
 def _decode_data(value: Any) -> bytes | None:
     if not isinstance(value, str) or not value.strip():
         return None
@@ -142,14 +171,20 @@ def _image_request(card: dict[str, Any], prompt: str) -> Any:
     provider = str(card.get("provider") or "").strip().lower()
     style = str(card.get("api_style") or media_provider_definition(provider).api_style)
     endpoint = _image_endpoint(card)
+    constrained_prompt = _append_generation_constraints(
+        prompt,
+        kind="image",
+        aspect_ratio=str(card.get("aspect_ratio") or ""),
+        size=str(card.get("image_size") or ""),
+    )
     if style == "cloudflare":
-        return requests.post(endpoint, headers=_headers(card), json={"prompt": prompt}, timeout=180)
+        return requests.post(endpoint, headers=_headers(card), json={"prompt": constrained_prompt}, timeout=180)
     if style == "fal_queue":
-        return requests.post(endpoint, headers=_headers(card, fal=True), json={"prompt": prompt, "num_images": 1}, timeout=180)
+        return requests.post(endpoint, headers=_headers(card, fal=True), json={"prompt": constrained_prompt, "num_images": 1}, timeout=180)
     if style == "dashscope":
-        body = {"model": _model(card), "input": {"prompt": prompt}, "parameters": {"size": "1024*1024", "n": 1}}
+        body = {"model": _model(card), "input": {"prompt": constrained_prompt}, "parameters": {"n": 1}}
         return requests.post(endpoint, headers=_headers(card), json=body, timeout=180)
-    body = {"model": _model(card), "prompt": prompt, "n": 1, "response_format": "b64_json"}
+    body = {"model": _model(card), "prompt": constrained_prompt, "n": 1, "response_format": "b64_json"}
     return requests.post(endpoint, headers=_headers(card), json=body, timeout=180)
 
 
@@ -171,10 +206,17 @@ def generate_image_for_card(
         merged = dict(settings)
         merged["gemini_image_api_key"] = _api_key(card)
         merged["gemini_image_model"] = _model(card) or merged.get("gemini_image_model") or "gemini-3.1-flash-image"
+        merged["gemini_image_aspect_ratio"] = str(card.get("aspect_ratio") or INTERNAL_IMAGE_ASPECT_RATIO)
+        merged["gemini_image_size"] = str(card.get("image_size") or INTERNAL_IMAGE_SIZE)
         try:
             return generate_thumbnail_image(
                 merged,
-                prompt,
+                _append_generation_constraints(
+                    prompt,
+                    kind="image",
+                    aspect_ratio=str(card.get("aspect_ratio") or ""),
+                    size=str(card.get("image_size") or ""),
+                ),
                 topic=topic,
                 variant_index=variant_index,
                 lettering_text=lettering_text,
@@ -260,7 +302,15 @@ def _video_endpoint(card: Mapping[str, Any]) -> str:
 def _video_request(card: dict[str, Any], prompt: str, image_url: str = "") -> Any:
     style = str(card.get("api_style") or media_provider_definition(card.get("provider")).api_style)
     endpoint = _video_endpoint(card)
-    body: dict[str, Any] = {"model": _model(card), "prompt": prompt}
+    body: dict[str, Any] = {
+        "model": _model(card),
+        "prompt": _append_generation_constraints(
+            prompt,
+            kind="video",
+            aspect_ratio=str(card.get("aspect_ratio") or ""),
+            size=str(card.get("video_size") or ""),
+        ),
+    }
     if image_url:
         body["image_url"] = image_url
     if style == "fal_queue":

package/hermes_ui/media_providers.py

@@ -12,6 +12,12 @@ MEDIA_VIDEO_ACTIVE_CARD_KEY = "media_video_active_card_id"
 MEDIA_IMAGE_ACTIVE_PROVIDER_KEY = "media_image_provider"
 MEDIA_VIDEO_ACTIVE_PROVIDER_KEY = "media_video_provider"
 
+# Mantidos internamente para preservar compatibilidade e controlar o prompt dos providers.
+INTERNAL_IMAGE_ASPECT_RATIO = "16:9"
+INTERNAL_IMAGE_SIZE = "1K"
+INTERNAL_VIDEO_ASPECT_RATIO = "16:9"
+INTERNAL_VIDEO_SIZE = "1080p"
+
 
 @dataclass(frozen=True, slots=True)
 class MediaProviderDefinition:
@@ -35,7 +41,6 @@ MEDIA_PROVIDER_CATALOG: tuple[MediaProviderDefinition, ...] = (
         default_base_url="https://generativelanguage.googleapis.com/v1beta",
         supports_image=True,
         api_style="gemini_interactions",
-        extra_fields=("aspect_ratio", "image_size"),
         description="Geração de imagem nativa Gemini para thumbnails e artes.",
     ),
     MediaProviderDefinition(
@@ -170,6 +175,9 @@ def normalize_media_card(card: Any, index: int = 0) -> dict[str, Any]:
     }
     for field in definition.extra_fields:
         result[field] = str(source.get(field) or "").strip()
+    if provider == "nano_banana":
+        result["aspect_ratio"] = str(source.get("aspect_ratio") or INTERNAL_IMAGE_ASPECT_RATIO).strip()
+        result["image_size"] = str(source.get("image_size") or INTERNAL_IMAGE_SIZE).strip()
     test_result = source.get("test_result")
     if isinstance(test_result, Mapping) and str(test_result.get("status") or "") in {"success", "error"}:
         result["test_result"] = {
@@ -215,8 +223,8 @@ def ensure_media_provider_cards(settings: Mapping[str, Any]) -> tuple[dict[str,
                     "api_key": legacy_key,
                     "model": legacy_model,
                     "base_url": "https://generativelanguage.googleapis.com/v1beta",
-                    "aspect_ratio": str(result.get("gemini_image_aspect_ratio") or "16:9"),
-                    "image_size": str(result.get("gemini_image_size") or "1K"),
+                    "aspect_ratio": str(result.get("gemini_image_aspect_ratio") or INTERNAL_IMAGE_ASPECT_RATIO),
+                    "image_size": str(result.get("gemini_image_size") or INTERNAL_IMAGE_SIZE),
                     "enabled": True,
                 },
                 0,
@@ -267,8 +275,8 @@ def apply_media_provider_cards_to_settings(settings: Mapping[str, Any], cards: l
     if nano_card:
         result["gemini_image_api_key"] = str(nano_card.get("api_key") or "")
         result["gemini_image_model"] = str(nano_card.get("model") or "gemini-3.1-flash-image")
-        result["gemini_image_aspect_ratio"] = str(nano_card.get("aspect_ratio") or result.get("gemini_image_aspect_ratio") or "16:9")
-        result["gemini_image_size"] = str(nano_card.get("image_size") or result.get("gemini_image_size") or "1K")
+        result["gemini_image_aspect_ratio"] = str(nano_card.get("aspect_ratio") or result.get("gemini_image_aspect_ratio") or INTERNAL_IMAGE_ASPECT_RATIO)
+        result["gemini_image_size"] = str(nano_card.get("image_size") or result.get("gemini_image_size") or INTERNAL_IMAGE_SIZE)
     return result
 
 

package/hermes_ui/pipeline_worker.py

@@ -12,14 +12,14 @@ from pathlib import Path
 from typing import Any
 
 from integrations.upload_routing import upload_with_default_route
-from hermes_ui.creative_generation import CreativeGenerationError, generate_creative_package, generate_topic_for_channel
+from hermes_ui.creative_generation import CreativeGenerationError, generate_creative_package, generate_title_and_keywords, generate_thumbnail_prompt, generate_topic_for_channel
 from hermes_ui.script_documents import save_script_document
 from hermes_ui.script_generation import generate_script_document
 from hermes_ui.storage import STORAGE, ensure_storage, read_json, write_json
 from hermes_ui.llm_providers import active_llm_card, provider_definition
-from hermes_ui.media_generation import MediaGenerationError, generate_image_from_pool, generate_video_from_pool
+from hermes_ui.media_generation import MediaGenerationError, _append_generation_constraints, generate_image_from_pool, generate_video_from_pool
 from hermes_ui.media_providers import media_cards_for_pool
-from hermes_ui.thumbnail_generation import generate_thumbnail_image
+from hermes_ui.thumbnail_generation import ThumbnailGenerationError, generate_thumbnail_image
 
 PIPELINE_LOCK_FILENAME = "pipeline_worker.lock"
 PIPELINE_LOG_FILENAME = "pipeline_worker.json"
@@ -401,7 +401,7 @@ def _run_video_helper(task: dict[str, Any]) -> Path:
                 # 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))
+                video_progress = min(79, 52 + 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)
@@ -503,37 +503,90 @@ def _run_task(task: dict[str, Any]) -> dict[str, Any]:
 
     _update(task_id, stage="title", state="doing", progress=35)
     provided_title = str(task.get("title") or "").strip()
+    provided_keywords = generation_settings.get("video_keywords") or task.get("keywords")
+    if isinstance(provided_keywords, str):
+        provided_keywords = re.split(r"[,\n;|]+", provided_keywords)
+    provided_keywords = [str(item).strip() for item in provided_keywords or [] if str(item).strip()]
+    title_candidates = task.get("title_candidates") if isinstance(task.get("title_candidates"), list) else []
+    editorial: dict[str, Any] = {
+        "title": provided_title or topic,
+        "title_candidates": title_candidates,
+        "keywords": provided_keywords,
+    }
+    if not provided_title:
+        try:
+            editorial = generate_title_and_keywords(
+                settings,
+                channel,
+                topic,
+                blueprint,
+                language=str(task.get("language") or channel.get("language") or "Português"),
+            )
+        except CreativeGenerationError:
+            # A falha editorial não deve impedir a geração do vídeo: usa o tema
+            # como título e keywords determinísticas, deixando o erro de imagem
+            # para a etapa posterior e independente da criação do MP4.
+            editorial = {"title": topic, "title_candidates": [], "keywords": []}
+    title = str(editorial.get("title") or provided_title or topic).strip()
+    keywords = provided_keywords[:15] or (
+        editorial.get("keywords") if isinstance(editorial.get("keywords"), list) else []
+    )
+    keywords = [str(item).strip() for item in keywords if str(item).strip()][:15] or _keywords(
+        topic,
+        title,
+        str(channel.get("niche") or ""),
+    )
+    title_candidates = editorial.get("title_candidates") if isinstance(editorial.get("title_candidates"), list) else title_candidates
+    title_artifact = _save_json_artifact(
+        task_id,
+        "title-keywords",
+        {"topic": topic, "title": title, "keywords": keywords, "title_candidates": title_candidates},
+    )
+    artifacts = {**artifacts, "title_keywords": title_artifact}
+    _update(task_id, title=title, tags=keywords, artifacts=artifacts, title_candidates=title_candidates, progress=45)
+
+    _update(task_id, stage="keywords", state="doing", progress=48)
+    _update(task_id, tags=keywords, progress=50)
+
+    # O vídeo é deliberadamente concluído antes de qualquer chamada ao provider
+    # de imagem. O artefacto fica persistido mesmo que a quota da thumbnail falhe.
+    _update(task_id, stage="video", state="doing", progress=52, error=None)
+    video_cards = media_cards_for_pool(settings, "video")
+    if bool(settings.get("media_video_pool_enabled")) and video_cards:
+        try:
+            video_prompt = _append_generation_constraints(
+                f"Título: {title}\n\nRoteiro:\n{str(script.get('content') or '')[:12000]}",
+                kind="video",
+            )
+            video_path = generate_video_from_pool(settings, video_prompt)
+        except MediaGenerationError as exc:
+            raise PipelineError(f"Pool de vídeo externo: {exc}") from exc
+    else:
+        video_path = _run_video_helper({**task, "topic": topic, "title": title})
+    current_after_video = _task_by_id(task_id) or {}
+    artifacts = dict(current_after_video.get("artifacts") or artifacts)
+    artifacts["video"] = str(video_path)
+    _update(task_id, artifacts=artifacts, video_ready=True, progress=80)
+
+    _update(task_id, stage="thumbnail_prompt", state="doing", progress=82, error=None)
     existing_variant = task.get("thumbnail_variant") if isinstance(task.get("thumbnail_variant"), dict) else {}
     existing_variant = dict(existing_variant)
     if not str(existing_variant.get("image_prompt") or "").strip() and str(task.get("thumbnail_prompt") or "").strip():
         existing_variant["image_prompt"] = str(task.get("thumbnail_prompt") or "").strip()
     if not str(existing_variant.get("overlay_text") or "").strip() and str(task.get("thumbnail_text") or "").strip():
         existing_variant["overlay_text"] = str(task.get("thumbnail_text") or "").strip()
-    prepared_thumbnail = bool(str(existing_variant.get("image_prompt") or "").strip())
-    if provided_title and prepared_thumbnail:
-        # The creation UI already generated the title/thumbnail brief. Do not call
-        # the complete creative-package generator a second time for this task.
-        creative = {
-            "title": provided_title,
-            "keywords": [],
-            "thumbnail_variant": existing_variant,
-            "title_candidates": task.get("title_candidates") if isinstance(task.get("title_candidates"), list) else [],
-        }
-    else:
-        creative = generate_creative_package(settings, channel, topic, blueprint, language=str(task.get("language") or channel.get("language") or "Português"))
-    title = str(creative.get("title") or provided_title or topic).strip()
-    provided_keywords = generation_settings.get("video_keywords")
-    if isinstance(provided_keywords, str):
-        provided_keywords = re.split(r"[,\n;|]+", provided_keywords)
-    provided_keywords = [str(item).strip() for item in provided_keywords or [] if str(item).strip()]
-    keywords = provided_keywords[:15] or (creative.get("keywords") if isinstance(creative.get("keywords"), list) else _keywords(topic, title, str(channel.get("niche") or "")))
-    title_artifact = _save_json_artifact(task_id, "title-keywords", {"topic": topic, "title": title, "keywords": keywords, "title_candidates": creative.get("title_candidates", [])})
-    _update(task_id, title=title, tags=keywords, artifacts={**artifacts, "title_keywords": title_artifact}, title_candidates=creative.get("title_candidates", []), progress=45)
-
-    _update(task_id, stage="keywords", state="doing", progress=48)
-    variant = creative.get("thumbnail_variant") if isinstance(creative.get("thumbnail_variant"), dict) else {}
-    if not variant and prepared_thumbnail:
-        variant = existing_variant
+    variant = existing_variant
+    if not str(variant.get("image_prompt") or "").strip():
+        try:
+            variant = generate_thumbnail_prompt(
+                settings,
+                channel,
+                topic,
+                blueprint=blueprint,
+                language=str(task.get("language") or channel.get("language") or "Português"),
+            )
+        except CreativeGenerationError as exc:
+            raise PipelineError(f"Não foi possível gerar o prompt da thumbnail: {exc}") from exc
     prompt_payload = {
         "topic": topic,
         "title": title,
@@ -550,34 +603,41 @@ def _run_task(task: dict[str, Any]) -> dict[str, Any]:
         },
     }
     prompt_artifact = _save_json_artifact(task_id, "thumbnail-prompt", prompt_payload)
-    artifacts = {**artifacts, "thumbnail_prompt_json": prompt_artifact}
-    _update(task_id, stage="thumbnail_prompt", state="doing", progress=52, thumbnail_prompt=str(variant.get("image_prompt") or ""), thumbnail_text=str(variant.get("overlay_text") or ""), thumbnail_status="prompt_ready", artifacts=artifacts)
-    _update(task_id, stage="thumbnail", state="doing", progress=56, thumbnail_prompt=str(variant.get("image_prompt") or ""), thumbnail_text=str(variant.get("overlay_text") or ""), thumbnail_status="prompt_ready", artifacts=artifacts)
-    thumbnail_path = _generate_pipeline_thumbnail(
-        settings,
-        str(variant.get("image_prompt") or ""),
-        topic=topic,
-        variant_index=0,
-        lettering_text=str(variant.get("overlay_text") or ""),
-        lettering_prompt=str(variant.get("lettering_prompt") or ""),
+    artifacts["thumbnail_prompt_json"] = prompt_artifact
+    _update(
+        task_id,
+        stage="thumbnail_prompt",
+        state="doing",
+        progress=84,
+        thumbnail_variant=variant,
+        thumbnail_prompt=str(variant.get("image_prompt") or ""),
+        thumbnail_text=str(variant.get("overlay_text") or ""),
+        thumbnail_status="prompt_ready",
+        artifacts=artifacts,
     )
-    artifacts["thumbnail"] = str(thumbnail_path)
-    _update(task_id, artifacts=artifacts, thumbnail_status="generated", progress=62)
 
-    _update(task_id, stage="video", state="doing", progress=68)
-    video_cards = media_cards_for_pool(settings, "video")
-    if bool(settings.get("media_video_pool_enabled")) and video_cards:
-        try:
-            video_prompt = f"Título: {title}\n\nRoteiro:\n{str(script.get('content') or '')[:12000]}"
-            video_path = generate_video_from_pool(settings, video_prompt)
-        except MediaGenerationError as exc:
-            raise PipelineError(f"Pool de vídeo externo: {exc}") from exc
+    _update(task_id, stage="thumbnail", state="doing", progress=86, error=None)
+    current_artifacts = dict((_task_by_id(task_id) or {}).get("artifacts") or artifacts)
+    existing_thumbnail = Path(str(current_artifacts.get("thumbnail") or variant.get("image_path") or "")).expanduser()
+    if existing_thumbnail.is_file() and existing_thumbnail.stat().st_size > 0:
+        thumbnail_path = existing_thumbnail
     else:
-        video_path = _run_video_helper({**task, "topic": topic})
-    artifacts["video"] = str(video_path)
-    _update(task_id, artifacts=artifacts, progress=80)
+        try:
+            thumbnail_path = _generate_pipeline_thumbnail(
+                settings,
+                str(variant.get("image_prompt") or ""),
+                topic=topic,
+                variant_index=0,
+                lettering_text=str(variant.get("overlay_text") or ""),
+                lettering_prompt=str(variant.get("lettering_prompt") or ""),
+            )
+        except (MediaGenerationError, ThumbnailGenerationError) as exc:
+            raise PipelineError(f"A thumbnail não foi gerada; o vídeo já está disponível em {video_path}: {exc}") from exc
+    artifacts = dict((_task_by_id(task_id) or {}).get("artifacts") or current_artifacts)
+    artifacts["thumbnail"] = str(thumbnail_path)
+    _update(task_id, artifacts=artifacts, thumbnail_status="generated", progress=90)
 
-    _update(task_id, stage="upload", state="doing", progress=86)
+    _update(task_id, stage="upload", state="doing", progress=94, error=None)
     result = upload_with_default_route(
         settings,
         storage_root=STORAGE,

package/package.json

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