@danhachuel/thunderbolt 0.2.54 → 0.2.56

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.2.54
+> **Versão deste manual:** 0.2.56
 > **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.2.54 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.56 install
 ```
 
 Linux/macOS:
 
 ```bash
-npx --yes @danhachuel/thunderbolt@0.2.54 install
+npx --yes @danhachuel/thunderbolt@0.2.56 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.
@@ -428,7 +428,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.2.54 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.2.56 install`; o instalador detecta e reutiliza o que já estiver válido.
 
 ### Niche Finder Apify
 
@@ -458,15 +458,21 @@ Depois do tópico, clique em **Gerar títulos e thumbnails com IA**. O Thunderbo
 
 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.
 
-## Pipeline: Criação de Vídeos, Criação de Músicas e Automação
+## Pipeline: Criação de Vídeos, Criação de Músicas, Roteiros e Automação
 
 O modo `Pexels/Pixabay` representa materiais de stock. Ao seleccionar `full_ia`, o selector `Estilo IA` apresenta os 12 estilos disponíveis. Ao seleccionar `Apenas Música`, a UI obriga a escolher uma música existente, carregar um ficheiro ou solicitar uma música a um endpoint Suno configurado. O vídeo recebe `background_mode=none`, sem fundo Pexels/Pixabay ou IA.
 
+A aba **Roteiros**, colocada entre **Criação de Músicas** e **Upload**, permite seleccionar um canal opcional, um Blueprint, **Roteiro de vídeo** ou **Letra de música**, idioma, tema e estrutura. O botão **Gerar com IA a partir do Blueprint** usa o provider LLM configurado e devolve um rascunho Markdown editável; o utilizador deve rever e clicar em **Guardar documento no storage**. Os ficheiros são guardados em `storage/scripts/` e o índice em `storage/state/scripts.json`; o caminho absoluto aparece no topo da página. Na subaba **Vídeos** de **Criação de Vídeos**, a aplicação mostra a frase `Os vídeos são guardados em <storage>/videos`, que identifica a pasta local dos vídeos.
+
 A aba **Automação Youtube**, dentro do menu expansível **Automação**, lista os canais e vídeos, permite escolher e guardar **Blueprint padrão** e **Voz padrão** por canal, guarda **Automação ON** e valida horários diários no formato `HH:MM`. Os valores ficam sincronizados com o editor existente no cartão da aba **Canais Youtube** e são copiados para novas tarefas. O launcher inicia o worker local, que consulta o relógio do computador, gera um briefing, título e pacote de thumbnail específicos com o provider LLM configurado, cria o lote agendado na fila e evita duplicar o mesmo canal no mesmo dia. Se a geração não puder ser executada, o erro fica registado e o placeholder antigo não é usado.
 
 A área **Teste de vozes**, dentro de **Configurações > Configurações Técnicas**, é 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.
 
-## Upload directo
+## Upload, Postiz e Upload directo
+
+A subaba **Postiz**, dentro de **Upload**, permite carregar as integrações Postiz, seleccionar o canal ligado e enviar vídeos MP4 através da Public API. Configure **Activar Postiz como fallback final**, **Postiz API key**, **Postiz Public API Base URL**, **Postiz MCP URL** e, opcionalmente, o ID da integração padrão em **Configurações Técnicas > API Keys**. A API key é enviada como valor bruto do cabeçalho `Authorization`; o upload usa `POST /upload` e a publicação usa `POST /posts`.
+
+O botão de envio YouTube segue a ordem fixa **1. API Oficial, 2. Upload directo, 3. Postiz**. A API Oficial regista no storage local até cinco envios bem-sucedidos por dia por conta Gmail. Quando a quota é atingida ou o método falha, o Thunderbolt valida o `credentials.json` e tenta o Upload directo. Postiz só é tentado como último recurso e apenas quando está activo, com API key e integração válida.
 
 Em **Configurações > Configurações Técnicas > Contas Google/YouTube — canais em lote**, cada conta aparece como um expander identificado por nome e e-mail. Dentro dele existe o uploader **Subir documento de cookies/credenciais** e o input **sessionInfo token desta conta Google**. O documento JSON único contém cookies, INNERTUBE_API_KEY, chunk_size e o mapa de IDs delegados por canal; o sessionInfo preenchido na conta é sincronizado no mesmo ficheiro, guardado em `storage/youtube_direct_accounts/<id-da-conta>/credentials.json`.
 

package/README.md

@@ -11,7 +11,7 @@ A primeira versão implementa a camada UI independente com:
 | Área | Incluído |
 |---|---|
 | Início | Resumo de canais, tarefas, backlog, execução e falhas, com as filas do Pipeline inline |
-| Pipeline | Menu expansível com Criação de Vídeos, Criação de Músicas e Upload |
+| Pipeline | Menu expansível com Criação de Vídeos, Criação de Músicas, Roteiros e Upload |
 | Blueprints Youtube | Leitura da pasta `storage/blueprints/`, upload/validação de JSON e criação a partir de link YouTube |
 | Brandings | Subaba própria dentro de Blueprints, upload/listagem de Brandings e criação conjunta com Blueprint |
 | Canais Youtube | Subabas de importação pública sem API Key, Canais em lote gmail por conta Google/YouTube via OAuth e cadastro manual independente; cartões com botão Editar, nicho/referências visível, Prompts do Canal/Blueprint, Narrador/voz e gestão dos últimos 10 vídeos |
@@ -20,9 +20,9 @@ A primeira versão implementa a camada UI independente com:
 | Models AI | Menu expansível com Personagens e Redes Sociais reservados para desenvolvimento futuro |
 | Niche Finder | Menu expansível com duas alternativas independentes: Niche Finder Kaggle e Niche Finder Apify, com parâmetros, execução e resultados separados |
 | Edição | Menu expansível abaixo de Automação com Limpador de Metadados, Clip Generator local em Cortes e Editor Python inspirado no PYEdit para vídeos e scripts locais |
-| Upload | YouTube via `youtube-automation-agent` adaptado internamente, OAuth directo de redundância, Upload directo via sessão Frontend API com cookies/sessionInfo por conta e DELEGATED_SESSION_ID por canal, TikTok, Instagram e Facebook Pages no front end |
+| Upload | YouTube via `youtube-automation-agent` adaptado internamente, fallback ordenado API Oficial → Upload directo → Postiz, upload de MP4 para Postiz via API key/MCP configurável, TikTok, Instagram e Facebook Pages no front end |
 | MCP | Catálogo local opcional de Short Video Maker, AutoVio, OpenMontage e OpenCut, com portas editáveis e activação |
-| Configurações Técnicas | Provedores LLM, OpenAI/NVIDIA NIM com API key, Base URL e selector de modelos, TTS/voz, preview de vozes, Suno, materiais, Whisper, FFmpeg, OAuth YouTube, contas Google/YouTube para canais em lote com e-mail, Client ID, Client Secret e sessionInfo por conta, cartões expansíveis por nome/e-mail, documento credentials.json criado automaticamente e eliminação individual, cookies SID/SSID/HSID/APISID/SAPISID no documento JSON, Data API Key opcional, Kaggle Username/API Key, Apify API Token/Actor ID/limites, Upload directo, TikTok Client ID/Secret e Upload-Post |
+| Configurações Técnicas | Provedores LLM, OpenAI/NVIDIA NIM com API key, Base URL e selector de modelos, TTS/voz, preview de vozes, Suno, materiais, Whisper, FFmpeg, OAuth YouTube, contas Google/YouTube para canais em lote com e-mail, Client ID, Client Secret e sessionInfo por conta, cartões expansíveis por nome/e-mail, documento credentials.json criado automaticamente e eliminação individual, cookies SID/SSID/HSID/APISID/SAPISID no documento JSON, Data API Key opcional, Kaggle Username/API Key, Apify API Token/Actor ID/limites, Upload directo, Postiz API key/Base URL/MCP URL/integração padrão, TikTok Client ID/Secret e Upload-Post |
 | Launcher | Execução via `npx`, instalação assistida, diagnóstico e preparação para distribuição |
 
 ## Upload directo — credenciais por conta e por canal
@@ -38,9 +38,9 @@ Os dados são segredos de sessão. Os valores não aparecem em tabelas ou logs,
 
 Os adaptadores do MoneyPrinterTurbo e de publicação nas plataformas são ligados pelas configurações locais e pelos pontos de integração em `integrations/`. A UI não inventa dados quando um serviço externo ou credencial não está disponível.
 
-## Navegação da UI 0.2.54
+## Navegação da UI 0.2.56
 
-A barra lateral mantém os níveis principais, nesta ordem: **Início**, **Niche Finder**, **Pipeline**, **Automação**, **Edição**, **Models AI** e **Configurações**. **Pipeline** é expansível e contém **Criação de Vídeos**, **Criação de Músicas** e **Upload**. **Automação** também é expansível e contém **Automação Youtube**. **Edição** é expansível e contém **Limpador de Metadados**, **Cortes** e **Editor Python**, nessa ordem. **Models AI** é expansível e contém **Personagens** e **Redes Sociais**, 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** e **Configurações Técnicas**. O Início reúne o dashboard e as filas do Pipeline, sem botões de acções rápidas.
+A barra lateral mantém os níveis principais, nesta ordem: **Início**, **Niche Finder**, **Pipeline**, **Automação**, **Edição**, **Models AI** e **Configurações**. **Pipeline** é expansível e contém **Criação de Vídeos**, **Criação de Músicas**, **Roteiros** e **Upload**. **Automação** também é expansível e contém **Automação Youtube**. **Edição** é expansível e contém **Limpador de Metadados**, **Cortes** e **Editor Python**, nessa ordem. **Models AI** é expansível e contém **Personagens** e **Redes Sociais**, 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** e **Configurações Técnicas**. O Início reúne o dashboard e as filas do Pipeline, sem botões de acções rápidas.
 
 Dentro de **Configurações Técnicas**, a UI está organizada em três subabas, sem numeração visível: **Contas Google/YouTube — canais em lote**, **API Keys** e **Teste de vozes**. A primeira contém cartões expansíveis de contas Google, sessionInfo e documentos de Upload directo; o formulário **Adicionar outra conta Gmail** fica fora dos cartões. **API Keys** reúne execução local, OAuth, LLM, TTS, materiais e restantes credenciais; **Teste de vozes** contém exclusivamente o preview de áudio.
 
@@ -161,9 +161,9 @@ thunderbolt
 No Windows PowerShell, se `npx` for bloqueado por `npx.ps1`, use directamente `npx.cmd`:
 
 ```powershell
-npx.cmd --yes @danhachuel/thunderbolt@0.2.54 install
-npx.cmd --yes @danhachuel/thunderbolt@0.2.54 doctor
-npx.cmd --yes @danhachuel/thunderbolt@0.2.54
+npx.cmd --yes @danhachuel/thunderbolt@0.2.56 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.56 doctor
+npx.cmd --yes @danhachuel/thunderbolt@0.2.56
 ```
 
 Como alternativa, pode permitir scripts para o seu utilizador:
@@ -187,7 +187,7 @@ O menu expansível **Niche Finder** contém duas alternativas independentes. **N
 
 A interface apresenta dentro da aba os parâmetros da busca: número de clusters entre 2 e 10, suporte mínimo entre 0,01 e 0,50, país, categoria de engagement, intervalo de datas e tags. A página permanece sem resultados até o primeiro clique em **Analisar Nichos**; depois, se os parâmetros forem alterados, mostra os resultados anteriores e pede novo clique para aplicar os filtros actuais. O núcleo aplica normalização, filtros, `log1p`, `StandardScaler`, K-Means e FP-Growth. Os resultados aparecem em DataFrames para clusters, itemsets frequentes, regras de associação e dados analisados, acompanhados por uma visualização Plotly nativa e pesquisa de palavras nos clusters.
 
-**Niche Finder Apify** é a segunda alternativa e não usa o dataset, filtros, execução ou resultados Kaggle. Define três palavras-chave, período, limite de resultados, Shorts, duração, idioma de legendas e ordenação; depois de clicar em **Pesquisar no Apify**, inicia o actor `streamers~youtube-scraper`, acompanha o run, carrega o dataset, normaliza vídeos, limpa SRT, calcula VSC Ratio e tenta resumir as transcrições com o provider LLM configurado. Os resultados ficam na sessão própria `niche_apify_results`, o histórico pequeno fica em `storage/state/niche_apify_runs.json` e existem exportações JSON/CSV. Configure o **Apify API Token** em Configurações Técnicas. As dependências adicionais são instaladas pelo fluxo normal do pacote: `requests`, `pandas` e os componentes já existentes da análise. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.2.54 install`; o instalador detecta e reutiliza componentes já válidos.
+**Niche Finder Apify** é a segunda alternativa e não usa o dataset, filtros, execução ou resultados Kaggle. Define três palavras-chave, período, limite de resultados, Shorts, duração, idioma de legendas e ordenação; depois de clicar em **Pesquisar no Apify**, inicia o actor `streamers~youtube-scraper`, acompanha o run, carrega o dataset, normaliza vídeos, limpa SRT, calcula VSC Ratio e tenta resumir as transcrições com o provider LLM configurado. Os resultados ficam na sessão própria `niche_apify_results`, o histórico pequeno fica em `storage/state/niche_apify_runs.json` e existem exportações JSON/CSV. Configure o **Apify API Token** em Configurações Técnicas. As dependências adicionais são instaladas pelo fluxo normal do pacote: `requests`, `pandas` e os componentes já existentes da análise. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.2.56 install`; o instalador detecta e reutiliza componentes já válidos.
 
 ## Editor Python baseado no PYEdit
 
@@ -254,7 +254,7 @@ A aba **Canais Youtube** está dividida em dois fluxos independentes. Em **Impor
 
 Em **Cadastro manual**, nenhum pedido ao YouTube é feito e não existe qualquer dependência de API Key. O utilizador pode preencher nome, URL, handle, descrição, métricas, thumbnail, idioma, estilo, Blueprint padrão, voz padrão, `DELEGATED_SESSION_ID` e configuração de Automação. A importação pública nunca grava automaticamente: os dados aparecem num formulário de revisão antes de guardar. A resolução pública aceita URLs `/channel/UC...`, handles e subpáginas; quando existe um ID mas o HTML não traz todos os dados, tenta o feed RSS público. Se o YouTube responder que o canal não existe ou não fornecer metadados, a UI mostra uma mensagem clara e não mantém o formulário de uma pesquisa anterior. Cada cartão de canal tem **Activo** e, logo abaixo, **Apagar canal**, com confirmação; tarefas e artefactos não são apagados.
 
-## Upload YouTube
+## Upload YouTube e fallback Postiz
 
 O Upload usa como caminho **principal** a lógica do `PublishingSchedulingAgent` do [youtube-automation-agent](https://github.com/darkzOGx/youtube-automation-agent), adaptada para Python e executada dentro do processo Streamlit do Thunderbolt. Não é necessário instalar ou iniciar um segundo servidor Node. O fluxo valida o MP4 real, constrói `snippet/status`, faz upload resumível e tenta enviar thumbnail e legendas.
 
@@ -262,12 +262,20 @@ Na aba **Upload**, configure primeiro apenas o **YouTube OAuth Client ID** e o *
 
 Use **Autorizar fallback OAuth** apenas se precisar de uma autorização separada para o caminho de redundância. Os resultados guardam no histórico local qual mecanismo foi utilizado e as tentativas realizadas, sem guardar segredos.
 
+A subaba **Postiz**, dentro de **Upload**, permite carregar as integrações ligadas através de `GET /integrations`, enviar um MP4 para `POST /upload` e criar o post YouTube em `POST /posts`. A API key é enviada como valor bruto do cabeçalho `Authorization`; a base cloud é `https://api.postiz.com/public/v1` e pode ser substituída por uma instalação self-hosted. O modo MCP guarda também a URL Streamable HTTP configurável para uso futuro/alternativo.
+
+O botão principal de YouTube usa a ordem **API Oficial → Upload directo → Postiz**. A API Oficial tem um contador local de cinco envios bem-sucedidos por dia por conta Gmail; quando a quota é atingida, ou o método falha, o Thunderbolt tenta o documento de sessão do Upload directo. Só depois de esse caminho falhar tenta o Postiz, desde que esteja activo, tenha API key e tenha um ID de integração configurado.
+
 A subaba **Upload directo** adapta o [YouTube-Video-Upload-Frontend-Api](https://github.com/Nojus10/YouTube-Video-Upload-Frontend-Api). Ela usa cookies, `sessionInfo`, `INNERTUBE_API_KEY` e `DELEGATED_SESSION_ID` fornecidos manualmente pelo utilizador, cria o vídeo através do endpoint interno e envia o ficheiro em chunks de 256 KiB. Este caminho é experimental, não extrai cookies automaticamente e fica separado do agente YouTube principal.
 
 ## Pipeline: Criação de Vídeos, Criação de Músicas e Automação Youtube
 
 Em **Criação de Vídeos**, o estilo visual `Pexels/Pixabay` é o modo de materiais, `full_ia` abre o selector **Estilo IA** com os 12 estilos solicitados e **Apenas Música** exige um áudio local, um upload musical ou um pedido ao endpoint Suno configurado. **Criação de Músicas** reutiliza o mesmo conteúdo e formulário com título próprio. Neste último modo, a task fica com `background_mode=none`: não são gerados fundos Pexels/Pixabay nem fundos IA.
 
+A subaba **Roteiros**, entre **Criação de Músicas** e **Upload**, permite escolher um canal opcional, um Blueprint, o tipo **Roteiro de vídeo** ou **Letra de música**, idioma, briefing e notas de estrutura. O botão **Gerar com IA a partir do Blueprint** usa o provider LLM configurado, devolve um rascunho Markdown editável e só guarda o documento quando o utilizador confirmar. Os ficheiros ficam em `storage/scripts/` e o índice do histórico em `storage/state/scripts.json`; a própria página mostra o caminho absoluto correspondente ao storage local.
+
+Na subaba **Vídeos** de **Criação de Vídeos**, a frase `Os vídeos são guardados em <storage>/videos` identifica a pasta real onde os artefactos de vídeo devem ser procurados.
+
 O agente musical guarda os ficheiros em `storage/music/`, aceita formatos de áudio comuns e pode descarregar uma URL de áudio devolvida por um endpoint Suno compatível. Em **Canais Youtube**, abra **Definir Blueprint e voz padrão** no cartão do canal para guardar os defaults; em **Automação Youtube**, os mesmos dois selectores aparecem no cartão e são sincronizados. Esses valores são usados automaticamente em novas tarefas criadas para o canal. A aba **Automação Youtube** também guarda `Automação ON` e um horário diário `HH:MM` por canal e lista os vídeos cadastrados; por definição, esta entrega não executa workers de fundo.
 
 ## Teste de vozes

package/app/main.py

@@ -34,9 +34,13 @@ from hermes_ui.cuts import CutsError, download_direct_video_url, generate_clips,
 from hermes_ui.mcp import detect_local_service, install_skill_locally, load_integrations, load_server_config, read_packaged_skill, save_server_config, update_integration
 from hermes_ui.mcp_server import server_status, start_server, stop_server
 from hermes_ui.music import list_music_files, materialize_suno_audio, request_suno_generation, store_music_file
+from hermes_ui.script_documents import list_script_documents, read_script_document, save_script_document, script_storage_path
+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.creative_generation import CreativeGenerationError, generate_creative_package, generate_topic_for_channel
 from integrations.platforms import IntegrationResult, TikTokAdapter, YouTubeAdapter, fetch_channel_videos_public
+from integrations.postiz import PostizAdapter
+from integrations.upload_routing import OFFICIAL_DAILY_LIMIT, official_upload_count, upload_with_default_route
 from integrations.youtube_direct_upload import YouTubeDirectUploader
 from integrations.youtube_direct_credentials import delete_credentials_document, direct_account_status, document_status, ensure_credentials_document, merge_credentials_document, parse_credentials_document, save_credentials_document, update_credentials_document_session_info
 from integrations.youtube_batch import account_key as youtube_batch_account_key, account_status as youtube_batch_account_status, authorize_account as authorize_youtube_batch_account, delete_account_token as delete_youtube_batch_token, list_my_channels as list_youtube_batch_channels, loopback_redirect_uri
@@ -1239,6 +1243,150 @@ def render_music_creation():
     render_new_video(page_title="Criação de Músicas")
 
 
+def render_scripts():
+    st.title("Roteiros")
+    st.caption("Produza e guarde roteiros de vídeos ou letras de músicas a partir dos Blueprints do Thunderbolt.")
+    script_dir = script_storage_path()
+    st.info(f"**Ficheiros guardados em:** `{script_dir}` · o conteúdo fica no storage local do Thunderbolt e não é enviado automaticamente para plataformas.")
+
+    create_tab, history_tab = st.tabs(["Novo roteiro/letra", "Histórico guardado"])
+    with create_tab:
+        all_channels = [channel for channel in read_json("channels.json", []) if isinstance(channel, dict)]
+        active_channels = [channel for channel in all_channels if channel.get("active", True)]
+        channel_options: list[dict[str, Any] | None] = [None] + active_channels
+        selected_channel = st.selectbox(
+            "Canal (opcional)",
+            channel_options,
+            format_func=lambda channel: "Documento independente" if channel is None else str(channel.get("name") or "Canal sem nome"),
+            key="script_channel",
+        )
+        blueprint_options = blueprint_catalog()
+        blueprint_ids = [identifier for identifier, _label in blueprint_options]
+        blueprint_labels = {identifier: label for identifier, label in blueprint_options}
+        selected_blueprint_id = st.selectbox(
+            "Blueprint",
+            blueprint_ids,
+            format_func=lambda identifier: blueprint_labels.get(identifier, "Sem Blueprint padrão"),
+            key="script_blueprint",
+        )
+        selected_blueprint: dict[str, Any] = {}
+        if selected_blueprint_id:
+            for path in list_blueprint_files():
+                try:
+                    blueprint = load_blueprint_file(path)
+                except (OSError, ValueError, json.JSONDecodeError):
+                    continue
+                identifiers = {str(blueprint.get("id") or ""), path.stem, str(blueprint.get("name") or "")}
+                if selected_blueprint_id in identifiers:
+                    selected_blueprint = dict(blueprint)
+                    selected_blueprint.setdefault("id", selected_blueprint_id)
+                    selected_blueprint.setdefault("name", blueprint_labels.get(selected_blueprint_id, selected_blueprint_id))
+                    break
+        if selected_blueprint:
+            st.caption(f"Blueprint aplicado ao contexto: **{selected_blueprint.get('name', selected_blueprint_id)}**")
+        else:
+            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.",
+        )
+        language_options = VIDEO_LANGUAGE_OPTIONS
+        language = st.selectbox("Idioma", language_options, key="script_language")
+        structure_notes = st.text_area(
+            "Estrutura e notas opcionais",
+            key="script_structure_notes",
+            height=90,
+            placeholder="Ex.: 6 cenas, narração documental, refrão repetível, atmosfera sombria…",
+        )
+        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"):
+                st.session_state.pop(key, None)
+            st.rerun()
+        if generate_clicked:
+            try:
+                with st.spinner("A gerar o documento com o provider LLM configurado…"):
+                    generated = generate_script_document(
+                        read_json("settings.json", {}),
+                        document_type=document_type,
+                        title=title,
+                        brief=brief,
+                        language=language,
+                        channel=selected_channel or {},
+                        blueprint=selected_blueprint,
+                        structure_notes=structure_notes,
+                    )
+                st.session_state["script_draft"] = generated
+                st.session_state["script_draft_title"] = generated["title"]
+                st.session_state["script_draft_summary"] = generated.get("summary", "")
+                st.session_state["script_draft_content"] = generated["content"]
+                st.success("Rascunho gerado. Reveja e edite o texto antes de guardar.")
+            except CreativeGenerationError as exc:
+                st.error(str(exc))
+
+        draft = st.session_state.get("script_draft")
+        if draft:
+            st.divider()
+            st.subheader("Rascunho editável")
+            if "script_draft_title" not in st.session_state:
+                st.session_state["script_draft_title"] = str(draft.get("title") or title or "Documento")
+            if "script_draft_summary" not in st.session_state:
+                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 "")
+            draft_title = st.text_input("Título do rascunho", key="script_draft_title")
+            draft_summary = st.text_input("Resumo", key="script_draft_summary")
+            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:
+                    record = save_script_document(
+                        {
+                            **draft,
+                            "title": draft_title,
+                            "summary": draft_summary,
+                            "content": draft_content,
+                            "document_type": "video_script" if document_type == "Roteiro de vídeo" else "music_lyrics",
+                            "language": language,
+                            "channel_id": str((selected_channel or {}).get("id") or ""),
+                            "channel_name": str((selected_channel or {}).get("name") or "Documento independente"),
+                            "blueprint_id": str(selected_blueprint.get("id") or selected_blueprint_id or ""),
+                            "blueprint_name": str(selected_blueprint.get("name") or blueprint_labels.get(selected_blueprint_id, "SEM BLUEPRINT CONFIGURADO")),
+                        }
+                    )
+                    st.success(f"Documento guardado em `{record['path']}`.")
+                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.")
+
+    with history_tab:
+        st.caption(f"Histórico persistente: `{script_dir}` · índice em `{STORAGE / 'state' / 'scripts.json'}`")
+        records = list_script_documents()
+        if not records:
+            st.info("Ainda não existem roteiros ou letras guardados.")
+        for record in records[:50]:
+            label = f"{record.get('title', 'Documento')} · {record.get('document_type', 'documento')}"
+            with st.expander(label, expanded=False):
+                st.caption(f"{record.get('created_at', '—')} · {record.get('channel_name', 'Documento independente')} · Blueprint: {record.get('blueprint_name', '—')}")
+                stored_path = Path(str(record.get("path") or ""))
+                content = read_script_document(record)
+                if content:
+                    st.text_area("Conteúdo", value=content, height=220, key=f"stored_script_{record.get('id')}")
+                    if stored_path.is_file():
+                        st.download_button("Descarregar Markdown", data=stored_path.read_bytes(), file_name=stored_path.name, mime="text/markdown", key=f"download_script_{record.get('id')}")
+                else:
+                    st.warning("O ficheiro deste registo já não está disponível no storage.")
+
+
 @st.cache_data(show_spinner=False)
 def _cached_niche_download():
     """Download or reuse the dataset only after the user submits the form."""
@@ -1809,6 +1957,7 @@ def render_python_editor():
 def render_videos():
     st.subheader("Vídeos e backlog")
     st.caption("Acompanhamento dos vídeos criados, estados da pipeline e controlos de execução.")
+    st.caption(f"Os vídeos são guardados em `{STORAGE / 'videos'}`.")
     tasks = read_json("tasks.json", [])
     if not tasks:
         st.info("Nenhum vídeo criado.")
@@ -1989,17 +2138,99 @@ def render_upload_direct():
 
 def render_upload():
     st.title("Upload")
-    upload_tab, direct_tab = st.tabs(["Upload convencional", "Upload directo"])
+    upload_tab, direct_tab, postiz_tab = st.tabs(["Upload convencional", "Upload directo", "Postiz"])
     with direct_tab:
         render_upload_direct()
+    with postiz_tab:
+        render_upload_postiz()
     with upload_tab:
         render_upload_conventional()
 
 
+def render_upload_postiz():
+    st.subheader("Upload para Postiz")
+    st.caption("O Thunderbolt envia primeiro o MP4 para o Postiz e cria um post na integração seleccionada. A API key e o servidor são configurados em Configurações Técnicas.")
+    settings = read_json("settings.json", {})
+    postiz = PostizAdapter(settings)
+    if not settings.get("postiz_enabled"):
+        st.warning("Postiz está desactivado. Active-o em Configurações Técnicas > API Keys e guarde a API key antes de enviar.")
+    if not postiz.api_key:
+        st.info("Nenhuma API key Postiz configurada.")
+        return
+
+    integration_catalog = st.session_state.get("postiz_integrations", [])
+    integration_ids = [str(item.get("id")) for item in integration_catalog if isinstance(item, dict) and item.get("id")]
+    integration_labels = {
+        str(item.get("id")): " — ".join(str(value) for value in [item.get("name") or item.get("provider") or item.get("type") or "Integração", item.get("username") or item.get("profile") or item.get("identifier") or ""] if value)
+        for item in integration_catalog if isinstance(item, dict) and item.get("id")
+    }
+    integration_default = str(settings.get("postiz_integration_id", "") or "")
+    if st.button("Carregar integrações Postiz", key="postiz_load_integrations"):
+        result = postiz.list_integrations()
+        if result.ok:
+            st.session_state["postiz_integrations"] = result.data.get("integrations", [])
+            st.success(result.message)
+            st.rerun()
+        st.error(result.message)
+    if integration_ids:
+        selected_integration = st.selectbox(
+            "Canal/integração Postiz",
+            integration_ids,
+            index=integration_ids.index(integration_default) if integration_default in integration_ids else 0,
+            format_func=lambda value: integration_labels.get(value, value),
+            key="postiz_upload_integration",
+        )
+        st.caption("Para alterar a integração padrão, guarde o ID seleccionado em Configurações Técnicas.")
+    else:
+        selected_integration = st.text_input("ID da integração Postiz", value=integration_default, key="postiz_upload_integration_manual", help="Carregue as integrações para seleccionar uma conta ou introduza o ID devolvido pela API do Postiz.").strip()
+        st.info("Carregue as integrações para descobrir os canais Postiz ligados à sua conta.")
+
+    tasks = [task for task in read_json("tasks.json", []) if task.get("state") == "done" or task.get("artifacts", {}).get("video")]
+    if not tasks:
+        st.info("Não há vídeos prontos para enviar para o Postiz.")
+        return
+    for task in tasks:
+        artifacts = task.get("artifacts", {}) or {}
+        video_path = artifacts.get("video", "")
+        thumbnail_path = artifacts.get("thumbnail") or artifacts.get("cover", "")
+        with st.container(border=True):
+            st.write(f"**{task.get('topic', 'Vídeo Thunderbolt')}** — {task.get('channel_name', 'Canal')}")
+            st.caption(video_path or "Sem caminho de vídeo registado")
+            title = st.text_input("Título Postiz", value=task.get("title") or task.get("topic", "Vídeo Thunderbolt"), key=f"postiz_title_{task['id']}")
+            description = st.text_area("Descrição Postiz", value=task.get("description", ""), key=f"postiz_description_{task['id']}", height=90)
+            visibility = st.selectbox("Visibilidade YouTube no Postiz", ["private", "unlisted", "public"], key=f"postiz_visibility_{task['id']}")
+            if st.button("Enviar vídeo para Postiz", type="primary", key=f"postiz_upload_{task['id']}"):
+                result = postiz.publish_video(
+                    video_path,
+                    integration_id=selected_integration,
+                    title=title,
+                    description=description,
+                    visibility=visibility,
+                    tags=task.get("tags", []) if isinstance(task.get("tags", []), list) else [tag.strip() for tag in str(task.get("tags", "")).split(",") if tag.strip()],
+                    thumbnail_path=thumbnail_path,
+                )
+                record = {
+                    "task_id": task.get("id"),
+                    "destination": "Postiz",
+                    "status": "published" if result.ok else "failed",
+                    "message": result.message,
+                    "data": result.data,
+                    "created_at": now(),
+                }
+                uploads = read_json("uploads.json", [])
+                uploads.append(record)
+                write_json("uploads.json", uploads)
+                (st.success if result.ok else st.error)(result.message)
+
+
 def render_upload_conventional():
     st.title("Upload")
     settings = read_json("settings.json", {})
     youtube = YouTubeAdapter(settings=settings)
+    channels = read_json("channels.json", [])
+    channel_map = {str(channel.get("id")): channel for channel in channels if channel.get("id")}
+    direct_accounts = {str(account.get("id")): account for account in settings.get("youtube_batch_accounts", []) if isinstance(account, dict) and account.get("id")}
+    postiz = PostizAdapter(settings)
     tasks = [t for t in read_json("tasks.json", []) if t.get("state") == "done" or t.get("artifacts", {}).get("video")]
     destination = st.multiselect("Destinos", ["YouTube", "TikTok", "Instagram", "Facebook Pages"], default=["YouTube"], key="upload_destinations", placeholder="Seleccione os destinos")
 
@@ -2009,9 +2240,14 @@ def render_upload_conventional():
         st.info("Facebook Pages está disponível no front end. A publicação real será ligada numa etapa de credenciais/API própria.")
 
     if "YouTube" in destination:
-        st.markdown("**YouTube — youtube-automation-agent (principal)**")
-        st.caption("O Thunderbolt executa internamente a lógica do PublishingSchedulingAgent: OAuth, upload resumível, metadados, thumbnail e legendas. O OAuth directo é usado apenas como redundância se o caminho principal falhar.")
+        st.markdown("**YouTube — fluxo recomendado de envio**")
+        st.caption("Ordem automática: 1. API Oficial — até 5 envios bem-sucedidos por dia e por conta Gmail; 2. Upload directo — sessão interna YouTube; 3. Postiz — fallback final configurável.")
         status = youtube.upload_status()
+        if settings.get("postiz_enabled"):
+            postiz_status = postiz.status()
+            (st.success if postiz_status.ok else st.warning)(postiz_status.message)
+        else:
+            st.caption("Postiz está desactivado; active-o em Configurações Técnicas para o usar como fallback final.")
         status_cols = st.columns(2)
         with status_cols[0]:
             (st.success if status["agent"].ok else st.warning)(f"Agente: {status['agent'].message}")
@@ -2041,6 +2277,8 @@ def render_upload_conventional():
             thumbnail_path = artifacts.get("thumbnail") or artifacts.get("cover", "")
             captions_path = artifacts.get("captions") or artifacts.get("subtitle", "")
             st.caption(video_path or "Sem caminho de vídeo registado")
+            channel = channel_map.get(str(task.get("channel_id")), {})
+            account = direct_accounts.get(str(channel.get("google_account_id", "")))
             if "YouTube" in destination:
                 title = st.text_input("Título", value=task.get("title") or task.get("topic", "Vídeo Thunderbolt"), key=f"yt_title_{task['id']}")
                 description = st.text_area("Descrição", value=task.get("description", ""), key=f"yt_description_{task['id']}", height=100)
@@ -2052,10 +2290,16 @@ def render_upload_conventional():
                     category_id = st.text_input("Category ID", value="22", key=f"yt_category_{task['id']}")
                 with yt_cols[2]:
                     language = st.text_input("Idioma", value="pt-BR", key=f"yt_language_{task['id']}")
-                if st.button("Publicar no YouTube", type="primary", key=f"upload_youtube_{task['id']}"):
+                quota_count = official_upload_count(channel, account)
+                st.caption(f"API Oficial hoje: {quota_count}/{OFFICIAL_DAILY_LIMIT} envios nesta conta Gmail.")
+                if st.button("Enviar pelo fluxo recomendado", type="primary", key=f"upload_youtube_{task['id']}"):
                     tags = [tag.strip() for tag in tags_raw.split(",") if tag.strip()]
-                    result = youtube.upload_video(
-                        video_path,
+                    result = upload_with_default_route(
+                        settings,
+                        storage_root=STORAGE,
+                        channel=channel,
+                        account=account,
+                        video_path=video_path,
                         title=title,
                         description=description,
                         tags=tags,
@@ -2432,6 +2676,20 @@ def render_settings():
                 upload_post_platforms = text_setting("Plataformas Upload-Post", "upload_post_platforms")
                 upload_post_auto_upload = st.checkbox("Publicar automaticamente após gerar", bool(settings.get("upload_post_auto_upload", False)))
 
+            with st.expander("Postiz — API key, integração e MCP", expanded=True):
+                st.caption("O Thunderbolt é o cliente. A API key é enviada exclusivamente ao servidor Postiz configurado; não é colocada em URLs, logs ou repositório.")
+                postiz_enabled = st.checkbox("Activar Postiz como fallback final", bool(settings.get("postiz_enabled", False)))
+                postiz_mode = st.selectbox("Modo de ligação", ["api", "mcp"], index=0 if settings.get("postiz_mode", "api") != "mcp" else 1, help="API é o modo determinístico de upload. MCP fica disponível para uma ligação compatível com Streamable HTTP.")
+                postiz_cols = st.columns(2)
+                with postiz_cols[0]:
+                    postiz_api_key = text_setting("Postiz API key", "postiz_api_key", secret=True, help_text="API key criada nas definições do Postiz. A API HTTP usa o valor bruto no cabeçalho Authorization.")
+                    postiz_base_url = text_setting("Postiz Public API Base URL", "postiz_base_url", help_text="Cloud: https://api.postiz.com/public/v1 · Self-hosted: https://seu-servidor/api/public/v1")
+                    postiz_integration_id = text_setting("Postiz integração padrão", "postiz_integration_id", help_text="ID do canal/integração devolvido por GET /integrations.")
+                with postiz_cols[1]:
+                    postiz_mcp_url = text_setting("Postiz MCP URL", "postiz_mcp_url", help_text="Cloud: https://api.postiz.com/mcp · o cliente acrescenta a API key conforme o modo escolhido.")
+                    postiz_auto_publish = st.checkbox("Permitir publicação imediata no Postiz", bool(settings.get("postiz_auto_publish", False)))
+                st.caption("No Upload, a aba Postiz permite carregar as integrações e enviar vídeos manualmente. No fluxo recomendado, Postiz só é tentado depois da API Oficial e do Upload directo.")
+
             if refresh_openai_models:
                 try:
                     discovered_models = fetch_openai_compatible_models(openai_api_key, openai_base_url)
@@ -2466,6 +2724,9 @@ def render_settings():
                     "upload_post_enabled": upload_post_enabled, "upload_post_api_key": upload_post_api_key,
                     "upload_post_username": upload_post_username, "upload_post_platforms": upload_post_platforms,
                     "upload_post_auto_upload": upload_post_auto_upload,
+                    "postiz_enabled": postiz_enabled, "postiz_api_key": postiz_api_key, "postiz_base_url": postiz_base_url.strip() or "https://api.postiz.com/public/v1",
+                    "postiz_mcp_url": postiz_mcp_url.strip() or "https://api.postiz.com/mcp", "postiz_mode": postiz_mode,
+                    "postiz_integration_id": postiz_integration_id.strip(), "postiz_auto_publish": bool(postiz_auto_publish),
                 })
                 write_json("settings.json", settings)
                 try:
@@ -2782,6 +3043,7 @@ def main():
     pipeline_items = [
         ("Criação de Vídeos", ":material/add_circle:", "Criação de Vídeos"),
         ("Criação de Músicas", ":material/music_note:", "Criação de Músicas"),
+        ("Roteiros", ":material/article:", "Roteiros"),
         ("Upload", ":material/cloud_upload:", "Upload"),
     ]
     edition_items = [
@@ -2874,6 +3136,7 @@ def main():
         "Início": render_dashboard,
         "Criação de Vídeos": render_new_video,
         "Criação de Músicas": render_music_creation,
+        "Roteiros": render_scripts,
         "Automação Youtube": render_automation,
         "Niche Finder Kaggle": render_niche_finder,
         "Niche Finder Apify": render_niche_finder_apify,

package/hermes_ui/script_documents.py

@@ -0,0 +1,82 @@
+"""Local Markdown storage for Thunderbolt scripts and music lyrics."""
+
+from __future__ import annotations
+
+import re
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from .storage import STORAGE, append_json, ensure_storage, read_json, write_json
+
+SCRIPT_HISTORY_FILE = "scripts.json"
+
+
+def _slug(value: str, fallback: str = "documento") -> str:
+    normalized = re.sub(r"[^a-zA-Z0-9À-ÿ]+", "-", str(value or "").strip(), flags=re.UNICODE).strip("-").lower()
+    return (normalized or fallback)[:90]
+
+
+def script_storage_path() -> Path:
+    ensure_storage()
+    path = STORAGE / "scripts"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def save_script_document(document: dict[str, Any]) -> dict[str, Any]:
+    content = str(document.get("content") or "").strip()
+    if not content:
+        raise ValueError("O documento não pode ser guardado vazio.")
+    created_at = datetime.now(timezone.utc).isoformat()
+    document_id = str(document.get("id") or uuid.uuid4().hex[:12])
+    title = str(document.get("title") or "Documento").strip()
+    document_type = str(document.get("document_type") or "video_script").strip()
+    prefix = "roteiro" if document_type == "video_script" else "letra"
+    filename = f"{prefix}-{_slug(title)}-{document_id}.md"
+    path = script_storage_path() / filename
+    front_matter = [
+        "---",
+        f"id: {document_id}",
+        f"type: {document_type}",
+        f"title: {title}",
+        f"language: {str(document.get('language') or '')}",
+        f"channel: {str(document.get('channel_name') or '')}",
+        f"blueprint: {str(document.get('blueprint_name') or '')}",
+        f"created_at: {created_at}",
+        "---",
+        "",
+    ]
+    summary = str(document.get("summary") or "").strip()
+    if summary:
+        front_matter.extend([f"> {summary}", ""])
+    path.write_text("\n".join(front_matter) + content.rstrip() + "\n", encoding="utf-8")
+    record = {
+        **document,
+        "id": document_id,
+        "title": title,
+        "document_type": document_type,
+        "path": str(path),
+        "filename": filename,
+        "created_at": created_at,
+        "content": content,
+    }
+    history = read_json(SCRIPT_HISTORY_FILE, [])
+    if not isinstance(history, list):
+        history = []
+    history.insert(0, {key: value for key, value in record.items() if key != "content"})
+    write_json(SCRIPT_HISTORY_FILE, history[:200])
+    return record
+
+
+def list_script_documents() -> list[dict[str, Any]]:
+    history = read_json(SCRIPT_HISTORY_FILE, [])
+    return [item for item in history if isinstance(item, dict)] if isinstance(history, list) else []
+
+
+def read_script_document(record: dict[str, Any]) -> str:
+    path = Path(str(record.get("path") or ""))
+    if not path.is_file():
+        return ""
+    return path.read_text(encoding="utf-8")

package/hermes_ui/script_generation.py

@@ -0,0 +1,91 @@
+"""Blueprint-aware generation of video scripts and music lyrics."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from .creative_generation import CreativeGenerationError, _chat_json, channel_context
+
+
+DOCUMENT_TYPES = {
+    "Roteiro de vídeo": "video_script",
+    "Letra de música": "music_lyrics",
+}
+
+
+def generate_script_document(
+    settings: dict[str, Any],
+    *,
+    document_type: str,
+    title: str,
+    brief: str,
+    language: str,
+    channel: dict[str, Any] | None = None,
+    blueprint: dict[str, Any] | None = None,
+    structure_notes: str = "",
+) -> dict[str, Any]:
+    """Generate an editable Markdown document from the configured LLM.
+
+    The function deliberately returns text only. It never writes to storage; the UI
+    decides whether the generated draft should be saved after the user reviews it.
+    """
+    normalized_type = DOCUMENT_TYPES.get(document_type, document_type)
+    if normalized_type not in {"video_script", "music_lyrics"}:
+        raise CreativeGenerationError("Escolha Roteiro de vídeo ou Letra de música.")
+    if not brief.strip():
+        raise CreativeGenerationError("Escreva um tema ou briefing antes de gerar o documento.")
+
+    channel_context_value = channel_context(channel or {}, blueprint or {})
+    blueprint_payload = blueprint or {}
+    if normalized_type == "video_script":
+        output_requirements = {
+            "content": "roteiro completo em Markdown, com título, gancho, cenas, narração e indicações visuais/sonoras",
+            "summary": "resumo editorial em uma frase",
+        }
+        system = (
+            "És um roteirista editorial de vídeos faceless. Cria um roteiro original, natural e executável, "
+            "alinhado exclusivamente ao nicho e às regras do Blueprint fornecido. Não inventes factos sensíveis, "
+            "não uses introduções genéricas, não escrevas comentários sobre IA e não incluas um CTA vazio. "
+            "Responde apenas com JSON válido nas chaves title, summary e content."
+        )
+    else:
+        output_requirements = {
+            "content": "letra completa em Markdown, com secções [Verso], [Pré-refrão], [Refrão], [Ponte] quando fizer sentido",
+            "summary": "resumo da intenção musical em uma frase",
+        }
+        system = (
+            "És um compositor de letras originais. Cria uma letra cantável, coerente com o tema, idioma, "
+            "Blueprint e direcção musical fornecidos. Não copies letras existentes, não cites artistas sem pedido "
+            "e não acrescentes explicações dentro da letra. Responde apenas com JSON válido nas chaves title, summary e content."
+        )
+
+    user = json.dumps(
+        {
+            "document_type": normalized_type,
+            "requested_title": title.strip(),
+            "brief": brief.strip(),
+            "language": language.strip(),
+            "channel": channel_context_value,
+            "blueprint": blueprint_payload,
+            "structure_notes": structure_notes.strip(),
+            "output_requirements": output_requirements,
+        },
+        ensure_ascii=False,
+    )
+    result = _chat_json(settings, system, user)
+    content = str(result.get("content") or "").strip()
+    if not content:
+        raise CreativeGenerationError("O provider LLM devolveu um documento sem conteúdo.")
+    return {
+        "document_type": normalized_type,
+        "title": str(result.get("title") or title or brief).strip(),
+        "summary": str(result.get("summary") or "").strip(),
+        "content": content,
+        "language": language.strip(),
+        "blueprint_id": str(blueprint_payload.get("id") or ""),
+        "blueprint_name": str(blueprint_payload.get("name") or "SEM BLUEPRINT CONFIGURADO"),
+        "channel_id": str((channel or {}).get("id") or ""),
+        "channel_name": str((channel or {}).get("name") or "Documento independente"),
+        "generated_by": "configured_llm",
+    }

package/hermes_ui/storage.py

@@ -24,8 +24,9 @@ DEFAULTS: dict[str, Any] = {
     "uploads.json": [],
     "niche_apify_runs.json": [],
     "metadata_edits.json": [],
-    "python_editor_edits.json": [],
-    "mcp_server.json": {
+        "python_editor_edits.json": [],
+        "scripts.json": [],
+        "mcp_server.json": {
         "enabled": False,
         "host": "127.0.0.1",
         "port": 3031,
@@ -191,6 +192,13 @@ DEFAULTS: dict[str, Any] = {
         "upload_post_username": "",
         "upload_post_platforms": "tiktok,instagram",
         "upload_post_auto_upload": False,
+        "postiz_enabled": False,
+        "postiz_api_key": "",
+        "postiz_base_url": "https://api.postiz.com/public/v1",
+        "postiz_mcp_url": "https://api.postiz.com/mcp",
+        "postiz_mode": "api",
+        "postiz_integration_id": "",
+        "postiz_auto_publish": False,
         "tiktok_client_key": "",
         "tiktok_client_secret": "",
         "tiktok_redirect_uri": "http://localhost:3030/oauth/tiktok/callback",

package/integrations/postiz.py

@@ -0,0 +1,173 @@
+"""Postiz Public API adapter used as the final upload fallback."""
+
+from __future__ import annotations
+
+import mimetypes
+from pathlib import Path
+from typing import Any
+
+import requests
+
+from .platforms import IntegrationResult
+
+
+DEFAULT_POSTIZ_BASE_URL = "https://api.postiz.com/public/v1"
+DEFAULT_POSTIZ_MCP_URL = "https://api.postiz.com/mcp"
+
+
+class PostizAdapter:
+    def __init__(self, settings: dict[str, Any] | None = None):
+        self.settings = settings or {}
+        self.api_key = str(self.settings.get("postiz_api_key") or "").strip()
+        self.base_url = str(self.settings.get("postiz_base_url") or DEFAULT_POSTIZ_BASE_URL).strip().rstrip("/")
+        self.mcp_url = str(self.settings.get("postiz_mcp_url") or DEFAULT_POSTIZ_MCP_URL).strip().rstrip("/")
+
+    def _headers(self, *, json_body: bool = False) -> dict[str, str]:
+        headers = {"Authorization": self.api_key}
+        if json_body:
+            headers["Content-Type"] = "application/json"
+        return headers
+
+    def _error(self, message: str, data: dict[str, Any] | None = None) -> IntegrationResult:
+        return IntegrationResult(False, message, data or {})
+
+    def status(self) -> IntegrationResult:
+        if not self.api_key:
+            return self._error("Postiz não configurado: adicione a API key em Configurações Técnicas.")
+        return IntegrationResult(True, f"Postiz configurado em {self.base_url}.", {"base_url": self.base_url, "mcp_url": self.mcp_url})
+
+    def list_integrations(self) -> IntegrationResult:
+        status = self.status()
+        if not status.ok:
+            return status
+        try:
+            response = requests.get(f"{self.base_url}/integrations", headers=self._headers(), timeout=30)
+        except requests.RequestException as exc:
+            return self._error(f"Não foi possível contactar o Postiz: {exc}")
+        if response.status_code >= 400:
+            return self._error(f"Postiz devolveu HTTP {response.status_code}: {response.text[:500]}")
+        try:
+            payload = response.json()
+        except ValueError:
+            return self._error("Postiz devolveu uma resposta que não é JSON.")
+        if isinstance(payload, dict):
+            integrations = payload.get("integrations") or payload.get("data") or payload.get("items") or []
+        else:
+            integrations = payload
+        if not isinstance(integrations, list):
+            return self._error("A resposta de integrações do Postiz não tem uma lista válida.", {"payload": payload})
+        normalized = [item for item in integrations if isinstance(item, dict) and item.get("id")]
+        return IntegrationResult(True, f"{len(normalized)} integração(ões) Postiz carregada(s).", {"integrations": normalized, "payload": payload})
+
+    def upload_file(self, video_path: str | Path, *, mime_type: str | None = None) -> IntegrationResult:
+        status = self.status()
+        if not status.ok:
+            return status
+        path = Path(video_path)
+        if not path.is_file():
+            return self._error(f"Vídeo não encontrado para o Postiz: {path}")
+        content_type = mime_type or mimetypes.guess_type(path.name)[0] or "video/mp4"
+        try:
+            with path.open("rb") as handle:
+                response = requests.post(
+                    f"{self.base_url}/upload",
+                    headers=self._headers(),
+                    files={"file": (path.name, handle, content_type)},
+                    timeout=180,
+                )
+        except requests.RequestException as exc:
+            return self._error(f"Não foi possível enviar o vídeo para o Postiz: {exc}")
+        if response.status_code >= 400:
+            return self._error(f"Postiz rejeitou o upload (HTTP {response.status_code}): {response.text[:500]}")
+        try:
+            payload = response.json()
+        except ValueError:
+            return self._error("Postiz devolveu uma resposta de upload que não é JSON.")
+        asset_id = str(payload.get("id") or "").strip() if isinstance(payload, dict) else ""
+        asset_path = str(payload.get("path") or "").strip() if isinstance(payload, dict) else ""
+        if not asset_id or not asset_path:
+            return self._error("O upload Postiz não devolveu id e path do asset.", {"payload": payload})
+        return IntegrationResult(True, "Vídeo carregado no Postiz.", {"asset": {"id": asset_id, "path": asset_path}, "payload": payload})
+
+    def create_youtube_post(
+        self,
+        integration_id: str,
+        *,
+        asset: dict[str, str],
+        title: str,
+        description: str = "",
+        visibility: str = "private",
+        tags: list[str] | None = None,
+        thumbnail: dict[str, str] | None = None,
+        post_type: str = "now",
+        date: str | None = None,
+    ) -> IntegrationResult:
+        status = self.status()
+        if not status.ok:
+            return status
+        integration_id = str(integration_id or "").strip()
+        if not integration_id:
+            return self._error("Seleccione uma integração YouTube do Postiz antes de publicar.")
+        normalized_visibility = visibility if visibility in {"public", "unlisted", "private"} else "private"
+        tag_values = [str(tag).strip() for tag in (tags or []) if str(tag).strip()]
+        body: dict[str, Any] = {
+            "type": post_type if post_type in {"now", "schedule", "draft"} else "now",
+            "shortLink": False,
+            "tags": [],
+            "posts": [
+                {
+                    "integration": {"id": integration_id},
+                    "value": [{"content": description, "image": [asset]}],
+                    "settings": {
+                        "__type": "youtube",
+                        "title": title.strip()[:100] or "Vídeo Thunderbolt",
+                        "type": normalized_visibility,
+                        "selfDeclaredMadeForKids": "no",
+                        "thumbnail": thumbnail,
+                        "tags": [{"value": value, "label": value} for value in tag_values],
+                    },
+                }
+            ],
+        }
+        if post_type == "schedule" and date:
+            body["date"] = date
+        try:
+            response = requests.post(f"{self.base_url}/posts", headers=self._headers(json_body=True), json=body, timeout=60)
+        except requests.RequestException as exc:
+            return self._error(f"Não foi possível criar o post no Postiz: {exc}")
+        if response.status_code >= 400:
+            return self._error(f"Postiz rejeitou a publicação (HTTP {response.status_code}): {response.text[:500]}", {"request": body})
+        try:
+            payload = response.json()
+        except ValueError:
+            return self._error("Postiz devolveu uma resposta de publicação que não é JSON.", {"request": body})
+        return IntegrationResult(True, "Post criado no Postiz.", {"payload": payload, "request": body, "asset": asset, "integration_id": integration_id})
+
+    def publish_video(
+        self,
+        video_path: str | Path,
+        *,
+        integration_id: str,
+        title: str,
+        description: str = "",
+        visibility: str = "private",
+        tags: list[str] | None = None,
+        thumbnail_path: str | Path | None = None,
+    ) -> IntegrationResult:
+        upload = self.upload_file(video_path)
+        if not upload.ok:
+            return upload
+        thumbnail_asset = None
+        if thumbnail_path and Path(thumbnail_path).is_file():
+            thumb_upload = self.upload_file(thumbnail_path, mime_type=mimetypes.guess_type(str(thumbnail_path))[0] or "image/jpeg")
+            if thumb_upload.ok:
+                thumbnail_asset = thumb_upload.data.get("asset")
+        return self.create_youtube_post(
+            integration_id,
+            asset=upload.data["asset"],
+            title=title,
+            description=description,
+            visibility=visibility,
+            tags=tags,
+            thumbnail=thumbnail_asset,
+        )

package/integrations/upload_routing.py

@@ -0,0 +1,177 @@
+"""Ordered YouTube upload routing for Thunderbolt.
+
+The route is intentionally deterministic:
+1. Official YouTube API, up to five successful sends per Google account/day.
+2. Internal browser-session upload, when the account document is complete.
+3. Postiz, when configured with an API key and integration ID.
+"""
+
+from __future__ import annotations
+
+from datetime import date
+from pathlib import Path
+from typing import Any, Callable
+
+from integrations.platforms import IntegrationResult, YouTubeAdapter
+from integrations.postiz import PostizAdapter
+from integrations.youtube_direct_credentials import document_status
+from integrations.youtube_direct_upload import YouTubeDirectUploader
+from hermes_ui.storage import read_json, write_json
+
+OFFICIAL_DAILY_LIMIT = 5
+QUOTA_FILENAME = "official_upload_quota.json"
+
+
+def _attempt_record(name: str, result: IntegrationResult, *, skipped: bool = False) -> dict[str, Any]:
+    return {
+        "route": name,
+        "status": "skipped" if skipped else ("success" if result.ok else "failed"),
+        "message": result.message,
+        "data": result.data,
+    }
+
+
+def _quota_key(channel: dict[str, Any], account: dict[str, Any] | None) -> str:
+    if account and account.get("id"):
+        return f"account:{account['id']}"
+    if channel.get("google_account_id"):
+        return f"account:{channel['google_account_id']}"
+    return f"channel:{channel.get('id', 'unknown')}"
+
+
+def official_upload_count(channel: dict[str, Any], account: dict[str, Any] | None, *, today: str | None = None) -> int:
+    today = today or date.today().isoformat()
+    state = read_json(QUOTA_FILENAME, {})
+    if not isinstance(state, dict):
+        return 0
+    entry = state.get(_quota_key(channel, account), {})
+    if not isinstance(entry, dict) or entry.get("date") != today:
+        return 0
+    try:
+        return max(0, int(entry.get("count", 0)))
+    except (TypeError, ValueError):
+        return 0
+
+
+def record_official_upload(channel: dict[str, Any], account: dict[str, Any] | None, *, today: str | None = None) -> int:
+    today = today or date.today().isoformat()
+    state = read_json(QUOTA_FILENAME, {})
+    if not isinstance(state, dict):
+        state = {}
+    key = _quota_key(channel, account)
+    current = official_upload_count(channel, account, today=today)
+    state[key] = {"date": today, "count": current + 1}
+    write_json(QUOTA_FILENAME, state)
+    return current + 1
+
+
+def _result_with_attempts(result: IntegrationResult, attempts: list[dict[str, Any]], route: str) -> IntegrationResult:
+    data = dict(result.data or {})
+    data["route"] = route
+    data["attempts"] = attempts
+    return IntegrationResult(result.ok, result.message, data)
+
+
+def upload_with_default_route(
+    settings: dict[str, Any],
+    *,
+    storage_root: Path,
+    channel: dict[str, Any],
+    account: dict[str, Any] | None,
+    video_path: str,
+    title: str,
+    description: str = "",
+    tags: list[str] | None = None,
+    category_id: str = "22",
+    language: str = "pt-BR",
+    privacy_status: str = "private",
+    thumbnail_path: str = "",
+    captions_path: str = "",
+    official_uploader: Callable[..., IntegrationResult] | None = None,
+    direct_uploader: Callable[..., IntegrationResult] | None = None,
+    postiz_publisher: Callable[..., IntegrationResult] | None = None,
+) -> IntegrationResult:
+    attempts: list[dict[str, Any]] = []
+    quota_count = official_upload_count(channel, account)
+    if quota_count >= OFFICIAL_DAILY_LIMIT:
+        quota_result = IntegrationResult(False, f"Limite local de {OFFICIAL_DAILY_LIMIT} envios oficiais por conta Google atingido hoje; a tentar o próximo método.", {"count": quota_count, "limit": OFFICIAL_DAILY_LIMIT})
+        attempts.append(_attempt_record("API Oficial", quota_result, skipped=True))
+    else:
+        official_uploader = official_uploader or YouTubeAdapter(settings).upload_video
+        try:
+            official_result = official_uploader(
+                video_path,
+                title=title,
+                description=description,
+                tags=tags or [],
+                category_id=category_id,
+                language=language,
+                privacy_status=privacy_status,
+                thumbnail_path=thumbnail_path,
+                captions_path=captions_path,
+            )
+        except Exception as exc:  # Keep fallback actionable and deterministic.
+            official_result = IntegrationResult(False, f"API Oficial falhou: {exc}", {})
+        attempts.append(_attempt_record("API Oficial", official_result))
+        if official_result.ok:
+            used = record_official_upload(channel, account)
+            data = dict(official_result.data or {})
+            data["official_daily_count"] = used
+            data["official_daily_limit"] = OFFICIAL_DAILY_LIMIT
+            data["route"] = "API Oficial"
+            data["attempts"] = attempts
+            return IntegrationResult(True, official_result.message, data)
+
+    direct_ready = False
+    if account:
+        try:
+            status = document_status(storage_root, account, channel, settings, [channel])
+            direct_ready = bool(status.get("ready"))
+            if not direct_ready:
+                missing = list(status.get("missing_cookies", []))
+                if not status.get("has_session_info"):
+                    missing.append("sessionInfo")
+                if not status.get("has_innertube_api_key"):
+                    missing.append("INNERTUBE_API_KEY")
+                if not status.get("has_delegated_session_id"):
+                    missing.append("DELEGATED_SESSION_ID")
+                direct_result = IntegrationResult(False, f"Upload directo indisponível: {', '.join(missing)}.", {"missing": missing})
+            else:
+                direct_result = None
+        except Exception as exc:
+            direct_result = IntegrationResult(False, f"Não foi possível validar o documento do Upload directo: {exc}", {})
+    else:
+        direct_result = IntegrationResult(False, "Upload directo indisponível: o canal não tem uma conta Google associada.", {})
+    if direct_ready:
+        direct_uploader = direct_uploader or YouTubeDirectUploader(settings, channel, account=account, storage_root=storage_root).upload
+        try:
+            direct_result = direct_uploader(video_path, title=title, description=description, visibility=privacy_status)
+        except Exception as exc:
+            direct_result = IntegrationResult(False, f"Upload directo falhou: {exc}", {})
+    attempts.append(_attempt_record("Upload directo", direct_result))
+    if direct_result.ok:
+        return _result_with_attempts(direct_result, attempts, "Upload directo")
+
+    postiz = PostizAdapter(settings)
+    if not bool(settings.get("postiz_enabled", False)):
+        postiz_result = IntegrationResult(False, "Postiz está desactivado em Configurações Técnicas.", {})
+        attempts.append(_attempt_record("Postiz", postiz_result, skipped=True))
+    else:
+        postiz_publisher = postiz_publisher or postiz.publish_video
+        try:
+            postiz_result = postiz_publisher(
+                video_path,
+                integration_id=str(settings.get("postiz_integration_id", "") or ""),
+                title=title,
+                description=description,
+                visibility=privacy_status,
+                tags=tags or [],
+                thumbnail_path=thumbnail_path,
+            )
+        except Exception as exc:
+            postiz_result = IntegrationResult(False, f"Postiz falhou: {exc}", {})
+        attempts.append(_attempt_record("Postiz", postiz_result))
+        if postiz_result.ok:
+            return _result_with_attempts(postiz_result, attempts, "Postiz")
+
+    return IntegrationResult(False, "Nenhum método de envio conseguiu publicar o vídeo.", {"attempts": attempts, "route": "none"})

package/package.json

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