@danhachuel/thunderbolt 0.3.21 → 0.3.23

package/app/main.py

@@ -22,6 +22,7 @@ except (OSError, json.JSONDecodeError):
     APP_VERSION = ""
 
 from hermes_ui.domain import STAGES, create_batch, create_channel, create_tasks_for_batch, delete_channel, pipeline_summary, set_channel_defaults, transition_task, update_channel, update_channel_video
+from hermes_ui.drafts import save_draft
 from hermes_ui.automation_worker import load_worker_status
 from hermes_ui.storage import BLUEPRINTS, DEFAULT_LLM_PROVIDER, MEDIA_DOWNLOADS, STORAGE, TIKTOK_PROMPT_MASTERS, ensure_storage, get_display_name, list_blueprint_files, list_prompt_master_files, load_blueprint_file, load_prompt_master_file, now, read_json, set_display_name, write_json
 from app.modules.niche_finder.apify import ApifyError, DEFAULT_ACTOR_ID, abort_actor_run, build_actor_input, get_dataset_items, normalize_video_items, start_actor_run, wait_for_actor_run
@@ -45,6 +46,7 @@ from hermes_ui.script_documents import list_script_documents, read_script_docume
 from hermes_ui.script_generation import generate_script_document
 from hermes_ui.voice_preview import DEFAULT_SAMPLE, load_preview_file, synthesize_preview
 from hermes_ui.thumbnail_generation import ThumbnailGenerationError, generate_thumbnail_image
+from hermes_ui.thumbnails import list_thumbnail_tasks, regenerate_thumbnail
 from hermes_ui.creative_generation import CreativeGenerationError, generate_creative_package, 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
@@ -520,17 +522,19 @@ def generate_video_content_for_ui(
     subject: str,
     language: str,
     generation_settings: dict[str, Any] | None = None,
+    blueprint: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
     """Generate the subject, script and English keywords in one MoneyPrinter-style action."""
     subject = str(subject or "").strip()
     topic_result: dict[str, Any] | None = None
     if not subject:
-        topic_result = generate_topic_for_ui(settings, channel)
+        selected_blueprint = blueprint if isinstance(blueprint, dict) else blueprint_for_channel(channel)
+        topic_result = generate_topic_for_channel(settings, channel, selected_blueprint)
         subject = str(topic_result.get("topic") or "").strip()
     if not subject:
         raise CreativeGenerationError("A IA não devolveu um Video Subject válido.")
 
-    blueprint = blueprint_for_channel(channel)
+    blueprint = blueprint if isinstance(blueprint, dict) else blueprint_for_channel(channel)
     script_result = generate_script_document(
         settings,
         document_type="Roteiro de vídeo",
@@ -561,7 +565,7 @@ def generate_video_content_for_ui(
     }
 
 
-def _generate_video_content_callback(prefix: str, channel: dict, fallback_language: str) -> None:
+def _generate_video_content_callback(prefix: str, channel: dict, fallback_language: str, blueprint: dict[str, Any] | None = None) -> None:
     """Streamlit callback for the single button below Subject, Script and Keywords."""
     settings = read_json("settings.json", {})
     generation_settings = {
@@ -577,17 +581,30 @@ def _generate_video_content_callback(prefix: str, channel: dict, fallback_langua
             generation_settings["video_subject"],
             generation_settings["script_language"],
             generation_settings=generation_settings,
+            blueprint=blueprint,
         )
         st.session_state[f"{prefix}_video_subject"] = result["topic"]
         st.session_state[f"{prefix}_video_script"] = result["script"]
         st.session_state[f"{prefix}_video_keywords"] = ", ".join(result["keywords"])
-        st.session_state["new_video_topic"] = result["topic"]
-        st.session_state["new_video_topic_meta"] = result.get("topic_result") or {
+        if prefix == "pipeline_scripts":
+            script_result = result.get("script_result") or {}
+            st.session_state["script_draft"] = {
+                "title": result["topic"],
+                "summary": str(script_result.get("summary") or ""),
+                "content": result["script"],
+                "keywords": result["keywords"],
+            }
+            st.session_state["script_draft_title"] = result["topic"]
+            st.session_state["script_draft_summary"] = str(script_result.get("summary") or "")
+            st.session_state["script_draft_content"] = result["script"]
+            st.session_state["script_draft_keywords"] = ", ".join(result["keywords"])
+        st.session_state[f"{prefix}_topic"] = result["topic"]
+        st.session_state[f"{prefix}_topic_meta"] = result.get("topic_result") or {
             "topic": result["topic"],
             "topic_source": result.get("topic_source", "manual"),
         }
         # A subject change invalidates a previously generated title/thumbnail package.
-        st.session_state.pop("new_video_creative_payload", None)
+        st.session_state.pop(f"{prefix}_creative_payload", None)
         st.session_state[f"{prefix}_generate_content_notice"] = "Tema, roteiro e palavras-chave gerados com IA."
         st.session_state.pop(f"{prefix}_generate_content_error", None)
     except CreativeGenerationError as exc:
@@ -595,8 +612,57 @@ def _generate_video_content_callback(prefix: str, channel: dict, fallback_langua
         st.session_state.pop(f"{prefix}_generate_content_notice", None)
 
 
-def _video_topic_source(subject: str) -> str:
-    meta = st.session_state.get("new_video_topic_meta") or {}
+def _save_pipeline_draft_callback(
+    prefix: str,
+    draft_kind: str,
+    page_title: str,
+    *,
+    channel: dict[str, Any] | None = None,
+    blueprint: dict[str, Any] | None = None,
+    document_type: str = "video_script",
+    title: str = "",
+    brief: str = "",
+) -> None:
+    """Persist the current editable pipeline fields as a local draft."""
+    channel = channel or {}
+    blueprint = blueprint or {}
+    is_script_draft = prefix == "pipeline_scripts"
+    subject = str(st.session_state.get(f"{prefix}_video_subject") or "").strip()
+    script = str(st.session_state.get(f"{prefix}_video_script") or "").strip()
+    keywords = str(st.session_state.get(f"{prefix}_video_keywords") or (st.session_state.get("script_draft_keywords") if is_script_draft else "") or "").strip()
+    draft_title = str((st.session_state.get("script_draft_title") if is_script_draft else "") or title or subject or page_title).strip()
+    draft_brief = str((st.session_state.get("script_brief") if is_script_draft else "") or brief or subject).strip()
+    draft_content = str((st.session_state.get("script_draft_content") if is_script_draft else "") or script).strip()
+    if not any((draft_title, draft_brief, draft_content, keywords)):
+        st.session_state[f"{prefix}_save_draft_error"] = "Preencha pelo menos um campo antes de guardar o rascunho."
+        st.session_state.pop(f"{prefix}_save_draft_notice", None)
+        return
+
+    record = save_draft(
+        {
+            "draft_kind": draft_kind,
+            "page": page_title,
+            "title": draft_title,
+            "brief": draft_brief,
+            "content": draft_content,
+            "video_subject": subject,
+            "video_script": script,
+            "video_keywords": keywords,
+            "summary": str((st.session_state.get("script_draft_summary") if is_script_draft else "") or "").strip(),
+            "document_type": document_type,
+            "language": str(st.session_state.get(f"{prefix}_script_language") or "").strip(),
+            "channel_id": str(channel.get("id") or ""),
+            "channel_name": str(channel.get("name") or "Documento independente"),
+            "blueprint_id": str(blueprint.get("id") or ""),
+            "blueprint_name": str(blueprint.get("name") or "SEM BLUEPRINT CONFIGURADO"),
+        }
+    )
+    st.session_state[f"{prefix}_save_draft_notice"] = f"Rascunho guardado localmente: {record['id']}."
+    st.session_state.pop(f"{prefix}_save_draft_error", None)
+
+
+def _video_topic_source(subject: str, prefix: str = "new_video") -> str:
+    meta = st.session_state.get(f"{prefix}_topic_meta") or {}
     generated_topic = str(meta.get("topic") or "").strip() if isinstance(meta, dict) else ""
     return "llm" if generated_topic and generated_topic == str(subject or "").strip() and meta.get("topic_source") == "llm" else "manual"
 
@@ -645,6 +711,7 @@ def render_video_generation_settings(
     current_language: str = "",
     channel: dict[str, Any] | None = None,
     generate_content_callback: Any | None = None,
+    save_draft_callback: Any | None = None,
 ) -> dict[str, Any]:
     """Render the shared MoneyPrinter-style settings and return a serializable payload."""
     settings: dict[str, Any] = {}
@@ -701,6 +768,20 @@ def render_video_generation_settings(
         if st.session_state.get(f"{prefix}_generate_content_error"):
             st.error(st.session_state[f"{prefix}_generate_content_error"])
 
+    if save_draft_callback is not None:
+        st.button(
+            "Salvar rascunho",
+            key=f"{prefix}_save_draft",
+            use_container_width=True,
+            type="secondary",
+            icon=":material/save:",
+            on_click=save_draft_callback,
+        )
+        if st.session_state.get(f"{prefix}_save_draft_notice"):
+            st.success(st.session_state[f"{prefix}_save_draft_notice"])
+        if st.session_state.get(f"{prefix}_save_draft_error"):
+            st.error(st.session_state[f"{prefix}_save_draft_error"])
+
     st.markdown("### Video Settings")
     video_cols = st.columns(2)
     with video_cols[0]:
@@ -1667,7 +1748,7 @@ def render_channels():
             render_channel_videos(channel)
 
 
-def render_new_video(page_title: str = "Criação de Vídeos"):
+def render_new_video(page_title: str = "Criação de Vídeos", prefix: str = "new_video"):
     st.title(page_title)
     create_tab = render_localized_tabs(["Criar vídeo"])[0]
     with create_tab:
@@ -1680,7 +1761,7 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
                 "Modo de criação",
                 ["Canal específico", "Lote no mesmo canal", "Lote geral"],
                 horizontal=True,
-                key="new_video_mode",
+                key=f"{prefix}_mode",
             )
             mode = {"Canal específico": "single", "Lote no mesmo canal": "same_channel", "Lote geral": "general"}[mode_label]
             selected_one: dict[str, Any] | None = None
@@ -1701,11 +1782,11 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
                         st.caption(f"**{channel.get('name', 'Canal')}** · {status} · Blueprint: **{summary['name']}** · Voz: {summary['voice'] or 'Sem voz padrão'}")
                 general_context = st.text_area(
                     "Contexto opcional para todos os canais",
-                    value=st.session_state.get("new_video_general_context", ""),
-                    key="new_video_general_context",
+                    value=st.session_state.get(f"{prefix}_general_context", ""),
+                    key=f"{prefix}_general_context",
                     placeholder="Opcional: campanha, época, evento ou restrição editorial comum. O tema final será individual por canal.",
                 )
-                if st.button("Gerar tópicos individuais para todos os canais", key="new_video_generate_general_topics", use_container_width=True):
+                if st.button("Gerar tópicos individuais para todos os canais", key=f"{prefix}_generate_general_topics", use_container_width=True):
                     settings = read_json("settings.json", {})
                     generated_topics: dict[str, dict[str, Any]] = {}
                     errors: list[str] = []
@@ -1719,9 +1800,9 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
                         for error in errors:
                             st.error(error)
                     else:
-                        st.session_state["new_video_general_topics"] = generated_topics
+                        st.session_state[f"{prefix}_general_topics"] = generated_topics
                         st.success(f"Foram gerados {len(generated_topics)} briefings independentes.")
-                general_topics = st.session_state.get("new_video_general_topics", {})
+                general_topics = st.session_state.get(f"{prefix}_general_topics", {})
                 if general_topics:
                     st.subheader("Briefings por canal")
                     for channel in all_channels:
@@ -1729,35 +1810,56 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
                         if result:
                             st.write(f"**{channel.get('name', 'Canal')}**")
                             st.caption(f"{result.get('niche', '')} · {result.get('angle', '')}")
-                            st.text_area("Briefing gerado", value=result.get("topic", ""), key=f"new_video_general_topic_{channel['id']}", height=80)
+                            st.text_area("Briefing gerado", value=result.get("topic", ""), key=f"{prefix}_general_topic_{channel['id']}", height=80)
                 generation_settings = render_video_generation_settings(
-                    "new_video",
+                    prefix,
                     current_language=str(st.session_state.get("video_language") or ""),
+                    save_draft_callback=lambda: _save_pipeline_draft_callback(
+                        prefix,
+                        "music" if page_title == "Criação de Músicas" else "video",
+                        page_title,
+                        channel=selected_one,
+                        blueprint=blueprint_for_channel(selected_one or {}),
+                    ),
                 )
             else:
                 if not active_channels:
                     st.warning("Não existem canais activos disponíveis para os modos de canal específico.")
                     selected = []
                 else:
-                    selected_one = st.selectbox("Canal", active_channels, format_func=lambda c: c["name"], key="new_video_channel")
+                    selected_one = st.selectbox("Canal", active_channels, format_func=lambda c: c["name"], key=f"{prefix}_channel")
                     selected = [selected_one["id"]]
                     # Intentionally sits between Canal and the generation settings, as requested.
                     render_channel_blueprint_panel(selected_one)
                     generation_settings = render_video_generation_settings(
-                        "new_video",
+                        prefix,
                         current_language=str(st.session_state.get("video_language") or ""),
                         channel=selected_one,
                         generate_content_callback=lambda: _generate_video_content_callback(
-                            "new_video",
+                            prefix,
                             selected_one,
                             str(st.session_state.get("video_language") or "pt"),
                         ),
+                        save_draft_callback=lambda: _save_pipeline_draft_callback(
+                            prefix,
+                            "music" if page_title == "Criação de Músicas" else "video",
+                            page_title,
+                            channel=selected_one,
+                            blueprint=blueprint_for_channel(selected_one or {}),
+                        ),
                     )
 
             if not generation_settings:
                 generation_settings = render_video_generation_settings(
-                    "new_video",
+                    prefix,
                     current_language=str(st.session_state.get("video_language") or ""),
+                    save_draft_callback=lambda: _save_pipeline_draft_callback(
+                        prefix,
+                        "music" if page_title == "Criação de Músicas" else "video",
+                        page_title,
+                        channel=selected_one,
+                        blueprint=blueprint_for_channel(selected_one or {}),
+                    ),
                 )
             wide_style_label = generation_settings["video_source"]
             style_ia = generation_settings.get("style_ia", "")
@@ -1765,47 +1867,47 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
             music_source = ""
             if wide_style_label == "Apenas Música":
                 st.caption("Apenas Música não gera Pexels/Pixabay nem fundo IA; o áudio musical será usado como elemento principal.")
-                music_source = st.radio("Fonte da música", ["Ficheiro existente", "Carregar ficheiro", "Criar via Suno API"], horizontal=True, key="new_video_music_source")
+                music_source = st.radio("Fonte da música", ["Ficheiro existente", "Carregar ficheiro", "Criar via Suno API"], horizontal=True, key=f"{prefix}_music_source")
                 if music_source == "Ficheiro existente":
                     local_music = list_music_files()
                     if local_music:
-                        selected_music = st.selectbox("Música local", local_music, format_func=lambda item: item.name, key="new_video_music_existing")
+                        selected_music = st.selectbox("Música local", local_music, format_func=lambda item: item.name, key=f"{prefix}_music_existing")
                         music_path = str(selected_music)
                     else:
                         st.warning("Ainda não existem músicas em storage/music. Escolha Carregar ficheiro ou Criar via Suno API.")
                 elif music_source == "Carregar ficheiro":
-                    uploaded_music = st.file_uploader("Carregar música", type=["mp3", "wav", "m4a", "aac", "flac", "ogg"], key="new_video_music_upload")
-                    if uploaded_music and st.button("Guardar música local", key="new_video_music_store", use_container_width=True):
+                    uploaded_music = st.file_uploader("Carregar música", type=["mp3", "wav", "m4a", "aac", "flac", "ogg"], key=f"{prefix}_music_upload")
+                    if uploaded_music and st.button("Guardar música local", key=f"{prefix}_music_store", use_container_width=True):
                         try:
                             stored_music = store_music_file(uploaded_music.name, uploaded_music.getvalue())
-                            st.session_state["new_video_music_path"] = str(stored_music)
+                            st.session_state[f"{prefix}_music_path"] = str(stored_music)
                             st.success(f"Música guardada em `{stored_music}`")
                         except (OSError, ValueError) as exc:
                             st.error(str(exc))
-                    music_path = st.session_state.get("new_video_music_path", "")
+                    music_path = st.session_state.get(f"{prefix}_music_path", "")
                 else:
-                    suno_prompt = st.text_area("Prompt musical Suno", placeholder="Instrumental cinematográfico, calmo, sem voz...", key="new_video_suno_prompt")
-                    suno_title = st.text_input("Título da música", value=st.session_state.get("new_video_topic") or "Thunderbolt music", key="new_video_suno_title")
-                    if st.button("Solicitar música no Suno", key="new_video_suno_request", use_container_width=True):
+                    suno_prompt = st.text_area("Prompt musical Suno", placeholder="Instrumental cinematográfico, calmo, sem voz...", key=f"{prefix}_suno_prompt")
+                    suno_title = st.text_input("Título da música", value=st.session_state.get(f"{prefix}_topic") or "Thunderbolt music", key=f"{prefix}_suno_title")
+                    if st.button("Solicitar música no Suno", key=f"{prefix}_suno_request", use_container_width=True):
                         suno_result = request_suno_generation(read_json("settings.json", {}), suno_prompt, suno_title)
                         (st.success if suno_result["ok"] else st.error)(suno_result["message"])
                         if suno_result["ok"]:
                             try:
                                 generated = materialize_suno_audio(suno_result.get("data", {}), suno_title or "suno-generated.mp3")
                                 if generated:
-                                    st.session_state["new_video_music_path"] = str(generated)
+                                    st.session_state[f"{prefix}_music_path"] = str(generated)
                                     st.success(f"Música descarregada para `{generated}`")
                                 else:
                                     st.info("O pedido foi aceite, mas o endpoint ainda não devolveu uma URL de áudio. Consulte o estado no serviço Suno e adicione o ficheiro quando estiver pronto.")
                             except (OSError, requests.RequestException, ValueError) as exc:
                                 st.warning(f"Pedido criado, mas não foi possível descarregar o áudio: {exc}")
-                    music_path = st.session_state.get("new_video_music_path", "")
+                    music_path = st.session_state.get(f"{prefix}_music_path", "")
 
             payloads: dict[str, dict[str, Any]] = {}
             if mode == "general":
-                existing_topics = st.session_state.get("new_video_general_topics", {})
-                payloads = dict(st.session_state.get("new_video_general_payloads", {}))
-                if st.button("Gerar títulos e thumbnails para todos os canais", key="new_video_generate_general_creative", use_container_width=True):
+                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] = []
@@ -1824,11 +1926,11 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
                         for error in errors:
                             st.error(error)
                     else:
-                        st.session_state["new_video_general_topics"] = {cid: {"topic": item["topic"], "topic_source": "llm"} for cid, item in new_payloads.items()}
-                        st.session_state["new_video_general_payloads"] = new_payloads
+                        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.")
-                payloads = st.session_state.get("new_video_general_payloads", payloads)
+                payloads = st.session_state.get(f"{prefix}_general_payloads", payloads)
                 for channel in all_channels:
                     payload = payloads.get(channel["id"])
                     if not payload:
@@ -1836,12 +1938,12 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
                     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"new_video_general_title_{channel['id']}")
+                            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
                         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"new_video_general_thumbnail_{channel['id']}")
+                            selected_variant_label = st.selectbox("Thumbnail escolhida", labels, key=f"{prefix}_general_thumbnail_{channel['id']}")
                             variant_index = labels.index(selected_variant_label)
                             variant = variants[variant_index]
                             payload["thumbnail_variant"] = variant
@@ -1849,13 +1951,13 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
                             payload["thumbnail_text"] = variant.get("overlay_text", "")
                             st.caption(f"{variant.get('composition', '')} · {variant.get('color_palette', '')}")
                             thumbnail_path = str(variant.get("image_path") or payload.get("thumbnail_path") or "").strip()
-                            if st.button("Gerar imagem com Nano Banana", key=f"new_video_general_generate_thumbnail_{channel['id']}", use_container_width=True):
+                            if st.button("Gerar imagem com Nano Banana", key=f"{prefix}_general_generate_thumbnail_{channel['id']}", 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))
                                     variant["image_path"] = thumbnail_path
                                     payload["thumbnail_path"] = thumbnail_path
                                     payload["thumbnail_status"] = "generated"
-                                    st.session_state["new_video_general_payloads"] = payloads
+                                    st.session_state[f"{prefix}_general_payloads"] = payloads
                                     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": channel.get("name") or "", "image_path": Path(thumbnail_path).name}, dedupe_key=f"thumbnail:{thumbnail_path}")
                                     st.success("Thumbnail gerada com Nano Banana.")
                                     st.rerun()
@@ -1870,7 +1972,7 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
                         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="new_video_generate_creative", use_container_width=True):
+                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:
@@ -1878,33 +1980,33 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
                             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["new_video_topic"] = topic_for_creative
-                                st.session_state["new_video_topic_meta"] = topic_result
+                                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),
+                                topic_source=_video_topic_source(topic_for_creative, prefix),
                             )
 
-                            st.session_state["new_video_creative_payload"] = generated
+                            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("new_video_creative_payload")
+                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="new_video_title_choice")
+                        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="new_video_thumbnail_choice")
+                        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
@@ -1913,13 +2015,13 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
                         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="new_video_generate_thumbnail_image", use_container_width=True):
+                        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))
                                 variant["image_path"] = thumbnail_path
                                 payload["thumbnail_path"] = thumbnail_path
                                 payload["thumbnail_status"] = "generated"
-                                st.session_state["new_video_creative_payload"] = payload
+                                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()
@@ -1931,9 +2033,9 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
                             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["new_video_creative_payload"] = payload
+                    st.session_state[f"{prefix}_creative_payload"] = payload
 
-            with st.form("new_video_form"):
+            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"]
@@ -1945,12 +2047,12 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
                     st.error("Escolha, carregue ou gere uma música antes de criar o vídeo Apenas Música.")
                     st.stop()
                 if mode == "general":
-                    payloads = dict(st.session_state.get("new_video_general_payloads", {}))
-                    topics = dict(st.session_state.get("new_video_general_topics", {}))
+                    payloads = dict(st.session_state.get(f"{prefix}_general_payloads", {}))
+                    topics = dict(st.session_state.get(f"{prefix}_general_topics", {}))
                     channels_by_id = {str(channel["id"]): channel for channel in all_channels}
                     payloads_need_refresh = len(payloads) != len(selected) or any(
-                        str(st.session_state.get(f"new_video_general_topic_{channel_id}", "") or "").strip()
-                        and str(st.session_state.get(f"new_video_general_topic_{channel_id}", "") or "").strip() != str((payloads.get(channel_id) or {}).get("topic") or "").strip()
+                        str(st.session_state.get(f"{prefix}_general_topic_{channel_id}", "") or "").strip()
+                        and str(st.session_state.get(f"{prefix}_general_topic_{channel_id}", "") or "").strip() != str((payloads.get(channel_id) or {}).get("topic") or "").strip()
                         for channel_id in selected
                     )
                     if payloads_need_refresh:
@@ -1960,7 +2062,7 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
                         with st.spinner("A gerar automaticamente um pacote criativo independente para cada canal…"):
                             for channel_id in selected:
                                 channel = channels_by_id[channel_id]
-                                edited_topic = str(st.session_state.get(f"new_video_general_topic_{channel_id}", "") or "").strip()
+                                edited_topic = str(st.session_state.get(f"{prefix}_general_topic_{channel_id}", "") or "").strip()
                                 topic_result = topics.get(channel_id) or {}
                                 try:
                                     if not edited_topic:
@@ -1979,8 +2081,8 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
                             st.error("O Lote geral não foi criado porque faltou gerar o conteúdo específico de pelo menos um canal.")
                         else:
                             payloads = generated_payloads
-                            st.session_state["new_video_general_payloads"] = payloads
-                            st.session_state["new_video_general_topics"] = {cid: {"topic": payload["topic"], "topic_source": payload.get("topic_source", "llm")} for cid, payload in payloads.items()}
+                            st.session_state[f"{prefix}_general_payloads"] = payloads
+                            st.session_state[f"{prefix}_general_topics"] = {cid: {"topic": payload["topic"], "topic_source": payload.get("topic_source", "llm")} for cid, payload in payloads.items()}
                     if len(payloads) == len(selected):
                         batch_topic = "Lote geral — um vídeo independente por canal"
                         channel_payloads = {cid: {**payload, "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} for cid, payload in payloads.items()}
@@ -1996,14 +2098,14 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
                             st.error("Preencha o campo Video Subject ou use o botão de geração automática abaixo das keywords.")
                             st.stop()
                         quantity_value = int(quantity if mode == "same_channel" else 1)
-                        payload = dict(st.session_state.get("new_video_creative_payload") or {})
+                        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(
                                     read_json("settings.json", {}),
                                     selected_one or {},
                                     topic_value,
-                                    topic_source=_video_topic_source(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.")
@@ -2016,7 +2118,7 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
 
 def render_music_creation():
     """Expose the complete video-creation UI under the music-oriented navigation entry without changing the original page."""
-    render_new_video(page_title="Criação de Músicas")
+    render_new_video(page_title="Criação de Músicas", prefix="new_music")
 
 
 def render_scripts():
@@ -2064,27 +2166,38 @@ def render_scripts():
             st.warning("Sem Blueprint seleccionado: o documento pode ser criado, mas não terá contexto editorial de Blueprint.")
 
         document_type = st.radio("Tipo de documento", ["Roteiro de vídeo", "Letra de música"], horizontal=True, key="script_document_type")
-        title = st.text_input("Título", key="script_title", placeholder="Ex.: A verdade esquecida sobre…")
-        brief = st.text_area(
-            "Tema ou briefing",
-            key="script_brief",
-            height=120,
-            placeholder="Descreva o tema, a mensagem, o conflito ou a ideia musical que o Blueprint deve orientar.",
-        )
-        legacy_script_language = str(st.session_state.get("script_language") or "")
         script_settings = render_video_generation_settings(
             "pipeline_scripts",
-            current_language=legacy_script_language or str(read_json("settings.json", {}).get("video_language") or "pt"),
+            current_language=str(st.session_state.get("script_language") or read_json("settings.json", {}).get("video_language") or "pt"),
+            channel=selected_channel,
+            generate_content_callback=lambda: _generate_video_content_callback(
+                "pipeline_scripts",
+                selected_channel or {},
+                str(st.session_state.get("pipeline_scripts_script_language") or language_code(legacy_script_language or "pt")),
+                selected_blueprint,
+            ),
+            save_draft_callback=lambda: _save_pipeline_draft_callback(
+                "pipeline_scripts",
+                "script",
+                "Roteiros",
+                channel=selected_channel,
+                blueprint=selected_blueprint,
+                document_type="video_script" if document_type == "Roteiro de vídeo" else "music_lyrics",
+                title=title,
+                brief=brief,
+            ),
         )
         language = script_settings["script_language"]
         structure_notes = script_settings["script_structure_notes"]
+        title = str(script_settings.get("video_subject") or "").strip()
+        brief = str(script_settings.get("video_script") or "").strip() or title
         generate_col, clear_col = st.columns([1.4, 1])
         with generate_col:
             generate_clicked = st.button("Gerar com IA a partir do Blueprint", type="primary", use_container_width=True, key="generate_script_document")
         with clear_col:
             clear_clicked = st.button("Limpar rascunho", use_container_width=True, key="clear_script_document")
         if clear_clicked:
-            for key in ("script_draft", "script_draft_title", "script_draft_content", "script_draft_summary"):
+            for key in ("script_draft", "script_draft_title", "script_draft_content", "script_draft_summary", "script_draft_keywords"):
                 st.session_state.pop(key, None)
             st.rerun()
         if generate_clicked:
@@ -2129,8 +2242,11 @@ def render_scripts():
                 st.session_state["script_draft_summary"] = str(draft.get("summary") or "")
             if "script_draft_content" not in st.session_state:
                 st.session_state["script_draft_content"] = str(draft.get("content") or "")
+            if "script_draft_keywords" not in st.session_state:
+                st.session_state["script_draft_keywords"] = str(draft.get("keywords") or "")
             draft_title = st.text_input("Título do rascunho", key="script_draft_title")
             draft_summary = st.text_input("Resumo", key="script_draft_summary")
+            draft_keywords = st.text_area("Palavras-chave", height=90, key="script_draft_keywords")
             draft_content = st.text_area("Conteúdo guardado", height=460, key="script_draft_content")
             if st.button("Guardar documento no storage", type="primary", use_container_width=True, key="save_script_document"):
                 try:
@@ -2139,6 +2255,7 @@ def render_scripts():
                             **draft,
                             "title": draft_title,
                             "summary": draft_summary,
+                            "keywords": draft_keywords,
                             "content": draft_content,
                             "document_type": "video_script" if document_type == "Roteiro de vídeo" else "music_lyrics",
                             "language": language,
@@ -2153,7 +2270,7 @@ def render_scripts():
                 except (OSError, ValueError) as exc:
                     st.error(f"Não foi possível guardar o documento: {exc}")
         else:
-            st.caption("Gere um rascunho com IA para o editar aqui, ou seleccione um Blueprint e preencha o briefing para começar.")
+            st.caption("Gere um rascunho com IA para o editar aqui, ou seleccione um Blueprint e preencha as configurações do tema para começar.")
 
     with history_tab:
         st.caption(f"Histórico persistente: `{script_dir}` · índice em `{STORAGE / 'state' / 'scripts.json'}`")
@@ -2900,6 +3017,58 @@ def render_videos():
                         st.rerun()
 
 
+def render_thumbnails():
+    st.title("Thumbnails")
+    st.caption("Biblioteca de thumbnails associadas às tarefas da pipeline. A refacção actualiza apenas a imagem da tarefa e preserva o histórico local.")
+    records = list_thumbnail_tasks()
+    if not records:
+        st.info("Ainda não existem tarefas com thumbnail gerada ou prompt de imagem disponível.")
+        return
+
+    settings = read_json("settings.json", {})
+    for record in records:
+        with st.container(border=True):
+            image_col, details_col, action_col = st.columns([1.35, 2.65, 1.25])
+            with image_col:
+                image_path = record.get("image_path")
+                if image_path and image_path.is_file():
+                    st.image(str(image_path), use_container_width=True)
+                else:
+                    st.markdown("### Sem imagem")
+                    st.caption("Imagem ainda não gerada")
+            with details_col:
+                st.write(f"**{record['title']}**")
+                st.caption(f"Canal: {record['channel_name']} · Tarefa: {record['task_id']}")
+                st.caption(f"Estado: {record['status']} · Variante: {record['variant_index'] + 1}")
+                if record["prompt"]:
+                    with st.expander("Ver prompt da thumbnail", expanded=False):
+                        st.code(record["prompt"], language="text")
+                else:
+                    st.warning("Esta tarefa não tem prompt de imagem. Não é possível refazer a thumbnail.")
+            with action_col:
+                if st.button(
+                    "Refazer thumbnail",
+                    key=f"regenerate_thumbnail_{record['task_id']}",
+                    icon=":material/refresh:",
+                    use_container_width=True,
+                    disabled=not bool(record["prompt"]),
+                ):
+                    try:
+                        with st.spinner("A refazer a thumbnail…"):
+                            _task, image_path = regenerate_thumbnail(record["task_id"], settings)
+                        record_notification(
+                            "thumbnail_generation_completed",
+                            f"Thumbnail refeita: {record['title']}",
+                            "A thumbnail da tarefa foi regenerada com sucesso.",
+                            metadata={"task_id": record["task_id"], "channel_name": record["channel_name"], "image_path": str(image_path)},
+                            dedupe_key=f"thumbnail:regenerated:{record['task_id']}:{image_path}",
+                        )
+                        st.success("Thumbnail refeita com sucesso.")
+                        st.rerun()
+                    except ThumbnailGenerationError as exc:
+                        st.error(str(exc))
+
+
 def render_automation():
     st.title("Automação Youtube")
     st.caption("Agendamento diário da geração por canal. O worker verifica o relógio local do computador e coloca os lotes agendados na fila.")
@@ -4548,6 +4717,7 @@ def main():
         ("Criação de Vídeos", ":material/add_circle:", "Criação de Vídeos"),
         ("Backlog Vídeos", ":material/video_library:", "Backlog Vídeos"),
         ("Roteiros", ":material/article:", "Roteiros"),
+        ("Thumbnails", ":material/image:", "Thumbnails"),
         ("Upload", ":material/cloud_upload:", "Upload"),
     ]
     base_files_items = [
@@ -4682,6 +4852,7 @@ def main():
         "Criação de Músicas": render_music_creation,
         "Upload Música": lambda: render_edit_placeholder("Upload Música", ""),
         "Roteiros": render_scripts,
+        "Thumbnails": render_thumbnails,
         "Upload": render_upload,
         "Blueprints Youtube": render_blueprints,
         "Prompt Masters": render_tiktok_prompt_masters,

package/hermes_ui/drafts.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import uuid
+from typing import Any
+
+from .storage import now, read_json, write_json
+
+DRAFTS_FILE = "drafts.json"
+MAX_DRAFTS = 200
+
+
+def list_drafts() -> list[dict[str, Any]]:
+    """Return locally persisted drafts, newest first."""
+    records = read_json(DRAFTS_FILE, [])
+    return [record for record in records if isinstance(record, dict)] if isinstance(records, list) else []
+
+
+def save_draft(draft: dict[str, Any]) -> dict[str, Any]:
+    """Persist one editable pipeline draft without advancing any pipeline task."""
+    record = {
+        **draft,
+        "id": str(draft.get("id") or f"draft_{uuid.uuid4().hex[:12]}"),
+        "created_at": str(draft.get("created_at") or now()),
+        "updated_at": now(),
+    }
+    drafts = list_drafts()
+    drafts.insert(0, record)
+    write_json(DRAFTS_FILE, drafts[:MAX_DRAFTS])
+    return record
+
+
+__all__ = ["DRAFTS_FILE", "list_drafts", "save_draft"]
+

package/hermes_ui/languages.py

@@ -229,34 +229,34 @@ for _language_code, _api_key_values in _API_KEY_EXPANDER_TRANSLATIONS.items():
 # translation path as the legacy pages.
 UI_NAV_TRANSLATIONS: dict[str, dict[str, str]] = {
     "pt": {
-        "Arquivos Base": "Arquivos Base", "Pipeline Vídeos": "Pipeline Vídeos", "Canais e Perfis de Vídeos": "Canais e Perfis de Vídeos", "Canais YouTube": "Canais YouTube", "Facebook Pages": "Facebook Pages", "Prompt Masters": "Prompt Masters", "Backlog Vídeos": "Backlog Vídeos", "Música": "Música", "Upload Música": "Upload Música", "Geração de Conteúdo IA": "Geração de Conteúdo IA", "Motion Control": "Motion Control", "UGC Products": "UGC Products", "Growth": "Growth", "Analista Growth Youtube": "Analista Growth Youtube", "Analista Growth Tiktok": "Analista Growth Tiktok", "Analista Growth Instagram": "Analista Growth Instagram", "Documentação": "Documentação", "Tutorial Kaggle": "Tutorial Kaggle", "Tutorial Apify": "Tutorial Apify", "Pipeline Música": "Pipeline Música", "módulos disponíveis": "módulos disponíveis",
+        "Arquivos Base": "Arquivos Base", "Pipeline Vídeos": "Pipeline Vídeos", "Canais e Perfis de Vídeos": "Canais e Perfis de Vídeos", "Canais YouTube": "Canais YouTube", "Facebook Pages": "Facebook Pages", "Prompt Masters": "Prompt Masters", "Backlog Vídeos": "Backlog Vídeos", "Thumbnails": "Thumbnails", "Música": "Música", "Upload Música": "Upload Música", "Geração de Conteúdo IA": "Geração de Conteúdo IA", "Motion Control": "Motion Control", "UGC Products": "UGC Products", "Growth": "Growth", "Analista Growth Youtube": "Analista Growth Youtube", "Analista Growth Tiktok": "Analista Growth Tiktok", "Analista Growth Instagram": "Analista Growth Instagram", "Documentação": "Documentação", "Tutorial Kaggle": "Tutorial Kaggle", "Tutorial Apify": "Tutorial Apify", "Pipeline Música": "Pipeline Música", "módulos disponíveis": "módulos disponíveis",
     },
     "en": {
-        "Arquivos Base": "Base Files", "Pipeline Vídeos": "Video Pipeline", "Canais e Perfis de Vídeos": "Video Channels & Profiles", "Canais YouTube": "YouTube Channels", "Facebook Pages": "Facebook Pages", "Prompt Masters": "Prompt Masters", "Backlog Vídeos": "Video Backlog", "Música": "Music", "Upload Música": "Music Upload", "Geração de Conteúdo IA": "AI Content Generation", "Motion Control": "Motion Control", "UGC Products": "UGC Products", "Growth": "Growth", "Analista Growth Youtube": "YouTube Growth Analyst", "Analista Growth Tiktok": "TikTok Growth Analyst", "Analista Growth Instagram": "Instagram Growth Analyst", "Documentação": "Documentation", "Tutorial Kaggle": "Kaggle Tutorial", "Tutorial Apify": "Apify Tutorial", "Pipeline Música": "Music Pipeline", "módulos disponíveis": "available modules",
+        "Arquivos Base": "Base Files", "Pipeline Vídeos": "Video Pipeline", "Canais e Perfis de Vídeos": "Video Channels & Profiles", "Canais YouTube": "YouTube Channels", "Facebook Pages": "Facebook Pages", "Prompt Masters": "Prompt Masters", "Backlog Vídeos": "Video Backlog", "Thumbnails": "Thumbnails", "Música": "Music", "Upload Música": "Music Upload", "Geração de Conteúdo IA": "AI Content Generation", "Motion Control": "Motion Control", "UGC Products": "UGC Products", "Growth": "Growth", "Analista Growth Youtube": "YouTube Growth Analyst", "Analista Growth Tiktok": "TikTok Growth Analyst", "Analista Growth Instagram": "Instagram Growth Analyst", "Documentação": "Documentation", "Tutorial Kaggle": "Kaggle Tutorial", "Tutorial Apify": "Apify Tutorial", "Pipeline Música": "Music Pipeline", "módulos disponíveis": "available modules",
     },
     "zh": {
-        "Arquivos Base": "基础文件", "Pipeline Vídeos": "视频流程", "Canais e Perfis de Vídeos": "视频频道与资料", "Canais YouTube": "YouTube 频道", "Facebook Pages": "Facebook 页面", "Prompt Masters": "主提示词", "Backlog Vídeos": "视频待办", "Música": "音乐", "Upload Música": "音乐上传", "Geração de Conteúdo IA": "AI 内容生成", "Motion Control": "动作控制", "UGC Products": "UGC 产品", "Growth": "增长", "Analista Growth Youtube": "YouTube 增长分析师", "Analista Growth Tiktok": "TikTok 增长分析师", "Analista Growth Instagram": "Instagram 增长分析师", "Documentação": "文档", "Tutorial Kaggle": "Kaggle 教程", "Tutorial Apify": "Apify 教程", "Pipeline Música": "音乐流程", "módulos disponíveis": "可用模块",
+        "Arquivos Base": "基础文件", "Pipeline Vídeos": "视频流程", "Canais e Perfis de Vídeos": "视频频道与资料", "Canais YouTube": "YouTube 频道", "Facebook Pages": "Facebook 页面", "Prompt Masters": "主提示词", "Backlog Vídeos": "视频待办", "Thumbnails": "缩略图", "Música": "音乐", "Upload Música": "音乐上传", "Geração de Conteúdo IA": "AI 内容生成", "Motion Control": "动作控制", "UGC Products": "UGC 产品", "Growth": "增长", "Analista Growth Youtube": "YouTube 增长分析师", "Analista Growth Tiktok": "TikTok 增长分析师", "Analista Growth Instagram": "Instagram 增长分析师", "Documentação": "文档", "Tutorial Kaggle": "Kaggle 教程", "Tutorial Apify": "Apify 教程", "Pipeline Música": "音乐流程", "módulos disponíveis": "可用模块",
     },
     "de": {
-        "Arquivos Base": "Basisdateien", "Pipeline Vídeos": "Video-Pipeline", "Canais e Perfis de Vídeos": "Videokanäle und Profile", "Canais YouTube": "YouTube-Kanäle", "Facebook Pages": "Facebook-Seiten", "Prompt Masters": "Prompt Masters", "Backlog Vídeos": "Video-Backlog", "Música": "Musik", "Upload Música": "Musik-Upload", "Geração de Conteúdo IA": "KI-Inhaltserstellung", "Motion Control": "Motion Control", "UGC Products": "UGC-Produkte", "Growth": "Wachstum", "Analista Growth Youtube": "YouTube-Wachstumsanalyst", "Analista Growth Tiktok": "TikTok-Wachstumsanalyst", "Analista Growth Instagram": "Instagram-Wachstumsanalyst", "Documentação": "Dokumentation", "Tutorial Kaggle": "Kaggle-Tutorial", "Tutorial Apify": "Apify-Tutorial", "Pipeline Música": "Musik-Pipeline", "módulos disponíveis": "verfügbare Module",
+        "Arquivos Base": "Basisdateien", "Pipeline Vídeos": "Video-Pipeline", "Canais e Perfis de Vídeos": "Videokanäle und Profile", "Canais YouTube": "YouTube-Kanäle", "Facebook Pages": "Facebook-Seiten", "Prompt Masters": "Prompt Masters", "Backlog Vídeos": "Video-Backlog", "Thumbnails": "Thumbnails", "Música": "Musik", "Upload Música": "Musik-Upload", "Geração de Conteúdo IA": "KI-Inhaltserstellung", "Motion Control": "Motion Control", "UGC Products": "UGC-Produkte", "Growth": "Wachstum", "Analista Growth Youtube": "YouTube-Wachstumsanalyst", "Analista Growth Tiktok": "TikTok-Wachstumsanalyst", "Analista Growth Instagram": "Instagram-Wachstumsanalyst", "Documentação": "Dokumentation", "Tutorial Kaggle": "Kaggle-Tutorial", "Tutorial Apify": "Apify-Tutorial", "Pipeline Música": "Musik-Pipeline", "módulos disponíveis": "verfügbare Module",
     },
     "vi": {
-        "Arquivos Base": "Tệp cơ sở", "Pipeline Vídeos": "Quy trình video", "Canais e Perfis de Vídeos": "Kênh và hồ sơ video", "Canais YouTube": "Kênh YouTube", "Facebook Pages": "Trang Facebook", "Prompt Masters": "Prompt Master", "Backlog Vídeos": "Danh sách video", "Música": "Âm nhạc", "Upload Música": "Tải nhạc lên", "Geração de Conteúdo IA": "Tạo nội dung AI", "Motion Control": "Điều khiển chuyển động", "UGC Products": "Sản phẩm UGC", "Growth": "Tăng trưởng", "Analista Growth Youtube": "Chuyên viên phân tích tăng trưởng YouTube", "Analista Growth Tiktok": "Chuyên viên phân tích tăng trưởng TikTok", "Analista Growth Instagram": "Chuyên viên phân tích tăng trưởng Instagram", "Documentação": "Tài liệu", "Tutorial Kaggle": "Hướng dẫn Kaggle", "Tutorial Apify": "Hướng dẫn Apify", "Pipeline Música": "Quy trình âm nhạc", "módulos disponíveis": "mô-đun khả dụng",
+        "Arquivos Base": "Tệp cơ sở", "Pipeline Vídeos": "Quy trình video", "Canais e Perfis de Vídeos": "Kênh và hồ sơ video", "Canais YouTube": "Kênh YouTube", "Facebook Pages": "Trang Facebook", "Prompt Masters": "Prompt Master", "Backlog Vídeos": "Danh sách video", "Thumbnails": "Ảnh thu nhỏ", "Música": "Âm nhạc", "Upload Música": "Tải nhạc lên", "Geração de Conteúdo IA": "Tạo nội dung AI", "Motion Control": "Điều khiển chuyển động", "UGC Products": "Sản phẩm UGC", "Growth": "Tăng trưởng", "Analista Growth Youtube": "Chuyên viên phân tích tăng trưởng YouTube", "Analista Growth Tiktok": "Chuyên viên phân tích tăng trưởng TikTok", "Analista Growth Instagram": "Chuyên viên phân tích tăng trưởng Instagram", "Documentação": "Tài liệu", "Tutorial Kaggle": "Hướng dẫn Kaggle", "Tutorial Apify": "Hướng dẫn Apify", "Pipeline Música": "Quy trình âm nhạc", "módulos disponíveis": "mô-đun khả dụng",
     },
     "tr": {
-        "Arquivos Base": "Temel Dosyalar", "Pipeline Vídeos": "Video Akışı", "Canais e Perfis de Vídeos": "Video Kanalları ve Profilleri", "Canais YouTube": "YouTube Kanalları", "Facebook Pages": "Facebook Sayfaları", "Prompt Masters": "Prompt Master'lar", "Backlog Vídeos": "Video Bekleme Listesi", "Música": "Müzik", "Upload Música": "Müzik Yükleme", "Geração de Conteúdo IA": "Yapay Zekâ İçeriği Oluşturma", "Motion Control": "Hareket Kontrolü", "UGC Products": "UGC Ürünleri", "Growth": "Büyüme", "Analista Growth Youtube": "YouTube Büyüme Analisti", "Analista Growth Tiktok": "TikTok Büyüme Analisti", "Analista Growth Instagram": "Instagram Büyüme Analisti", "Documentação": "Dokümantasyon", "Tutorial Kaggle": "Kaggle Eğitimi", "Tutorial Apify": "Apify Eğitimi", "Pipeline Música": "Müzik Akışı", "módulos disponíveis": "kullanılabilir modüller",
+        "Arquivos Base": "Temel Dosyalar", "Pipeline Vídeos": "Video Akışı", "Canais e Perfis de Vídeos": "Video Kanalları ve Profilleri", "Canais YouTube": "YouTube Kanalları", "Facebook Pages": "Facebook Sayfaları", "Prompt Masters": "Prompt Master'lar", "Backlog Vídeos": "Video Bekleme Listesi", "Thumbnails": "Küçük resimler", "Música": "Müzik", "Upload Música": "Müzik Yükleme", "Geração de Conteúdo IA": "Yapay Zekâ İçeriği Oluşturma", "Motion Control": "Hareket Kontrolü", "UGC Products": "UGC Ürünleri", "Growth": "Büyüme", "Analista Growth Youtube": "YouTube Büyüme Analisti", "Analista Growth Tiktok": "TikTok Büyüme Analisti", "Analista Growth Instagram": "Instagram Büyüme Analisti", "Documentação": "Dokümantasyon", "Tutorial Kaggle": "Kaggle Eğitimi", "Tutorial Apify": "Apify Eğitimi", "Pipeline Música": "Müzik Akışı", "módulos disponíveis": "kullanılabilir modüller",
     },
     "ru": {
-        "Arquivos Base": "Базовые файлы", "Pipeline Vídeos": "Конвейер видео", "Canais e Perfis de Vídeos": "Каналы и профили видео", "Canais YouTube": "Каналы YouTube", "Facebook Pages": "Страницы Facebook", "Prompt Masters": "Мастер-промпты", "Backlog Vídeos": "Очередь видео", "Música": "Музыка", "Upload Música": "Загрузка музыки", "Geração de Conteúdo IA": "Генерация контента ИИ", "Motion Control": "Управление движением", "UGC Products": "UGC-продукты", "Growth": "Рост", "Analista Growth Youtube": "Аналитик роста YouTube", "Analista Growth Tiktok": "Аналитик роста TikTok", "Analista Growth Instagram": "Аналитик роста Instagram", "Documentação": "Документация", "Tutorial Kaggle": "Руководство Kaggle", "Tutorial Apify": "Руководство Apify", "Pipeline Música": "Конвейер музыки", "módulos disponíveis": "доступные модули",
+        "Arquivos Base": "Базовые файлы", "Pipeline Vídeos": "Конвейер видео", "Canais e Perfis de Vídeos": "Каналы и профили видео", "Canais YouTube": "Каналы YouTube", "Facebook Pages": "Страницы Facebook", "Prompt Masters": "Мастер-промпты", "Backlog Vídeos": "Очередь видео", "Thumbnails": "Миниатюры", "Música": "Музыка", "Upload Música": "Загрузка музыки", "Geração de Conteúdo IA": "Генерация контента ИИ", "Motion Control": "Управление движением", "UGC Products": "UGC-продукты", "Growth": "Рост", "Analista Growth Youtube": "Аналитик роста YouTube", "Analista Growth Tiktok": "Аналитик роста TikTok", "Analista Growth Instagram": "Аналитик роста Instagram", "Documentação": "Документация", "Tutorial Kaggle": "Руководство Kaggle", "Tutorial Apify": "Руководство Apify", "Pipeline Música": "Конвейер музыки", "módulos disponíveis": "доступные модули",
     },
     "es": {
-        "Arquivos Base": "Archivos base", "Pipeline Vídeos": "Flujo de vídeos", "Canais e Perfis de Vídeos": "Canales y perfiles de vídeo", "Canais YouTube": "Canales de YouTube", "Facebook Pages": "Páginas de Facebook", "Prompt Masters": "Prompts maestros", "Backlog Vídeos": "Cola de vídeos", "Música": "Música", "Upload Música": "Subir música", "Geração de Conteúdo IA": "Generación de contenido con IA", "Motion Control": "Control de movimiento", "UGC Products": "Productos UGC", "Growth": "Crecimiento", "Analista Growth Youtube": "Analista de crecimiento de YouTube", "Analista Growth Tiktok": "Analista de crecimiento de TikTok", "Analista Growth Instagram": "Analista de crecimiento de Instagram", "Documentação": "Documentación", "Tutorial Kaggle": "Tutorial de Kaggle", "Tutorial Apify": "Tutorial de Apify", "Pipeline Música": "Flujo de música", "módulos disponíveis": "módulos disponibles",
+        "Arquivos Base": "Archivos base", "Pipeline Vídeos": "Flujo de vídeos", "Canais e Perfis de Vídeos": "Canales y perfiles de vídeo", "Canais YouTube": "Canales de YouTube", "Facebook Pages": "Páginas de Facebook", "Prompt Masters": "Prompts maestros", "Backlog Vídeos": "Cola de vídeos", "Thumbnails": "Miniaturas", "Música": "Música", "Upload Música": "Subir música", "Geração de Conteúdo IA": "Generación de contenido con IA", "Motion Control": "Control de movimiento", "UGC Products": "Productos UGC", "Growth": "Crecimiento", "Analista Growth Youtube": "Analista de crecimiento de YouTube", "Analista Growth Tiktok": "Analista de crecimiento de TikTok", "Analista Growth Instagram": "Analista de crecimiento de Instagram", "Documentação": "Documentación", "Tutorial Kaggle": "Tutorial de Kaggle", "Tutorial Apify": "Tutorial de Apify", "Pipeline Música": "Flujo de música", "módulos disponíveis": "módulos disponibles",
     },
     "id": {
-        "Arquivos Base": "File Dasar", "Pipeline Vídeos": "Alur Video", "Canais e Perfis de Vídeos": "Kanal dan Profil Video", "Canais YouTube": "Kanal YouTube", "Facebook Pages": "Halaman Facebook", "Prompt Masters": "Prompt Master", "Backlog Vídeos": "Antrean Video", "Música": "Musik", "Upload Música": "Unggah Musik", "Geração de Conteúdo IA": "Pembuatan Konten AI", "Motion Control": "Kontrol Gerakan", "UGC Products": "Produk UGC", "Growth": "Pertumbuhan", "Analista Growth Youtube": "Analis Pertumbuhan YouTube", "Analista Growth Tiktok": "Analis Pertumbuhan TikTok", "Analista Growth Instagram": "Analis Pertumbuhan Instagram", "Documentação": "Dokumentasi", "Tutorial Kaggle": "Tutorial Kaggle", "Tutorial Apify": "Tutorial Apify", "Pipeline Música": "Alur Musik", "módulos disponíveis": "modul tersedia",
+        "Arquivos Base": "File Dasar", "Pipeline Vídeos": "Alur Video", "Canais e Perfis de Vídeos": "Kanal dan Profil Video", "Canais YouTube": "Kanal YouTube", "Facebook Pages": "Halaman Facebook", "Prompt Masters": "Prompt Master", "Backlog Vídeos": "Antrean Video", "Thumbnails": "Thumbnail", "Música": "Musik", "Upload Música": "Unggah Musik", "Geração de Conteúdo IA": "Pembuatan Konten AI", "Motion Control": "Kontrol Gerakan", "UGC Products": "Produk UGC", "Growth": "Pertumbuhan", "Analista Growth Youtube": "Analis Pertumbuhan YouTube", "Analista Growth Tiktok": "Analis Pertumbuhan TikTok", "Analista Growth Instagram": "Analis Pertumbuhan Instagram", "Documentação": "Dokumentasi", "Tutorial Kaggle": "Tutorial Kaggle", "Tutorial Apify": "Tutorial Apify", "Pipeline Música": "Alur Musik", "módulos disponíveis": "modul tersedia",
     },
     "it": {
-        "Arquivos Base": "File di base", "Pipeline Vídeos": "Pipeline video", "Canais e Perfis de Vídeos": "Canali e profili video", "Canais YouTube": "Canali YouTube", "Facebook Pages": "Pagine Facebook", "Prompt Masters": "Prompt Master", "Backlog Vídeos": "Coda video", "Música": "Musica", "Upload Música": "Caricamento musica", "Geração de Conteúdo IA": "Generazione di contenuti IA", "Motion Control": "Controllo del movimento", "UGC Products": "Prodotti UGC", "Growth": "Crescita", "Analista Growth Youtube": "Analista della crescita YouTube", "Analista Growth Tiktok": "Analista della crescita TikTok", "Analista Growth Instagram": "Analista della crescita Instagram", "Documentação": "Documentazione", "Tutorial Kaggle": "Tutorial Kaggle", "Tutorial Apify": "Tutorial Apify", "Pipeline Música": "Pipeline musicale", "módulos disponíveis": "moduli disponibili",
+        "Arquivos Base": "File di base", "Pipeline Vídeos": "Pipeline video", "Canais e Perfis de Vídeos": "Canali e profili video", "Canais YouTube": "Canali YouTube", "Facebook Pages": "Pagine Facebook", "Prompt Masters": "Prompt Master", "Backlog Vídeos": "Coda video", "Thumbnails": "Miniature", "Música": "Musica", "Upload Música": "Caricamento musica", "Geração de Conteúdo IA": "Generazione di contenuti IA", "Motion Control": "Controllo del movimento", "UGC Products": "Prodotti UGC", "Growth": "Crescita", "Analista Growth Youtube": "Analista della crescita YouTube", "Analista Growth Tiktok": "Analista della crescita TikTok", "Analista Growth Instagram": "Analista della crescita Instagram", "Documentação": "Documentazione", "Tutorial Kaggle": "Tutorial Kaggle", "Tutorial Apify": "Tutorial Apify", "Pipeline Música": "Pipeline musicale", "módulos disponíveis": "moduli disponibili",
     },
 }
 for _language_code, _navigation_values in UI_NAV_TRANSLATIONS.items():
@@ -407,6 +407,72 @@ for _language_code, _video_generation_translation in VIDEO_GENERATION_TRANSLATIO
     UI_TRANSLATIONS[_language_code].update(_video_generation_translation)
 
 
+_PIPELINE_FEATURE_TRANSLATIONS: dict[str, dict[str, str]] = {
+    "pt": {
+        "Thumbnails": "Thumbnails", "Refazer thumbnail": "Refazer thumbnail", "Salvar rascunho": "Salvar rascunho",
+        "Rascunho guardado localmente": "Rascunho guardado localmente", "Thumbnail refeita com sucesso.": "Thumbnail refeita com sucesso.",
+        "Ver prompt da thumbnail": "Ver prompt da thumbnail", "Sem imagem": "Sem imagem", "Imagem ainda não gerada": "Imagem ainda não gerada",
+        "Palavras-chave": "Palavras-chave", "Título do rascunho": "Título do rascunho",
+    },
+    "en": {
+        "Thumbnails": "Thumbnails", "Refazer thumbnail": "Regenerate thumbnail", "Salvar rascunho": "Save draft",
+        "Rascunho guardado localmente": "Draft saved locally", "Thumbnail refeita com sucesso.": "Thumbnail regenerated successfully.",
+        "Ver prompt da thumbnail": "View thumbnail prompt", "Sem imagem": "No image", "Imagem ainda não gerada": "Image not generated yet",
+        "Palavras-chave": "Keywords", "Título do rascunho": "Draft title",
+    },
+    "zh": {
+        "Thumbnails": "缩略图", "Refazer thumbnail": "重新生成缩略图", "Salvar rascunho": "保存草稿",
+        "Rascunho guardado localmente": "草稿已保存到本地", "Thumbnail refeita com sucesso.": "缩略图已成功重新生成。",
+        "Ver prompt da thumbnail": "查看缩略图提示词", "Sem imagem": "无图像", "Imagem ainda não gerada": "尚未生成图像",
+        "Palavras-chave": "关键词", "Título do rascunho": "草稿标题",
+    },
+    "de": {
+        "Thumbnails": "Thumbnails", "Refazer thumbnail": "Thumbnail neu generieren", "Salvar rascunho": "Entwurf speichern",
+        "Rascunho guardado localmente": "Entwurf lokal gespeichert", "Thumbnail refeita com sucesso.": "Thumbnail erfolgreich neu generiert.",
+        "Ver prompt da thumbnail": "Thumbnail-Prompt anzeigen", "Sem imagem": "Kein Bild", "Imagem ainda não gerada": "Bild noch nicht generiert",
+        "Palavras-chave": "Schlüsselwörter", "Título do rascunho": "Entwurfstitel",
+    },
+    "vi": {
+        "Thumbnails": "Ảnh thu nhỏ", "Refazer thumbnail": "Tạo lại ảnh thu nhỏ", "Salvar rascunho": "Lưu bản nháp",
+        "Rascunho guardado localmente": "Đã lưu bản nháp cục bộ", "Thumbnail refeita com sucesso.": "Đã tạo lại ảnh thu nhỏ thành công.",
+        "Ver prompt da thumbnail": "Xem prompt ảnh thu nhỏ", "Sem imagem": "Không có hình ảnh", "Imagem ainda não gerada": "Chưa tạo hình ảnh",
+        "Palavras-chave": "Từ khóa", "Título do rascunho": "Tiêu đề bản nháp",
+    },
+    "tr": {
+        "Thumbnails": "Küçük resimler", "Refazer thumbnail": "Küçük resmi yeniden oluştur", "Salvar rascunho": "Taslağı kaydet",
+        "Rascunho guardado localmente": "Taslak yerel olarak kaydedildi", "Thumbnail refeita com sucesso.": "Küçük resim başarıyla yeniden oluşturuldu.",
+        "Ver prompt da thumbnail": "Küçük resim istemini görüntüle", "Sem imagem": "Görsel yok", "Imagem ainda não gerada": "Görsel henüz oluşturulmadı",
+        "Palavras-chave": "Anahtar kelimeler", "Título do rascunho": "Taslak başlığı",
+    },
+    "ru": {
+        "Thumbnails": "Миниатюры", "Refazer thumbnail": "Создать миниатюру заново", "Salvar rascunho": "Сохранить черновик",
+        "Rascunho guardado localmente": "Черновик сохранён локально", "Thumbnail refeita com sucesso.": "Миниатюра успешно создана заново.",
+        "Ver prompt da thumbnail": "Показать промпт миниатюры", "Sem imagem": "Нет изображения", "Imagem ainda não gerada": "Изображение ещё не создано",
+        "Palavras-chave": "Ключевые слова", "Título do rascunho": "Название черновика",
+    },
+    "es": {
+        "Thumbnails": "Miniaturas", "Refazer thumbnail": "Regenerar miniatura", "Salvar rascunho": "Guardar borrador",
+        "Rascunho guardado localmente": "Borrador guardado localmente", "Thumbnail refeita com sucesso.": "Miniatura regenerada correctamente.",
+        "Ver prompt da thumbnail": "Ver prompt de la miniatura", "Sem imagem": "Sin imagen", "Imagem ainda não gerada": "Imagen aún no generada",
+        "Palavras-chave": "Palabras clave", "Título do rascunho": "Título del borrador",
+    },
+    "id": {
+        "Thumbnails": "Thumbnail", "Refazer thumbnail": "Buat ulang thumbnail", "Salvar rascunho": "Simpan draf",
+        "Rascunho guardado localmente": "Draf disimpan secara lokal", "Thumbnail refeita com sucesso.": "Thumbnail berhasil dibuat ulang.",
+        "Ver prompt da thumbnail": "Lihat prompt thumbnail", "Sem imagem": "Tidak ada gambar", "Imagem ainda não gerada": "Gambar belum dibuat",
+        "Palavras-chave": "Kata kunci", "Título do rascunho": "Judul draf",
+    },
+    "it": {
+        "Thumbnails": "Miniature", "Refazer thumbnail": "Rigenera miniatura", "Salvar rascunho": "Salva bozza",
+        "Rascunho guardado localmente": "Bozza salvata localmente", "Thumbnail refeita com sucesso.": "Miniatura rigenerata con successo.",
+        "Ver prompt da thumbnail": "Mostra prompt della miniatura", "Sem imagem": "Nessuna immagine", "Imagem ainda não gerada": "Immagine non ancora generata",
+        "Palavras-chave": "Parole chiave", "Título do rascunho": "Titolo della bozza",
+    },
+}
+for _language_code, _pipeline_feature_translation in _PIPELINE_FEATURE_TRANSLATIONS.items():
+    UI_TRANSLATIONS[_language_code].update(_pipeline_feature_translation)
+
+
 _TAB_LABELS = (
     "Blueprints", "Brandings", "Pesquisa pública", "Cadastro manual", "Contas cadastradas", "Biblioteca",
     "Importar do YouTube", "Canais em lote gmail", "Criar vídeo", "Vídeos", "Novo roteiro/letra", "Histórico guardado",

package/hermes_ui/storage.py

@@ -34,6 +34,7 @@ DEFAULTS: dict[str, Any] = {
     "metadata_edits.json": [],
         "python_editor_edits.json": [],
         "scripts.json": [],
+        "drafts.json": [],
         "mcp_server.json": {
         "enabled": False,
         "host": "127.0.0.1",

package/hermes_ui/thumbnails.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import shutil
+import uuid
+from pathlib import Path
+from typing import Any
+
+from .storage import STORAGE, now, read_json, write_json
+from .thumbnail_generation import ThumbnailGenerationError, generate_thumbnail_image
+
+
+def _as_path(value: Any) -> Path | None:
+    raw = str(value or "").strip()
+    if not raw:
+        return None
+    candidates = [Path(raw)]
+    path = Path(raw)
+    if not path.is_absolute():
+        candidates.extend([STORAGE / path, STORAGE.parent / path])
+    for candidate in candidates:
+        if candidate.is_file():
+            return candidate
+    return Path(raw)
+
+
+def _variant_index(task: dict[str, Any], variant: dict[str, Any], variants: list[Any]) -> int:
+    for key in ("variant_index", "index"):
+        try:
+            value = int(variant.get(key))
+        except (TypeError, ValueError):
+            continue
+        if 0 <= value < len(variants):
+            return value
+    for index, candidate in enumerate(variants):
+        if isinstance(candidate, dict) and candidate is variant:
+            return index
+        if isinstance(candidate, dict) and variant and candidate.get("image_prompt") == variant.get("image_prompt"):
+            return index
+    return 0
+
+
+def normalize_thumbnail_task(task: dict[str, Any]) -> dict[str, Any]:
+    variants = task.get("thumbnail_variants") if isinstance(task.get("thumbnail_variants"), list) else []
+    variant = task.get("thumbnail_variant") if isinstance(task.get("thumbnail_variant"), dict) else {}
+    artifacts = task.get("artifacts") if isinstance(task.get("artifacts"), dict) else {}
+    image_path = variant.get("image_path") or task.get("thumbnail_path") or artifacts.get("thumbnail")
+    prompt = variant.get("image_prompt") or task.get("thumbnail_prompt") or ""
+    title = str(task.get("title") or task.get("topic") or "Vídeo sem título").strip()
+    return {
+        "task": task,
+        "task_id": str(task.get("id") or ""),
+        "title": title,
+        "topic": str(task.get("topic") or "").strip(),
+        "channel_name": str(task.get("channel_name") or "Canal sem nome").strip(),
+        "status": str(task.get("thumbnail_status") or "not_generated"),
+        "prompt": str(prompt or "").strip(),
+        "image_path": _as_path(image_path),
+        "variant": variant,
+        "variants": variants,
+        "variant_index": _variant_index(task, variant, variants),
+    }
+
+
+def list_thumbnail_tasks() -> list[dict[str, Any]]:
+    tasks = read_json("tasks.json", [])
+    if not isinstance(tasks, list):
+        return []
+    records = []
+    for task in tasks:
+        if not isinstance(task, dict):
+            continue
+        record = normalize_thumbnail_task(task)
+        has_thumbnail_signal = bool(
+            record["image_path"]
+            or record["prompt"]
+            or task.get("thumbnail_status")
+            or task.get("thumbnail_variant")
+            or task.get("thumbnail_variants")
+        )
+        if record["task_id"] and has_thumbnail_signal:
+            records.append(record)
+    return records
+
+
+def regenerate_thumbnail(task_id: str, settings: dict[str, Any]) -> tuple[dict[str, Any], Path]:
+    tasks = read_json("tasks.json", [])
+    if not isinstance(tasks, list):
+        raise ThumbnailGenerationError("O índice de tarefas não está disponível.")
+    for task in tasks:
+        if not isinstance(task, dict) or str(task.get("id") or "") != str(task_id):
+            continue
+        record = normalize_thumbnail_task(task)
+        if not record["prompt"]:
+            raise ThumbnailGenerationError("Esta tarefa não tem um prompt de imagem para refazer a thumbnail.")
+        previous_image = record.get("image_path")
+        if previous_image and previous_image.is_file():
+            history_dir = STORAGE / "thumbnails" / "history"
+            history_dir.mkdir(parents=True, exist_ok=True)
+            history_path = history_dir / f"{task_id}-{uuid.uuid4().hex[:10]}-{previous_image.name}"
+            shutil.copy2(previous_image, history_path)
+        image_path = generate_thumbnail_image(
+            settings,
+            record["prompt"],
+            topic=record["title"] or record["topic"],
+            variant_index=record["variant_index"],
+        )
+        artifacts = dict(task.get("artifacts") or {})
+        artifacts["thumbnail"] = str(image_path)
+        task["artifacts"] = artifacts
+        task["thumbnail_path"] = str(image_path)
+        task["thumbnail_status"] = "generated"
+        variant = dict(record["variant"])
+        if variant:
+            variant["image_path"] = str(image_path)
+            task["thumbnail_variant"] = variant
+        variants = task.get("thumbnail_variants")
+        if isinstance(variants, list) and 0 <= record["variant_index"] < len(variants) and isinstance(variants[record["variant_index"]], dict):
+            variants[record["variant_index"]] = {**variants[record["variant_index"]], "image_path": str(image_path)}
+            task["thumbnail_variants"] = variants
+        task["updated_at"] = now()
+        write_json("tasks.json", tasks)
+        return task, image_path
+    raise ThumbnailGenerationError(f"A tarefa {task_id} não foi encontrada.")
+
+
+__all__ = ["list_thumbnail_tasks", "normalize_thumbnail_task", "regenerate_thumbnail"]
+

package/package.json

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