@danhachuel/thunderbolt 0.3.40 → 0.3.42

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.39
+> **Versão deste manual:** 0.3.42
 > **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.39 install
+npx.cmd --yes @danhachuel/thunderbolt@0.3.42 install
 ```
 
 Linux/macOS:
 
 ```bash
-npx --yes @danhachuel/thunderbolt@0.3.39 install
+npx --yes @danhachuel/thunderbolt@0.3.42 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.
@@ -438,8 +438,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 e a voz, ou **SEM BLUEPRINT CONFIGURADO**. Clique em **Gerar títulos e thumbnails com IA**, confirme pelo menos 20 candidatos de título e 3–5 variantes de thumbnail, escolha uma variante 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 **Gerar títulos e thumbnails para todos os canais** antes de criar o batch.
+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.
 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.
@@ -487,7 +487,7 @@ Ao abrir a página, o Thunderbolt não prepara dados públicos, não descarrega
 
 Os parâmetros da UI são número de clusters entre 2 e 10, suporte mínimo entre 0,01 e 0,50, país, engagement, intervalo de datas e tags, todos dentro da área principal da aba. O núcleo normaliza os dados, calcula engagement, aplica filtros, faz transformação logarítmica e standardização, executa K-Means e calcula itemsets/regras com FP-Growth. Não são apresentados resultados até ao primeiro clique em **Analisar Nichos**; o mesmo botão aplica alterações posteriores aos filtros. Os resultados são DataFrames de clusters, itemsets frequentes, regras de associação e dados analisados; o gráfico de dispersão é criado nativamente com Plotly.
 
-As dependências adicionais — `scikit-learn`, `mlxtend`, `plotly`, `seaborn`, `matplotlib` e `kagglehub` — são instaladas pelo procedimento normal de `npx`. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.3.39 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.42 install`; o instalador detecta e reutiliza o que já estiver válido.
 
 ### Niche Finder Apify
 
@@ -515,9 +515,9 @@ No modo automático de **Cortes**, a aplicação não inventa uma selecção vir
 
 O formulário permite escrever manualmente o **Tópico ou briefing** ou clicar em **Gerar tópico/briefing com IA**. O botão usa o provider LLM, Base URL, API key e modelo guardados em **Configuração API > API Keys > Serviços e modelos**, incorpora a descrição, o nicho e o Blueprint do canal e coloca o resultado no campo para revisão. Abrir a página não inicia chamadas externas.
 
-Depois do tópico, clique em **Gerar títulos e thumbnails com IA**. O Thunderbolt solicita pelo menos 20 títulos candidatos e 3–5 variantes de thumbnail, aplica as regras das referências empacotadas em `seed/references/` e guarda a variante escolhida na task. O título aparece pré-preenchido no Upload. A thumbnail guarda conceito, texto de até quatro palavras, composição, paleta, prompt e sinergia com o título; se não existir um provider de imagem configurado, fica com estado **Prompt de thumbnail pronto — imagem pendente de provider de imagem**, sem criar um ficheiro artificial.
+Depois do tópico e do título inicial, a área **Gerar Thumbnail com IA** gera apenas o briefing/prompt da thumbnail e preserva o título já existente. Não chama o gerador de títulos nem cria candidatos redundantes. Em **Lote no mesmo canal**, gera uma variante independente para cada vídeo; ao criar as tasks, cada vídeo recebe a sua própria variante de thumbnail. A área **Gerar Thumbnail com IA** fica fechada por defeito, tal como **Configurações de vídeo**, **Configurações de áudio** e **Configurações de legendas**, formando as quatro áreas expansíveis principais. A geração da imagem final continua disponível no botão específico do Nano Banana depois de existir um prompt. Se não existir um provider de imagem configurado, fica com estado **Prompt de thumbnail pronto — imagem pendente de provider de imagem**, sem criar um ficheiro artificial.
 
-No modo **Lote geral**, todos os canais cadastrados são incluídos automaticamente. Não existe selector **Canais incluídos**. O Thunderbolt cria exactamente uma task por canal e cada task recebe briefing, título, thumbnail, Blueprint, voz e contexto próprios. O mesmo tópico não é replicado entre canais.
+No modo **Lote geral**, todos os canais cadastrados são incluídos automaticamente. Não existe selector **Canais incluídos**. O botão **Gerar Thumbnail com IA para todos os vídeos** percorre os tópicos individuais já preparados e gera somente uma thumbnail por vídeo/canal; não regenera títulos. O Thunderbolt cria exactamente uma task por canal e cada task recebe briefing, título, thumbnail, Blueprint, voz e contexto próprios. O mesmo tópico não é replicado entre canais.
 
 ## Pipeline: Criação de Vídeos, Criação de Músicas, Roteiros e Automação
 
@@ -525,7 +525,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 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 aba **Automação Youtube**, dentro do menu expansível **Automação**, apresenta os cartões no layout compacto de duas linhas: na primeira ficam avatar, nome, handle, toggle **Automação ligada** e horário; na segunda ficam **Idioma Padrão**, **Nicho Padrão**, **Blueprint Padrão**, **Narrador/Voz Padrão** e o botão **Guardar**. 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 ligada** 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

@@ -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.40
+## Navegação da UI 0.3.42
 
 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.
 
@@ -107,11 +107,15 @@ Abaixo do cartão, a secção **Últimos 10 vídeos publicados** fica num expand
 
 A aba **Criação de Vídeos** permite escrever manualmente o **Tópico ou briefing** ou usar **Gerar tópico/briefing com IA**. A geração usa o provider LLM configurado localmente em **Configuração API > API Keys > Serviços e modelos**, incorpora o Blueprint, a descrição, o idioma e a voz do canal e só ocorre depois do clique do utilizador. Se não houver credenciais ou modelo, a UI mostra uma mensagem accionável e não inventa conteúdo.
 
-Entre **Canal** e **Estilo wide**, a UI mostra o Blueprint padrão resolvido do canal e a voz associada. Quando não existe configuração, apresenta **SEM BLUEPRINT CONFIGURADO**. Depois do briefing, **Gerar títulos e thumbnails com IA** cria pelo menos 20 candidatos de título e 3–5 variantes de thumbnail. Os títulos seguem as fórmulas e regras de curiosidade, especificidade, emoção, keyword inicial e humanização fornecidas nas referências empacotadas; as thumbnails guardam conceito, overlay de até quatro palavras, composição, cores, prompt e sinergia com o título.
+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 continua disponível através do botão específico do Nano Banana; 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.
 
-No modo **Lote geral**, o Thunderbolt remove a selecção parcial e processa automaticamente todos os canais cadastrados. É 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.
+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.
+
+## Automação Youtube — layout compacto por canal
+
+A aba **Automação Youtube** usa um cartão compacto de duas linhas. Na primeira ficam avatar, nome, handle, **Automação ligada** e **Horário (HH:MM)**; na segunda ficam **Idioma Padrão**, **Nicho Padrão**, **Blueprint Padrão**, **Narrador/Voz Padrão** e o botão **Guardar**. As chaves e funções dos controlos permanecem as mesmas: Blueprint e Narrador/Voz são editáveis, enquanto Idioma e Nicho são apresentados a partir do canal.
 
 ## OpenAI/ NVIDIA NIM — descoberta de modelos
 

package/app/main.py

@@ -362,8 +362,13 @@ def save_ui_language(value: str) -> str:
     return normalized
 
 
+def normalize_video_language(value: Any, default: str = "pt") -> str:
+    raw = str(value or "").strip()
+    return "music" if raw.casefold() == "music" else language_code(raw, default=default)
+
+
 def save_video_language(value: str) -> str:
-    normalized = "music" if str(value or "").strip().casefold() == "music" else language_code(value)
+    normalized = normalize_video_language(value)
     settings = read_json("settings.json", {})
     settings["video_language"] = normalized
     write_json("settings.json", settings)
@@ -486,6 +491,13 @@ def blueprint_for_channel(channel: dict) -> dict[str, Any]:
     return {"id": blueprint_id, "name": blueprint_id}
 
 
+def channel_video_language(channel: dict[str, Any] | None, fallback: str = "pt") -> str:
+    """Return the channel's canonical video language, preserving legacy labels."""
+    if not isinstance(channel, dict):
+        return normalize_video_language(fallback)
+    return normalize_video_language(channel.get("language") or fallback)
+
+
 def channel_blueprint_summary(channel: dict) -> dict[str, str]:
     blueprint = blueprint_for_channel(channel)
     configured_id = str(channel.get("default_blueprint_id") or channel.get("blueprint_id") or "").strip()
@@ -501,12 +513,13 @@ def channel_blueprint_summary(channel: dict) -> dict[str, str]:
 def render_channel_blueprint_panel(channel: dict, *, compact: bool = False) -> None:
     summary = channel_blueprint_summary(channel)
     voice = summary["voice"] or "Sem voz padrão"
+    video_language = language_label(channel_video_language(channel))
     if summary["name"] == "SEM BLUEPRINT CONFIGURADO":
-        st.warning("**SEM BLUEPRINT CONFIGURADO** · configure um Blueprint padrão na aba Canais.")
+        st.warning(f"**SEM BLUEPRINT CONFIGURADO** · configure um Blueprint padrão na aba Canais. · **Idioma:** {video_language}")
     elif compact:
-        st.caption(f"**Blueprint:** {summary['name']} · **Voz:** {voice}")
+        st.caption(f"**Blueprint:** {summary['name']} · **Voz:** {voice} · **Idioma:** {video_language}")
     else:
-        st.info(f"**Blueprint utilizado pelo canal:** {summary['name']} · `{summary['id']}` · **Voz:** {voice}")
+        st.info(f"**Blueprint utilizado pelo canal:** {summary['name']} · `{summary['id']}` · **Voz:** {voice} · **Idioma:** {video_language}")
 
 
 def creative_payload_from_result(channel: dict, topic: str, creative: dict, topic_source: str = "manual") -> dict[str, Any]:
@@ -704,6 +717,75 @@ def generate_creative_for_ui(settings: dict[str, Any], channel: dict, topic: str
     return payload
 
 
+def generate_thumbnail_for_ui(
+    settings: dict[str, Any],
+    channel: dict[str, Any],
+    topic: str,
+    *,
+    title: str = "",
+    topic_source: str = "manual",
+) -> dict[str, Any]:
+    """Generate exactly one thumbnail brief for an existing video topic/title."""
+    topic = str(topic or "").strip()
+    if not topic:
+        raise CreativeGenerationError("É necessário um tópico antes de gerar a thumbnail.")
+    variant = generate_thumbnail_prompt(
+        settings,
+        channel,
+        topic,
+        blueprint=blueprint_for_channel(channel),
+        language=str(channel.get("language") or "Português"),
+    )
+    return {
+        "topic": topic,
+        "title": str(title or topic).strip(),
+        "topic_source": topic_source or "manual",
+        "thumbnail_variant": variant,
+        "thumbnail_variants": [variant],
+        "thumbnail_prompt": variant.get("image_prompt", ""),
+        "thumbnail_text": variant.get("overlay_text", ""),
+        "thumbnail_status": "prompt_ready",
+        "title_candidates": [],
+        "ai_generation": {"thumbnail": variant},
+    }
+
+
+def generate_thumbnail_variants_for_ui(
+    settings: dict[str, Any],
+    channel: dict[str, Any],
+    topic: str,
+    count: int,
+    *,
+    title: str = "",
+    topic_source: str = "manual",
+) -> dict[str, Any]:
+    """Generate one independent thumbnail brief for each video in a batch."""
+    count = max(1, min(int(count or 1), 100))
+    variants: list[dict[str, Any]] = []
+    for _index in range(count):
+        generated = generate_thumbnail_for_ui(
+            settings,
+            channel,
+            topic,
+            title=title,
+            topic_source=topic_source,
+        )
+        variants.append(dict(generated["thumbnail_variant"]))
+    first = variants[0]
+    return {
+        "topic": topic,
+        "title": str(title or topic).strip(),
+        "topic_source": topic_source or "manual",
+        "thumbnail_variant": first,
+        "thumbnail_variants": variants,
+        "thumbnail_prompt": first.get("image_prompt", ""),
+        "thumbnail_text": first.get("overlay_text", ""),
+        "thumbnail_status": "prompt_ready",
+        "title_candidates": [],
+        "ai_generation": {"thumbnail_variants": variants},
+    }
+
+
 def valid_hhmm(value: str) -> bool:
     return bool(re.fullmatch(r"(?:[01]\d|2[0-3]):[0-5]\d", str(value or "").strip()))
 
@@ -746,7 +828,15 @@ def render_video_generation_settings(
                 key=f"{prefix}_video_subject",
                 placeholder="Ex.: How AI is changing everyday life",
             )
-            normalized_current_language = "music" if str(current_language or "").strip().casefold() in {"music", "00 – apenas música de fundo (sem falas)", "00 - apenas música de fundo (sem falas)"} else language_code(current_language)
+            normalized_current_language = normalize_video_language(current_language)
+            if channel is not None:
+                channel_id = str(channel.get("id") or channel.get("name") or "")
+                channel_language_state_key = f"{prefix}_language_channel_id"
+                if st.session_state.get(channel_language_state_key) != channel_id:
+                    channel_language = channel_video_language(channel, fallback=normalized_current_language)
+                    st.session_state[f"{prefix}_script_language"] = channel_language
+                    st.session_state[channel_language_state_key] = channel_id
+                normalized_current_language = normalize_video_language(st.session_state.get(f"{prefix}_script_language") or normalized_current_language)
             settings["script_language"] = st.selectbox(
                 "Script Language",
                 VIDEO_LANGUAGE_SELECTION_OPTIONS,
@@ -755,14 +845,14 @@ def render_video_generation_settings(
                 key=f"{prefix}_script_language",
             )
         with subject_cols[1]:
-            with st.expander("Advanced Script Settings", expanded=False):
-                settings["script_structure_notes"] = st.text_area(
-                    "Estrutura e notas opcionais",
-                    value=str(st.session_state.get(f"{prefix}_script_structure_notes", "")),
-                    key=f"{prefix}_script_structure_notes",
-                    height=100,
-                    placeholder="Ex.: gancho forte, 6 cenas, narração documental…",
-                )
+            st.markdown("**Advanced Script Settings**")
+            settings["script_structure_notes"] = st.text_area(
+                "Estrutura e notas opcionais",
+                value=str(st.session_state.get(f"{prefix}_script_structure_notes", "")),
+                key=f"{prefix}_script_structure_notes",
+                height=100,
+                placeholder="Ex.: gancho forte, 6 cenas, narração documental…",
+            )
             settings["generate_script_with_ai"] = st.checkbox("Generate Script & Keywords with AI", value=True, key=f"{prefix}_generate_script_with_ai")
         settings["video_script"] = st.text_area(
             "Video Script (Optional)",
@@ -804,66 +894,69 @@ def render_video_generation_settings(
                 st.error(st.session_state[f"{prefix}_save_draft_error"])
 
     if "Configurações de vídeo" in visible_sections:
-        st.markdown("### Video Settings")
-        video_cols = st.columns(2)
-        with video_cols[0]:
-            settings["video_source"] = st.selectbox("Video Source", WIDE_STYLE_OPTIONS, key=f"{prefix}_video_source")
-            if settings["video_source"] == "full_ia":
-                settings["style_ia"] = st.selectbox("Estilo IA", AI_STYLE_OPTIONS, key=f"{prefix}_style_ia")
-            else:
-                settings["style_ia"] = ""
-            settings["video_format"] = st.selectbox("Formato", VIDEO_FORMAT_OPTIONS, key=f"{prefix}_video_format")
-            settings["video_concatenation_mode"] = st.selectbox("Video Concatenation Mode", VIDEO_CONCATENATION_OPTIONS, key=f"{prefix}_video_concatenation")
-            settings["match_visuals_to_script_order"] = st.checkbox("Match Visuals to Script Order", value=False, key=f"{prefix}_match_visuals")
-            settings["video_transition_mode"] = st.selectbox("Video Transition Mode", VIDEO_TRANSITION_OPTIONS, key=f"{prefix}_video_transition")
-        with video_cols[1]:
-            settings["video_aspect_ratio"] = st.selectbox("Video Aspect Ratio", ["Portrait 9:16", "Landscape 16:9", "Square 1:1"], key=f"{prefix}_video_aspect_ratio")
-            settings["maximum_clip_duration"] = st.selectbox("Maximum Clip Duration (seconds)", [3, 5, 8, 10, 15], key=f"{prefix}_maximum_clip_duration")
-            settings["videos_per_run"] = st.selectbox("Videos per Run", list(range(1, 11)), key=f"{prefix}_videos_per_run")
-            settings["video_encoder"] = st.selectbox("Video Encoder", VIDEO_ENCODER_OPTIONS, key=f"{prefix}_video_encoder")
+        with st.expander("Configurações de vídeo", expanded=False):
+            st.markdown("### Video Settings")
+            video_cols = st.columns(2)
+            with video_cols[0]:
+                settings["video_source"] = st.selectbox("Video Source", WIDE_STYLE_OPTIONS, key=f"{prefix}_video_source")
+                if settings["video_source"] == "full_ia":
+                    settings["style_ia"] = st.selectbox("Estilo IA", AI_STYLE_OPTIONS, key=f"{prefix}_style_ia")
+                else:
+                    settings["style_ia"] = ""
+                settings["video_format"] = st.selectbox("Formato", VIDEO_FORMAT_OPTIONS, key=f"{prefix}_video_format")
+                settings["video_concatenation_mode"] = st.selectbox("Video Concatenation Mode", VIDEO_CONCATENATION_OPTIONS, key=f"{prefix}_video_concatenation")
+                settings["match_visuals_to_script_order"] = st.checkbox("Match Visuals to Script Order", value=False, key=f"{prefix}_match_visuals")
+                settings["video_transition_mode"] = st.selectbox("Video Transition Mode", VIDEO_TRANSITION_OPTIONS, key=f"{prefix}_video_transition")
+            with video_cols[1]:
+                settings["video_aspect_ratio"] = st.selectbox("Video Aspect Ratio", ["Portrait 9:16", "Landscape 16:9", "Square 1:1"], key=f"{prefix}_video_aspect_ratio")
+                settings["maximum_clip_duration"] = st.selectbox("Maximum Clip Duration (seconds)", [3, 5, 8, 10, 15], key=f"{prefix}_maximum_clip_duration")
+                settings["videos_per_run"] = st.selectbox("Videos per Run", list(range(1, 11)), key=f"{prefix}_videos_per_run")
+                settings["video_encoder"] = st.selectbox("Video Encoder", VIDEO_ENCODER_OPTIONS, key=f"{prefix}_video_encoder")
 
     if "Configurações de áudio" in visible_sections:
-        st.markdown("### Audio Settings")
-        audio_cols = st.columns(2)
-        with audio_cols[0]:
-            settings["voiceover_mode"] = st.radio("Voiceover Mode", VOICEOVER_MODE_OPTIONS, horizontal=True, key=f"{prefix}_voiceover_mode")
-            settings["voiceover_service"] = st.selectbox("Voiceover Service", VOICEOVER_SERVICE_OPTIONS, key=f"{prefix}_voiceover_service")
-            if channel is not None:
-                channel_id = str(channel.get("id") or channel.get("name") or "")
-                channel_voice = str(channel.get("default_voice") or channel.get("voice") or "").strip()
-                channel_state_key = f"{prefix}_voice_channel_id"
-                if st.session_state.get(channel_state_key) != channel_id:
-                    st.session_state[f"{prefix}_voice"] = channel_voice
-                    st.session_state[channel_state_key] = channel_id
-            current_voice = str(st.session_state.get(f"{prefix}_voice", ""))
-            voice_options = voice_catalog(current_voice)
-            settings["voice"] = st.selectbox("Voice (match script language)", voice_options, format_func=lambda value: value or "Sem voz seleccionada", key=f"{prefix}_voice")
-            volume_speed_cols = st.columns(2)
-            with volume_speed_cols[0]:
-                settings["voiceover_volume"] = st.selectbox("Voiceover Volume", VOICEOVER_VOLUME_OPTIONS, index=VOICEOVER_VOLUME_OPTIONS.index("100%"), key=f"{prefix}_voiceover_volume")
-            with volume_speed_cols[1]:
-                settings["voiceover_speed"] = st.selectbox("Voiceover Speed", VOICEOVER_SPEED_OPTIONS, index=VOICEOVER_SPEED_OPTIONS.index("1.0x"), key=f"{prefix}_voiceover_speed")
-            st.button("Preview Voice", key=f"{prefix}_preview_voice", disabled=True, help="A pré-visualização de voz será ligada ao provider configurado.")
-        with audio_cols[1]:
-            settings["background_music_source"] = st.selectbox("Background Music Source", BACKGROUND_MUSIC_SOURCE_OPTIONS, index=3, key=f"{prefix}_background_music_source")
-            settings["background_music_volume"] = st.selectbox("Background Music Volume", BACKGROUND_MUSIC_VOLUME_OPTIONS, index=2, key=f"{prefix}_background_music_volume")
+        with st.expander("Configurações de áudio", expanded=False):
+            st.markdown("### Audio Settings")
+            audio_cols = st.columns(2)
+            with audio_cols[0]:
+                settings["voiceover_mode"] = st.radio("Voiceover Mode", VOICEOVER_MODE_OPTIONS, horizontal=True, key=f"{prefix}_voiceover_mode")
+                settings["voiceover_service"] = st.selectbox("Voiceover Service", VOICEOVER_SERVICE_OPTIONS, key=f"{prefix}_voiceover_service")
+                if channel is not None:
+                    channel_id = str(channel.get("id") or channel.get("name") or "")
+                    channel_voice = str(channel.get("default_voice") or channel.get("voice") or "").strip()
+                    channel_state_key = f"{prefix}_voice_channel_id"
+                    if st.session_state.get(channel_state_key) != channel_id:
+                        st.session_state[f"{prefix}_voice"] = channel_voice
+                        st.session_state[channel_state_key] = channel_id
+                current_voice = str(st.session_state.get(f"{prefix}_voice", ""))
+                voice_options = voice_catalog(current_voice)
+                settings["voice"] = st.selectbox("Voice (match script language)", voice_options, format_func=lambda value: value or "Sem voz seleccionada", key=f"{prefix}_voice")
+                volume_speed_cols = st.columns(2)
+                with volume_speed_cols[0]:
+                    settings["voiceover_volume"] = st.selectbox("Voiceover Volume", VOICEOVER_VOLUME_OPTIONS, index=VOICEOVER_VOLUME_OPTIONS.index("100%"), key=f"{prefix}_voiceover_volume")
+                with volume_speed_cols[1]:
+                    settings["voiceover_speed"] = st.selectbox("Voiceover Speed", VOICEOVER_SPEED_OPTIONS, index=VOICEOVER_SPEED_OPTIONS.index("1.0x"), key=f"{prefix}_voiceover_speed")
+                st.button("Preview Voice", key=f"{prefix}_preview_voice", disabled=True, help="A pré-visualização de voz será ligada ao provider configurado.")
+            with audio_cols[1]:
+                settings["background_music_source"] = st.selectbox("Background Music Source", BACKGROUND_MUSIC_SOURCE_OPTIONS, index=3, key=f"{prefix}_background_music_source")
+                settings["background_music_volume"] = st.selectbox("Background Music Volume", BACKGROUND_MUSIC_VOLUME_OPTIONS, index=2, key=f"{prefix}_background_music_volume")
 
     if "Configurações de legendas" in visible_sections:
-        st.markdown("### Subtitle Settings")
-        subtitle_cols = st.columns(2)
-        with subtitle_cols[0]:
-            settings["enable_subtitles"] = st.checkbox("Enable Subtitles", value=True, key=f"{prefix}_enable_subtitles")
-            settings["subtitle_font"] = st.selectbox("Font", SUBTITLE_FONT_OPTIONS, key=f"{prefix}_subtitle_font")
-            settings["subtitle_position"] = st.selectbox("Position", SUBTITLE_POSITION_OPTIONS, key=f"{prefix}_subtitle_position")
-            settings["subtitle_color"] = st.color_picker("Color", "#FFFFFF", key=f"{prefix}_subtitle_color")
-            settings["subtitle_background"] = st.checkbox("Background", value=True, key=f"{prefix}_subtitle_background")
-            settings["subtitle_background_color"] = st.color_picker("Background Color", "#000000", key=f"{prefix}_subtitle_background_color")
-            settings["subtitle_rounded_background"] = st.checkbox("Rounded Background", value=False, key=f"{prefix}_subtitle_rounded_background")
-        with subtitle_cols[1]:
-            settings["subtitle_font_size"] = st.slider("Font Size", min_value=12, max_value=96, value=60, key=f"{prefix}_subtitle_font_size")
-            settings["subtitle_outline"] = st.color_picker("Outline", "#000000", key=f"{prefix}_subtitle_outline")
-            settings["subtitle_outline_width"] = st.slider("Outline Width", min_value=0.0, max_value=5.0, value=1.5, step=0.25, key=f"{prefix}_subtitle_outline_width")
-            st.button("Restore Subtitle Defaults", key=f"{prefix}_restore_subtitle_defaults", disabled=True, help="Os valores predefinidos já estão activos nesta configuração.")
+        with st.expander("Configurações de legendas", expanded=False):
+            st.markdown("### Subtitle Settings")
+            subtitle_cols = st.columns(2)
+            with subtitle_cols[0]:
+                settings["enable_subtitles"] = st.checkbox("Enable Subtitles", value=True, key=f"{prefix}_enable_subtitles")
+                settings["subtitle_font"] = st.selectbox("Font", SUBTITLE_FONT_OPTIONS, key=f"{prefix}_subtitle_font")
+                settings["subtitle_position"] = st.selectbox("Position", SUBTITLE_POSITION_OPTIONS, key=f"{prefix}_subtitle_position")
+                settings["subtitle_color"] = st.color_picker("Color", "#FFFFFF", key=f"{prefix}_subtitle_color")
+                settings["subtitle_background"] = st.checkbox("Background", value=True, key=f"{prefix}_subtitle_background")
+                settings["subtitle_background_color"] = st.color_picker("Background Color", "#000000", key=f"{prefix}_subtitle_background_color")
+                settings["subtitle_rounded_background"] = st.checkbox("Rounded Background", value=False, key=f"{prefix}_subtitle_rounded_background")
+            with subtitle_cols[1]:
+                settings["subtitle_font_size"] = st.slider("Font Size", min_value=12, max_value=96, value=60, key=f"{prefix}_subtitle_font_size")
+                settings["subtitle_outline"] = st.color_picker("Outline", "#000000", key=f"{prefix}_subtitle_outline")
+                settings["subtitle_outline_width"] = st.slider("Outline Width", min_value=0.0, max_value=5.0, value=1.5, step=0.25, key=f"{prefix}_subtitle_outline_width")
+                st.button("Restore Subtitle Defaults", key=f"{prefix}_restore_subtitle_defaults", disabled=True, help="Os valores predefinidos já estão activos nesta configuração.")
     return settings
 
 
@@ -2099,43 +2192,42 @@ def render_new_video(page_title: str = "Criação de Vídeos", prefix: str = "ne
                                 st.warning(f"Pedido criado, mas não foi possível descarregar o áudio: {exc}")
                     music_path = st.session_state.get(f"{prefix}_music_path", "")
 
+            quantity = st.number_input("Quantidade", min_value=1, max_value=100, value=1, disabled=mode != "same_channel", key=f"{prefix}_quantity")
             payloads: dict[str, dict[str, Any]] = {}
             if mode == "general":
                 existing_topics = st.session_state.get(f"{prefix}_general_topics", {})
                 payloads = dict(st.session_state.get(f"{prefix}_general_payloads", {}))
-                if st.button("Gerar títulos e thumbnails para todos os canais", key=f"{prefix}_generate_general_creative", use_container_width=True):
-                    settings = read_json("settings.json", {})
-                    new_payloads: dict[str, dict[str, Any]] = {}
-                    errors: list[str] = []
-                    with st.spinner("A gerar títulos e thumbnails independentes por canal…"):
-                        for channel in all_channels:
-                            try:
-                                topic_result = existing_topics.get(channel["id"])
-                                if not topic_result:
-                                    topic_result = generate_topic_for_ui(settings, channel, general_context)
-                                generated = generate_creative_for_ui(settings, channel, topic_result["topic"], topic_source="llm")
-                                generated["ai_generation"]["topic"] = topic_result
-                                new_payloads[channel["id"]] = generated
-                            except CreativeGenerationError as exc:
-                                errors.append(f"{channel.get('name', 'Canal')}: {exc}")
-                    if errors:
-                        for error in errors:
-                            st.error(error)
-                    else:
-                        st.session_state[f"{prefix}_general_topics"] = {cid: {"topic": item["topic"], "topic_source": "llm"} for cid, item in new_payloads.items()}
-                        st.session_state[f"{prefix}_general_payloads"] = new_payloads
-                        payloads = new_payloads
-                        st.success(f"Pacote criativo pronto para {len(new_payloads)} canais.")
+                with st.expander("Gerar Thumbnail com IA", expanded=False):
+                    if st.button("Gerar Thumbnail com IA para todos os vídeos", key=f"{prefix}_generate_general_creative", use_container_width=True):
+                        settings = read_json("settings.json", {})
+                        new_payloads: dict[str, dict[str, Any]] = {}
+                        errors: list[str] = []
+                        with st.spinner("A gerar uma thumbnail independente por vídeo…"):
+                            for channel in all_channels:
+                                try:
+                                    topic_result = existing_topics.get(channel["id"])
+                                    topic = str((topic_result or {}).get("topic") or "").strip()
+                                    if not topic:
+                                        errors.append(f"{channel.get('name', 'Canal')}: gere primeiro o tópico individual do canal.")
+                                        continue
+                                    generated = generate_thumbnail_for_ui(settings, channel, topic, title=topic, topic_source=str((topic_result or {}).get("topic_source") or "llm"))
+                                    generated["ai_generation"]["topic"] = topic_result
+                                    new_payloads[channel["id"]] = generated
+                                except CreativeGenerationError as exc:
+                                    errors.append(f"{channel.get('name', 'Canal')}: {exc}")
+                        if errors:
+                            for error in errors:
+                                st.error(error)
+                        else:
+                            st.session_state[f"{prefix}_general_payloads"] = new_payloads
+                            payloads = new_payloads
+                            st.success(f"Thumbnail pronta para {len(new_payloads)} vídeo(s).")
                 payloads = st.session_state.get(f"{prefix}_general_payloads", payloads)
                 for channel in all_channels:
                     payload = payloads.get(channel["id"])
                     if not payload:
                         continue
-                    with st.expander(f"{channel.get('name', 'Canal')} — título e thumbnail", expanded=False):
-                        title_options = [item.get("title", "") for item in payload.get("title_candidates", []) if item.get("title")]
-                        if title_options:
-                            selected_title = st.selectbox("Título escolhido", title_options, index=max(0, title_options.index(payload.get("title")) if payload.get("title") in title_options else 0), key=f"{prefix}_general_title_{channel['id']}")
-                            payload["title"] = selected_title
+                    with st.expander(f"{channel.get('name', 'Canal')} — thumbnail", expanded=False):
                         variants = payload.get("thumbnail_variants", [])
                         if variants:
                             labels = [f"{idx + 1}. {item.get('concept', 'Variante')}" for idx, item in enumerate(variants)]
@@ -2176,83 +2268,87 @@ def render_new_video(page_title: str = "Criação de Vídeos", prefix: str = "ne
                                 st.caption("A imagem ainda não foi gerada. Configure a API key em Configuração API > API Keys.")
                         st.caption(f"Estado da thumbnail: {payload.get('thumbnail_status', 'prompt_ready')} · texto: {payload.get('thumbnail_text') or 'sem texto'}")
             else:
-                topic_for_creative = str(generation_settings.get("video_subject") or "").strip()
-                if st.button("Gerar títulos e thumbnails com IA", key=f"{prefix}_generate_creative", use_container_width=True):
-                    if selected_one is None:
-                        st.error("Seleccione primeiro um canal.")
-                    else:
-                        try:
-                            if not topic_for_creative:
-                                topic_result = generate_topic_for_ui(read_json("settings.json", {}), selected_one)
-                                topic_for_creative = str(topic_result["topic"]).strip()
-                                st.session_state[f"{prefix}_topic"] = topic_for_creative
-                                st.session_state[f"{prefix}_topic_meta"] = topic_result
-                            generated = generate_creative_for_ui(
-                                read_json("settings.json", {}),
-                                selected_one,
-                                topic_for_creative,
-                                topic_source=_video_topic_source(topic_for_creative, prefix),
-                            )
-
-                            st.session_state[f"{prefix}_creative_payload"] = generated
-                            st.success("Tema, título e thumbnails gerados; escolha a variante antes de criar as tarefas.")
-                            st.rerun()
-                        except CreativeGenerationError as exc:
-                            st.error(str(exc))
-                payload = st.session_state.get(f"{prefix}_creative_payload")
-                if payload:
-                    st.subheader("Título e Thumbnail automáticos")
-                    title_options = [item.get("title", "") for item in payload.get("title_candidates", []) if item.get("title")]
-                    if title_options:
-                        selected_title = st.selectbox("Título escolhido", title_options, index=max(0, title_options.index(payload.get("title")) if payload.get("title") in title_options else 0), key=f"{prefix}_title_choice")
-                        payload["title"] = selected_title
-                        with st.expander(f"Ver {len(title_options)} candidatos de título"):
-                            st.dataframe(payload.get("title_candidates", []), use_container_width=True, hide_index=True)
-                    variants = payload.get("thumbnail_variants", [])
-                    if variants:
-                        labels = [f"{idx + 1}. {item.get('concept', 'Variante')}" for idx, item in enumerate(variants)]
-                        selected_variant_label = st.selectbox("Thumbnail escolhida", labels, key=f"{prefix}_thumbnail_choice")
-                        variant_index = labels.index(selected_variant_label)
-                        variant = variants[variant_index]
-                        payload["thumbnail_variant"] = variant
-                        payload["thumbnail_prompt"] = variant.get("image_prompt", "")
-                        payload["thumbnail_text"] = variant.get("overlay_text", "")
-                        st.caption(f"Composição: {variant.get('composition', '')} · Cores: {variant.get('color_palette', '')}")
-                        st.code(variant.get("image_prompt", ""), language="text")
-                        thumbnail_path = str(variant.get("image_path") or payload.get("thumbnail_path") or "").strip()
-                        if st.button("Gerar imagem da thumbnail com Nano Banana", key=f"{prefix}_generate_thumbnail_image", use_container_width=True):
+                with st.expander("Gerar Thumbnail com IA", expanded=False):
+                    topic_for_thumbnail = str(generation_settings.get("video_subject") or "").strip()
+                    if st.button("Gerar Thumbnail com IA", key=f"{prefix}_generate_creative", use_container_width=True):
+                        if selected_one is None:
+                            st.error("Seleccione primeiro um canal.")
+                        elif not topic_for_thumbnail:
+                            st.error("Preencha o Video Subject antes de gerar a thumbnail.")
+                        else:
                             try:
-                                thumbnail_path = str(
-                                    generate_thumbnail_image(
-                                        read_json("settings.json", {}),
-                                        variant.get("image_prompt", ""),
-                                        topic=str(payload.get("topic") or ""),
-                                        variant_index=variant_index,
-                                        lettering_text=str(variant.get("overlay_text") or payload.get("thumbnail_text") or ""),
-                                        lettering_prompt=str(variant.get("lettering_prompt") or ""),
-                                    )
+                                existing_payload = dict(st.session_state.get(f"{prefix}_creative_payload") or {})
+                                existing_title = str(existing_payload.get("title") or topic_for_thumbnail).strip()
+                                generated = generate_thumbnail_variants_for_ui(
+                                    read_json("settings.json", {}),
+                                    selected_one,
+                                    topic_for_thumbnail,
+                                    int(quantity if mode == "same_channel" else 1),
+                                    title=existing_title,
+                                    topic_source=_video_topic_source(topic_for_thumbnail, prefix),
                                 )
-                                variant["image_path"] = thumbnail_path
-                                payload["thumbnail_path"] = thumbnail_path
-                                payload["thumbnail_status"] = "generated"
-                                st.session_state[f"{prefix}_creative_payload"] = payload
-                                record_notification("thumbnail_generation_completed", f"Thumbnail gerada: {payload.get('title') or payload.get('topic') or 'Vídeo'}", "A thumbnail foi gerada com sucesso pelo Nano Banana.", metadata={"channel_name": selected_one.get("name") if selected_one else "", "image_path": Path(thumbnail_path).name}, dedupe_key=f"thumbnail:{thumbnail_path}")
-                                st.success("Thumbnail gerada com Nano Banana.")
+                                generated = {**existing_payload, **generated}
+                                generated["topic"] = topic_for_thumbnail
+                                generated["title"] = existing_title
+                                generated["title_candidates"] = existing_payload.get("title_candidates", [])
+                                st.session_state[f"{prefix}_creative_payload"] = generated
+                                st.success(f"Thumbnail pronta para {int(quantity if mode == 'same_channel' else 1)} vídeo(s); o título existente foi preservado.")
                                 st.rerun()
-                            except ThumbnailGenerationError as exc:
+                            except CreativeGenerationError as exc:
                                 st.error(str(exc))
-                        if thumbnail_path and Path(thumbnail_path).is_file():
-                            st.image(thumbnail_path, caption="Thumbnail gerada pelo Nano Banana", use_container_width=True)
-                            payload["thumbnail_path"] = thumbnail_path
-                            payload["thumbnail_status"] = "generated"
-                        else:
-                            st.info("Escolha a variante e clique em **Gerar imagem da thumbnail com Nano Banana**. A API key é configurada em Configuração API > API Keys.")
-                    st.session_state[f"{prefix}_creative_payload"] = payload
+                    payload = st.session_state.get(f"{prefix}_creative_payload")
+                    if payload:
+                        st.subheader("Thumbnail automática")
+                        st.caption(f"Título preservado: {payload.get('title') or payload.get('topic') or 'Sem título'}")
+                        title_options = [item.get("title", "") for item in payload.get("title_candidates", []) if item.get("title")]
+                        if title_options:
+                            selected_title = st.selectbox("Título escolhido", title_options, index=max(0, title_options.index(payload.get("title")) if payload.get("title") in title_options else 0), key=f"{prefix}_title_choice")
+                            payload["title"] = selected_title
+                            with st.expander(f"Ver {len(title_options)} candidatos de título"):
+                                st.dataframe(payload.get("title_candidates", []), use_container_width=True, hide_index=True)
+                        variants = payload.get("thumbnail_variants", [])
+                        if variants:
+                            labels = [f"{idx + 1}. {item.get('concept', 'Variante')}" for idx, item in enumerate(variants)]
+                            selected_variant_label = st.selectbox("Thumbnail escolhida", labels, key=f"{prefix}_thumbnail_choice")
+                            variant_index = labels.index(selected_variant_label)
+                            variant = variants[variant_index]
+                            payload["thumbnail_variant"] = variant
+                            payload["thumbnail_prompt"] = variant.get("image_prompt", "")
+                            payload["thumbnail_text"] = variant.get("overlay_text", "")
+                            st.caption(f"Composição: {variant.get('composition', '')} · Cores: {variant.get('color_palette', '')}")
+                            st.code(variant.get("image_prompt", ""), language="text")
+                            thumbnail_path = str(variant.get("image_path") or payload.get("thumbnail_path") or "").strip()
+                            if st.button("Gerar imagem da thumbnail com Nano Banana", key=f"{prefix}_generate_thumbnail_image", use_container_width=True):
+                                try:
+                                    thumbnail_path = str(
+                                        generate_thumbnail_image(
+                                            read_json("settings.json", {}),
+                                            variant.get("image_prompt", ""),
+                                            topic=str(payload.get("topic") or ""),
+                                            variant_index=variant_index,
+                                            lettering_text=str(variant.get("overlay_text") or payload.get("thumbnail_text") or ""),
+                                            lettering_prompt=str(variant.get("lettering_prompt") or ""),
+                                        )
+                                    )
+                                    variant["image_path"] = thumbnail_path
+                                    payload["thumbnail_path"] = thumbnail_path
+                                    payload["thumbnail_status"] = "generated"
+                                    st.session_state[f"{prefix}_creative_payload"] = payload
+                                    record_notification("thumbnail_generation_completed", f"Thumbnail gerada: {payload.get('title') or payload.get('topic') or 'Vídeo'}", "A thumbnail foi gerada com sucesso pelo Nano Banana.", metadata={"channel_name": selected_one.get("name") if selected_one else "", "image_path": Path(thumbnail_path).name}, dedupe_key=f"thumbnail:{thumbnail_path}")
+                                    st.success("Thumbnail gerada com Nano Banana.")
+                                    st.rerun()
+                                except ThumbnailGenerationError as exc:
+                                    st.error(str(exc))
+                            if thumbnail_path and Path(thumbnail_path).is_file():
+                                st.image(thumbnail_path, caption="Thumbnail gerada pelo Nano Banana", use_container_width=True)
+                                payload["thumbnail_path"] = thumbnail_path
+                                payload["thumbnail_status"] = "generated"
+                            else:
+                                st.info("Escolha a variante e clique em **Gerar imagem da thumbnail com Nano Banana**. A API key é configurada em Configuração API > API Keys.")
+                        st.session_state[f"{prefix}_creative_payload"] = payload
 
             st.session_state[f"{prefix}_generation_settings"] = dict(generation_settings)
             with st.form(f"{prefix}_form"):
-
-                quantity = st.number_input("Quantidade", min_value=1, max_value=100, value=1, disabled=mode != "same_channel")
                 language = generation_settings["script_language"]
                 fmt = generation_settings["video_format"]
                 submitted = st.form_submit_button("Criar tarefas", type="primary")
@@ -3604,21 +3700,28 @@ def render_automation():
     for channel in channels:
         channel_id = channel["id"]
         with st.container(border=True):
-            cols = st.columns([0.55, 2.35, 1.35, 1.5, 1.35])
-            with cols[0]:
+            header_cols = st.columns([0.55, 2.35, 1.35, 1.5, 1.35])
+            with header_cols[0]:
                 if channel.get("thumbnail_url"):
                     st.image(channel["thumbnail_url"], width=48)
                 else:
                     st.markdown("### YT")
-            with cols[1]:
+            with header_cols[1]:
                 st.write(f"**{channel.get('name', 'Sem nome')}**")
                 st.caption(channel.get("handle") or channel.get("url") or "sem URL")
+            with header_cols[2]:
+                enabled = st.toggle("Automação ligada", value=bool(channel.get("automation_on", False)), key=f"automation_on_{channel_id}")
+            with header_cols[3]:
+                schedule_time = st.text_input("Horário (HH:MM)", value=channel.get("automation_time", "00:00"), key=f"automation_time_{channel_id}")
             blueprint_ids, blueprint_labels, current_blueprint, voice_options, current_voice = channel_default_options(channel)
-            default_cols = st.columns(4, gap="small")
+            default_cols = st.columns([1.15, 1.15, 1.5, 1.7, 1.35], gap="small")
             with default_cols[0]:
                 st.markdown("**Idioma Padrão**")
                 st.caption(language_label(channel.get("language") or "pt"))
             with default_cols[1]:
+                st.markdown("**Nicho Padrão**")
+                st.caption(channel_niche_label(channel))
+            with default_cols[2]:
                 automation_blueprint = st.selectbox(
                     "Blueprint Padrão",
                     blueprint_ids,
@@ -3626,9 +3729,6 @@ def render_automation():
                     format_func=lambda item: blueprint_labels.get(item, item or "Sem Blueprint padrão"),
                     key=f"automation_blueprint_{channel_id}",
                 )
-            with default_cols[2]:
-                st.markdown("**Nicho Padrão**")
-                st.caption(channel_niche_label(channel))
             with default_cols[3]:
                 automation_voice = st.selectbox(
                     "Narrador/Voz Padrão",
@@ -3637,11 +3737,7 @@ def render_automation():
                     format_func=lambda item: item or "Sem voz padrão",
                     key=f"automation_voice_{channel_id}",
                 )
-            with cols[2]:
-                enabled = st.toggle("Automação ON", value=bool(channel.get("automation_on", False)), key=f"automation_on_{channel_id}")
-            with cols[3]:
-                schedule_time = st.text_input("Horário (HH:MM)", value=channel.get("automation_time", "00:00"), key=f"automation_time_{channel_id}")
-            with cols[4]:
+            with default_cols[4]:
                 if st.button("Guardar", key=f"automation_save_{channel_id}", use_container_width=True):
                     if not valid_hhmm(schedule_time):
                         st.error("Use o formato HH:MM, por exemplo 08:30.")

package/hermes_ui/domain.py

@@ -135,7 +135,16 @@ def create_tasks_for_batch(batch: dict[str, Any]) -> list[dict[str, Any]]:
                 topic = f"Vídeo para {channel.get('name', 'Canal')}"
             title = str(payload.get("title") or topic).strip()
             artifacts = dict(payload.get("artifacts") or {})
-            thumbnail_path = str(payload.get("thumbnail_path") or "").strip()
+            thumbnail_variants = payload.get("thumbnail_variants") if isinstance(payload.get("thumbnail_variants"), list) else []
+            thumbnail_variant = payload.get("thumbnail_variant") if isinstance(payload.get("thumbnail_variant"), dict) else {}
+            if count > 1 and thumbnail_variants:
+                candidate = thumbnail_variants[index % len(thumbnail_variants)]
+                if isinstance(candidate, dict):
+                    thumbnail_variant = candidate
+            thumbnail_path = str(thumbnail_variant.get("image_path") or payload.get("thumbnail_path") or "").strip()
+            thumbnail_prompt = str(thumbnail_variant.get("image_prompt") or payload.get("thumbnail_prompt") or "").strip()
+            thumbnail_text = str(thumbnail_variant.get("overlay_text") or payload.get("thumbnail_text") or "").strip()
+            thumbnail_status = str(payload.get("thumbnail_status") or ("generated" if thumbnail_path else "not_generated"))
             if thumbnail_path:
                 artifacts.setdefault("thumbnail", thumbnail_path)
             task = {
@@ -161,11 +170,11 @@ def create_tasks_for_batch(batch: dict[str, Any]) -> list[dict[str, Any]]:
                 "voice": payload.get("voice") or channel.get("default_voice") or channel.get("voice", ""),
                 "automation_on": bool(channel.get("automation_on", False)),
                 "automation_time": channel.get("automation_time", "00:00"),
-                "thumbnail_variant": payload.get("thumbnail_variant", {}),
-                "thumbnail_variants": payload.get("thumbnail_variants", []),
-                "thumbnail_prompt": payload.get("thumbnail_prompt", ""),
-                "thumbnail_text": payload.get("thumbnail_text", ""),
-                "thumbnail_status": payload.get("thumbnail_status", "not_generated"),
+                "thumbnail_variant": thumbnail_variant,
+                "thumbnail_variants": thumbnail_variants,
+                "thumbnail_prompt": thumbnail_prompt,
+                "thumbnail_text": thumbnail_text,
+                "thumbnail_status": thumbnail_status,
                 "title_candidates": payload.get("title_candidates", []),
                 "ai_generation": payload.get("ai_generation", {}),
                 "stage": "script",

package/hermes_ui/pipeline_worker.py

@@ -470,8 +470,26 @@ def _run_task(task: dict[str, Any]) -> dict[str, Any]:
     _update(task_id, artifacts=artifacts, progress=30)
 
     _update(task_id, stage="title", state="doing", progress=35)
-    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 topic).strip()
+    provided_title = str(task.get("title") or "").strip()
+    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)
@@ -482,6 +500,8 @@ def _run_task(task: dict[str, Any]) -> dict[str, Any]:
 
     _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
     prompt_payload = {
         "topic": topic,
         "title": title,

package/package.json

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