@danhachuel/thunderbolt 0.2.53 → 0.2.55

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.53
+> **Versão deste manual:** 0.2.55
 > **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.53 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.55 install
 ```
 
 Linux/macOS:
 
 ```bash
-npx --yes @danhachuel/thunderbolt@0.2.53 install
+npx --yes @danhachuel/thunderbolt@0.2.55 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.53 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.55 install`; o instalador detecta e reutiliza o que já estiver válido.
 
 ### Niche Finder Apify
 
@@ -440,7 +440,7 @@ O menu **Models AI** foi adicionado abaixo de **Edição**. As abas **Personagen
 
 ## Edição: Limpador de Metadados, Cortes e Editor Python
 
-A aba **Limpador de Metadados** continua funcional e foi movida para **Edição**. A aba **Cortes** permanece reservada e não executa operações. A aba **Editor Python** é funcional e permite escolher vídeos gerados, indicar uma pasta local ou fazer upload manual; as operações são manuais e criam cópias sem alterar os originais.
+A aba **Limpador de Metadados** continua funcional e foi movida para **Edição**. A aba **Cortes** é um Clip Generator local inspirado no [OpenShorts](https://github.com/mutonby/openshorts): permite upload de vídeo, URL directa, vídeos gerados ou pasta local, formatos 9:16/1:1/16:9, opções avançadas, modo manual ou automático por segmentos locais e confirmação de direitos antes da geração. Os clips são processados com FFmpeg, guardados em `storage/cuts/runs/<id>/`, apresentados com preview e downloads individual/ZIP, acompanhados de manifesto JSON e histórico. A aba **Editor Python** é funcional e permite escolher vídeos gerados, indicar uma pasta local ou fazer upload manual; as operações são manuais e criam cópias sem alterar os originais.
 
 ## Editor Python baseado no PYEdit
 
@@ -448,6 +448,8 @@ O **Editor Python** adapta o recorte do [PYEdit](https://github.com/Congren/PYEd
 
 Cada operação usa FFmpeg local, preserva o original, cria a saída em `storage/python_editor/outputs/`, guarda o histórico em `storage/state/python_editor_edits.json` e permite descarregar o resultado e um manifesto JSON. Na subaba **Código Python**, pode criar e guardar scripts em `storage/python_editor/scripts/` ou carregar scripts existentes. Por segurança, a UI não executa código Python e não executa scripts automaticamente.
 
+No modo automático de **Cortes**, a aplicação não inventa uma selecção viral: sem transcrição ou provider de IA configurado, são gerados segmentos locais distribuídos pelo vídeo; o modo manual permite definir início e fim exactos. Abrir a página não inicia download, análise ou processamento.
+
 ## Criação de Vídeos — IA editorial e pacotes criativos
 
 O formulário permite escrever manualmente o **Tópico ou briefing** ou clicar em **Gerar tópico/briefing com IA**. O botão usa o provider LLM, Base URL, API key e modelo guardados em **Configurações Técnicas > API Keys**, incorpora a descrição, o nicho e o Blueprint do canal e coloca o resultado no campo para revisão. Abrir a página não inicia chamadas externas.
@@ -456,10 +458,12 @@ 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.

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 |
@@ -19,7 +19,7 @@ A primeira versão implementa a camada UI independente com:
 | Automação | Menu expansível com a subaba **Automação Youtube**, onde ficam os vídeos e canais, selectores editáveis de Blueprint/voz padrão, Automação ON, horário diário HH:MM e worker local baseado no relógio do computador |
 | 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 funcional, Cortes reservado e Editor Python inspirado no PYEdit para vídeos e scripts locais |
+| 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 |
 | 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 |
@@ -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.53
+## Navegação da UI 0.2.55
 
-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.50 install
-npx.cmd --yes @danhachuel/thunderbolt@0.2.50 doctor
-npx.cmd --yes @danhachuel/thunderbolt@0.2.50
+npx.cmd --yes @danhachuel/thunderbolt@0.2.55 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.55 doctor
+npx.cmd --yes @danhachuel/thunderbolt@0.2.55
 ```
 
 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.50 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.55 install`; o instalador detecta e reutiliza componentes já válidos.
 
 ## Editor Python baseado no PYEdit
 
@@ -240,6 +240,14 @@ A aba **Limpador de Metadados** foi adaptada do workflow `YTBMetadataGenerator.j
 
 A descrição segue a composição do workflow de referência: preview, secção de links e capítulos/timestamps. O resultado inclui um manifesto JSON para utilizar os metadados num fluxo posterior de upload. A versão local não usa o trigger RSS, o Apify ou a actualização automática de um vídeo YouTube; em vez disso, o utilizador fornece directamente o vídeo terceiro e controla a edição antes de publicar.
 
+## Cortes — Clip Generator local
+
+A aba **Cortes** é um Clip Generator local inspirado no fluxo do [OpenShorts](https://github.com/mutonby/openshorts). Permite fazer upload de um vídeo, descarregar uma URL directa de vídeo, seleccionar um vídeo gerado pela pipeline ou escolher uma pasta local. O original é preservado em `storage/cuts/inputs/`.
+
+O formulário apresenta os formatos **9:16 — Shorts/Reels/TikTok**, **1:1 — Feed posts** e **16:9 — YouTube/landscape**, além de opções avançadas para modo automático por segmentos locais ou corte manual, número de clips, durações mínima/máxima e intervalo de início/fim. A execução só começa depois da confirmação explícita de direitos e do clique em **Gerar Clips**.
+
+Os clips são gerados localmente com FFmpeg, redimensionados para o formato escolhido sem ampliar desnecessariamente a fonte e guardados em `storage/cuts/runs/<id>/`. A página apresenta estado de análise, preview dos resultados, download individual, download ZIP, manifesto JSON e histórico em `storage/state/cuts_runs.json`. A selecção automática de momentos virais por IA permanece um ponto de extensão: sem transcrição/provider configurado, o modo manual continua disponível e não são inventados resultados.
+
 ## Canais YouTube
 
 A aba **Canais Youtube** está dividida em dois fluxos independentes. Em **Importar do YouTube**, o método padrão **Página pública — sem API Key** consulta a página pública do canal e preenche nome, ID, handle, URL, descrição e thumbnail quando esses dados estão disponíveis. A opção **YouTube Data API — API Key opcional** pode ser escolhida para métricas oficiais quando uma **YouTube Data API Key própria** estiver configurada em **Configurações** ou em `YOUTUBE_API_KEY`; essa chave é distinta do OAuth Client ID e Client Secret.
@@ -260,6 +268,10 @@ A subaba **Upload directo** adapta o [YouTube-Video-Upload-Frontend-Api](https:/
 
 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

@@ -30,9 +30,12 @@ from app.modules.niche_finder.summarizer import summarize_items
 from hermes_ui.blueprints import create_blueprint_from_link, list_branding_files, save_generated_blueprint
 from hermes_ui.metadata_cleaner import build_description, clean_video_metadata, list_edit_records, metadata_manifest, normalize_tags, save_edit_record, store_external_video
 from hermes_ui.python_editor import AUDIO_EXTENSIONS, VIDEO_EXTENSIONS, PythonEditorError, change_speed, editor_manifest, extract_audio, list_edit_records as list_python_editor_records, list_generated_videos, list_scripts, list_video_files, read_script, remove_audio, replace_audio, resize_video, save_edit_record as save_python_editor_record, save_script, store_uploaded_asset, trim_video
+from hermes_ui.cuts import CutsError, download_direct_video_url, generate_clips, list_generated_videos as list_cut_generated_videos, list_runs as list_cut_runs, list_video_files as list_cut_video_files, manifest_bytes as cut_manifest_bytes, store_uploaded_video, zip_run as zip_cut_run
 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
@@ -150,7 +153,16 @@ st.markdown("""
 .content-label { color:#8ba6bb; font-size:.8rem; text-transform:uppercase; letter-spacing:.07em; }
 .content-value { color:#f4f8fb; font-size:1.8rem; font-weight:700; margin-top:.3rem; }
 .stage { border-left:3px solid #35a7ff; padding:.65rem .8rem; margin:.4rem 0; background:#101d2a; border-radius:8px; }
-.small-muted { color:#8ba6bb; font-size:.85rem; }
+ .small-muted { color:#8ba6bb; font-size:.85rem; }
+.tb-cuts-hero { max-width:860px; margin:0 auto 1.1rem; padding:1.6rem 1.4rem 1.35rem; text-align:center; border:1px solid #263d50; border-radius:18px; background:radial-gradient(circle at 50% 0, rgba(164,126,55,.16), transparent 58%), linear-gradient(145deg, rgba(17,27,37,.98), rgba(9,15,22,.98)); box-shadow:0 18px 48px rgba(0,0,0,.18); }
+.tb-cuts-hero .tb-cuts-kicker { color:#c59b55; font-size:.68rem; letter-spacing:.18em; text-transform:uppercase; font-weight:700; }
+.tb-cuts-hero h2 { color:#f5f0e8; font-family:Georgia,serif; font-size:2rem; font-weight:500; margin:.42rem 0 .25rem; text-transform:lowercase; }
+.tb-cuts-hero p { color:#9cafbf; margin:0 auto; max-width:620px; font-size:.9rem; }
+[data-testid="stRadio"] [role="radiogroup"] { gap:.6rem; }
+[data-testid="stRadio"] label { border:1px solid #2a4052; border-radius:12px; padding:.65rem .8rem; background:#101b25; min-height:4.3rem; }
+[data-testid="stRadio"] label:has(input:checked) { border-color:#c59b55; background:linear-gradient(145deg, rgba(96,71,33,.42), rgba(17,27,37,.95)); }
+[data-testid="stStatusWidget"] { border-color:#2a4052 !important; background:#101b25 !important; }
+
 /* Cores dos chips por identidade da plataforma, sem depender da ordem de selecção. */
 [data-testid="stMultiSelectTagsContainer"] span[data-tag] { color:#ffffff !important; border:0 !important; font-weight:700 !important; }
 [data-testid="stMultiSelectTagsContainer"] span[data-tag] span[title],
@@ -1229,6 +1241,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."""
@@ -1485,6 +1641,189 @@ def render_edit_placeholder(page_title: str, description: str):
     st.info("Esta aba está reservada para desenvolvimento futuro e ainda não executa nenhuma operação.")
 
 
+def render_cuts():
+    st.title("Cortes")
+    st.caption("Crie clips verticais, quadrados ou horizontais a partir de vídeos longos, com um fluxo local inspirado no Clip Generator do OpenShorts.")
+
+    st.markdown(
+        "<div class='tb-cuts-hero'><div class='tb-cuts-kicker'>01 · CLIP GENERATOR</div><h2>Create Viral Shorts</h2><p>Escolha um vídeo longo, defina o formato e gere clips locais sem sobrescrever a fonte.</p></div>",
+        unsafe_allow_html=True,
+    )
+
+    source_path = None
+    source_tab, url_tab, generated_tab, folder_tab = st.tabs(["Upload ficheiro", "URL de vídeo", "Vídeos gerados", "Pasta local"])
+    with source_tab:
+        uploaded_video = st.file_uploader(
+            "Clique para carregar ou arraste um vídeo",
+            type=sorted(extension.lstrip(".") for extension in VIDEO_EXTENSIONS),
+            key="cuts_video_upload",
+            help="MP4, MOV, MKV, WEBM e formatos suportados pelo FFmpeg. O original fica preservado.",
+        )
+        if uploaded_video is not None:
+            try:
+                source_path = store_uploaded_video(uploaded_video.name, uploaded_video.getvalue())
+                st.session_state["cuts_source_path"] = str(source_path)
+                st.session_state["cuts_source_label"] = f"Upload · {uploaded_video.name}"
+            except CutsError as exc:
+                st.error(str(exc))
+    with url_tab:
+        url_value = st.text_input("URL directa do vídeo", placeholder="https://exemplo.com/video.mp4", key="cuts_video_url")
+        st.caption("A URL deve apontar directamente para um ficheiro de vídeo HTTP/HTTPS. O download só ocorre depois de clicar no botão.")
+        if st.button("Descarregar vídeo", key="cuts_download_url", use_container_width=True):
+            try:
+                source_path = download_direct_video_url(url_value)
+                st.session_state["cuts_source_path"] = str(source_path)
+                st.session_state["cuts_source_label"] = f"URL · {url_value}"
+                st.success("Vídeo descarregado e pronto para análise.")
+            except CutsError as exc:
+                st.error(str(exc))
+    with generated_tab:
+        generated_paths = list_cut_generated_videos(read_json("tasks.json", []))
+        if not generated_paths:
+            st.info("Ainda não existem vídeos gerados com caminho registado na pipeline.")
+        else:
+            generated_labels = [f"{path.name} — {path}" for path in generated_paths]
+            selected_generated = st.selectbox("Vídeo gerado", range(len(generated_paths)), format_func=lambda index: generated_labels[index], key="cuts_generated_index")
+            if st.button("Usar vídeo seleccionado", key="cuts_use_generated", use_container_width=True):
+                source_path = generated_paths[selected_generated]
+                st.session_state["cuts_source_path"] = str(source_path)
+                st.session_state["cuts_source_label"] = f"Pipeline · {source_path.name}"
+    with folder_tab:
+        folder_value = st.text_input("Pasta de vídeos", value=str(STORAGE / "videos"), key="cuts_video_folder")
+        folder_paths = list_cut_video_files(folder_value)
+        if not folder_paths:
+            st.info("Não foram encontrados vídeos nessa pasta.")
+        else:
+            folder_labels = [f"{path.name} — {path}" for path in folder_paths]
+            selected_folder = st.selectbox("Vídeo da pasta", range(len(folder_paths)), format_func=lambda index: folder_labels[index], key="cuts_folder_index")
+            if st.button("Usar vídeo da pasta", key="cuts_use_folder", use_container_width=True):
+                source_path = folder_paths[selected_folder]
+                st.session_state["cuts_source_path"] = str(source_path)
+                st.session_state["cuts_source_label"] = f"Pasta local · {source_path.name}"
+
+    stored_source = st.session_state.get("cuts_source_path", "")
+    if not source_path and stored_source:
+        candidate = Path(stored_source)
+        if candidate.is_file():
+            source_path = candidate
+    if source_path and source_path.is_file():
+        st.markdown(f"**Fonte seleccionada:** `{st.session_state.get('cuts_source_label', source_path.name)}`")
+        source_cols = st.columns([1.4, 1])
+        with source_cols[0]:
+            st.video(str(source_path))
+        with source_cols[1]:
+            st.caption(f"{source_path.name}")
+            st.caption(f"{source_path.stat().st_size / (1024 * 1024):.2f} MB")
+            st.caption("A fonte original não é alterada.")
+    else:
+        st.info("Escolha um ficheiro, descarregue uma URL, seleccione um vídeo gerado ou indique uma pasta local.")
+
+    with st.container(border=True):
+        st.markdown("**Output format**")
+        format_options = ["9:16", "1:1", "16:9"]
+        output_format = st.radio(
+            "Formato de saída",
+            format_options,
+            format_func=lambda value: {"9:16": "9:16\\nShorts · Reels · TikTok", "1:1": "1:1\\nFeed posts", "16:9": "16:9\\nYouTube · landscape"}[value],
+            horizontal=True,
+            key="cuts_output_format",
+            label_visibility="collapsed",
+        )
+        with st.expander("advanced options", expanded=False):
+            strategy_label = st.selectbox("Estratégia", ["Automático · segmentos locais", "Manual · um intervalo"], key="cuts_strategy")
+            strategy = "manual" if strategy_label.startswith("Manual") else "automatic"
+            options_cols = st.columns(3)
+            with options_cols[0]:
+                max_clips = st.number_input("Número máximo de clips", min_value=1, max_value=20, value=3, step=1, key="cuts_max_clips")
+            with options_cols[1]:
+                min_duration = st.number_input("Duração mínima (s)", min_value=1.0, max_value=600.0, value=15.0, step=1.0, key="cuts_min_duration")
+            with options_cols[2]:
+                max_duration = st.number_input("Duração máxima (s)", min_value=1.0, max_value=600.0, value=60.0, step=1.0, key="cuts_max_duration")
+            manual_start = manual_end = 0.0
+            if strategy == "manual":
+                manual_cols = st.columns(2)
+                with manual_cols[0]:
+                    manual_start = st.number_input("Início do intervalo (s)", min_value=0.0, value=0.0, step=0.5, key="cuts_manual_start")
+                with manual_cols[1]:
+                    manual_end = st.number_input("Fim do intervalo (s)", min_value=0.5, value=30.0, step=0.5, key="cuts_manual_end")
+            st.caption("O modo automático cria segmentos locais distribuídos pelo vídeo. A selecção viral por IA fica disponível como extensão quando houver transcrição/provider configurado.")
+
+        rights_confirmed = st.checkbox(
+            "Confirmo que possuo os direitos ou autorização para processar este conteúdo.",
+            key="cuts_rights_confirmed",
+        )
+        generate_button = st.button(
+            "Gerar Clips",
+            type="primary",
+            use_container_width=True,
+            disabled=not (source_path and source_path.is_file() and rights_confirmed),
+            key="cuts_generate_button",
+        )
+
+    if generate_button and source_path and source_path.is_file():
+        settings = read_json("settings.json", {})
+        with st.status("A analisar e a gerar clips…", expanded=True) as status:
+            st.write("A validar fonte e parâmetros…")
+            try:
+                record = generate_clips(
+                    source_path,
+                    output_format=output_format,
+                    strategy=strategy,
+                    max_clips=int(max_clips),
+                    min_duration=float(min_duration),
+                    max_duration=float(max_duration),
+                    rights_confirmed=rights_confirmed,
+                    ffmpeg_path=settings.get("ffmpeg_path", ""),
+                    manual_start=float(manual_start),
+                    manual_end=float(manual_end) if strategy == "manual" else None,
+                )
+                st.session_state["cuts_last_run"] = record
+                status.update(label="Clips gerados", state="complete", expanded=False)
+            except CutsError as exc:
+                status.update(label="A geração falhou", state="error", expanded=True)
+                st.error(str(exc))
+
+    last_run = st.session_state.get("cuts_last_run")
+    if last_run:
+        st.divider()
+        status_label = {"complete": "CONCLUÍDO", "processing": "A PROCESSAR", "error": "ERRO"}.get(last_run.get("status"), str(last_run.get("status", "—")).upper())
+        st.markdown(f"### Live Analysis · `{status_label}`")
+        if last_run.get("status") == "complete":
+            clips = [clip for clip in last_run.get("clips", []) if Path(str(clip.get("path", ""))).is_file()]
+            result_cols = st.columns([3, 1, 1])
+            with result_cols[0]:
+                st.subheader("Generated Shorts")
+            with result_cols[1]:
+                st.metric("Clips", len(clips))
+            with result_cols[2]:
+                st.metric("Formato", last_run.get("output_format", "—"))
+            for index in range(0, len(clips), 3):
+                clip_cols = st.columns(3)
+                for col, clip in zip(clip_cols, clips[index:index + 3]):
+                    with col:
+                        with st.container(border=True):
+                            st.caption(f"Clip {clip.get('index', '—')} · {float(clip.get('duration', 0)):.1f}s")
+                            st.video(str(clip["path"]))
+                            st.download_button("Descarregar clip", data=Path(clip["path"]).read_bytes(), file_name=clip["name"], mime="video/mp4", key=f"cuts_download_{last_run['id']}_{clip['index']}", use_container_width=True)
+            try:
+                _, archive_bytes = zip_cut_run(last_run)
+                st.download_button("Descarregar todos os clips (ZIP)", data=archive_bytes, file_name=f"{last_run['id']}.zip", mime="application/zip", key=f"cuts_download_zip_{last_run['id']}", use_container_width=True)
+            except CutsError as exc:
+                st.warning(str(exc))
+            st.download_button("Descarregar manifesto JSON", data=cut_manifest_bytes(last_run), file_name=f"{last_run['id']}.json", mime="application/json", key=f"cuts_download_manifest_{last_run['id']}", use_container_width=True)
+        elif last_run.get("error"):
+            st.error(last_run["error"])
+
+    runs = list_cut_runs()
+    if runs:
+        with st.expander("Histórico do Clip Generator"):
+            st.dataframe(
+                [{"Data": run.get("created_at", "—"), "Fonte": run.get("source_name", "—"), "Formato": run.get("output_format", "—"), "Clips": len(run.get("clips", [])), "Estado": run.get("status", "—")} for run in runs[:20]],
+                use_container_width=True,
+                hide_index=True,
+            )
+
+
 def render_python_editor():
     st.title("Editor Python")
     st.caption("Editor local inspirado no PYEdit para scripts Python e edição manual de vídeos do Thunderbolt.")
@@ -1616,6 +1955,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.")
@@ -2589,6 +2929,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 = [
@@ -2681,12 +3022,13 @@ 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,
         "Edição": lambda: render_edit_placeholder("Edição", "Seleccione uma das abas de edição no menu expansível."),
         "Limpador de Metadados": render_metadata_cleaner,
-        "Cortes": lambda: render_edit_placeholder("Cortes", "Área reservada para a futura funcionalidade de cortes de vídeo."),
+        "Cortes": render_cuts,
         "Editor Python": render_python_editor,
         "Models AI": lambda: render_edit_placeholder("Models AI", "Seleccione uma das abas Models AI no menu expansível."),
         "Personagens": lambda: render_edit_placeholder("Personagens", "Área reservada para a futura funcionalidade de personagens."),

package/hermes_ui/cuts.py

@@ -0,0 +1,454 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import shutil
+import subprocess
+import unicodedata
+import uuid
+import zipfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Iterable
+from urllib.parse import urlparse
+
+import requests
+
+from . import storage
+from .metadata_cleaner import VIDEO_EXTENSIONS, _resolve_ffmpeg
+
+
+class CutsError(RuntimeError):
+    """Raised when a local clip-generation operation cannot be completed."""
+
+
+OUTPUT_FORMATS: dict[str, dict[str, Any]] = {
+    "9:16": {"width": 1080, "height": 1920, "label": "9:16 · Shorts / Reels / TikTok"},
+    "1:1": {"width": 1080, "height": 1080, "label": "1:1 · Feed posts"},
+    "16:9": {"width": 1920, "height": 1080, "label": "16:9 · YouTube / landscape"},
+}
+
+VIDEO_SUFFIXES = {f".{extension.lower().lstrip('.')}" for extension in VIDEO_EXTENSIONS}
+MAX_SOURCE_BYTES = 500 * 1024 * 1024
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _root() -> Path:
+    path = storage.STORAGE / "cuts"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def _inputs() -> Path:
+    path = _root() / "inputs"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def _runs_root() -> Path:
+    path = _root() / "runs"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def _safe_filename(name: str, fallback: str = "video") -> str:
+    normalized = unicodedata.normalize("NFKD", Path(name).name)
+    ascii_name = normalized.encode("ascii", "ignore").decode("ascii")
+    safe = re.sub(r"[^A-Za-z0-9._-]+", "-", ascii_name).strip(".-")
+    return safe or fallback
+
+
+def _validate_video(source: Path) -> Path:
+    candidate = Path(source).expanduser()
+    if not candidate.is_file():
+        raise CutsError("O vídeo seleccionado não existe ou não é um ficheiro.")
+    if candidate.suffix.lower() not in VIDEO_SUFFIXES:
+        raise CutsError("O vídeo seleccionado não tem uma extensão suportada.")
+    return candidate.resolve()
+
+
+def _safe_float(value: Any, fallback: float = 0.0) -> float:
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return fallback
+
+
+def normalize_output_format(output_format: str) -> str:
+    key = str(output_format or "").strip()
+    if key not in OUTPUT_FORMATS:
+        raise CutsError("Seleccione um formato de saída válido: 9:16, 1:1 ou 16:9.")
+    return key
+
+
+def store_uploaded_video(filename: str, content: bytes) -> Path:
+    if not content:
+        raise CutsError("O ficheiro de vídeo está vazio.")
+    suffix = Path(filename).suffix.lower()
+    if suffix not in VIDEO_SUFFIXES:
+        raise CutsError("O ficheiro enviado não tem uma extensão de vídeo suportada.")
+    digest = hashlib.sha256(content).hexdigest()[:16]
+    existing = next(iter(sorted(_inputs().glob(f"{digest}-*"))), None)
+    if existing and existing.is_file():
+        return existing.resolve()
+    target = _inputs() / f"{digest}-{_safe_filename(filename, 'video')}"
+    if not target.exists():
+        target.write_bytes(content)
+    return target.resolve()
+
+
+def list_video_files(folder: str | Path) -> list[Path]:
+    candidate = Path(folder).expanduser()
+    if not candidate.exists():
+        return []
+    if candidate.is_file():
+        return [candidate.resolve()] if candidate.suffix.lower() in VIDEO_SUFFIXES else []
+    try:
+        return sorted(
+            (path.resolve() for path in candidate.iterdir() if path.is_file() and path.suffix.lower() in VIDEO_SUFFIXES),
+            key=lambda path: path.stat().st_mtime,
+            reverse=True,
+        )
+    except OSError as exc:
+        raise CutsError(f"Não foi possível ler a pasta de vídeos: {exc}") from exc
+
+
+def list_generated_videos(tasks: Iterable[dict[str, Any]]) -> list[Path]:
+    paths: dict[str, Path] = {}
+    for task in tasks:
+        artifacts = task.get("artifacts") or {}
+        value = artifacts.get("video")
+        if isinstance(value, str) and value.strip():
+            candidate = Path(value).expanduser()
+            if candidate.is_file() and candidate.suffix.lower() in VIDEO_SUFFIXES:
+                paths[str(candidate.resolve())] = candidate.resolve()
+    return sorted(paths.values(), key=lambda path: path.stat().st_mtime, reverse=True)
+
+
+def resolve_ffmpeg(configured_path: str | None = None) -> str:
+    try:
+        return _resolve_ffmpeg(configured_path)
+    except RuntimeError as exc:
+        raise CutsError(str(exc)) from exc
+
+
+def resolve_ffprobe(configured_path: str | None = None) -> str | None:
+    configured = str(configured_path or "").strip()
+    candidates: list[str] = []
+    if configured:
+        configured_path_obj = Path(configured).expanduser()
+        if configured_path_obj.name.lower().startswith("ffmpeg"):
+            candidates.append(str(configured_path_obj.with_name("ffprobe" + configured_path_obj.suffix)))
+        candidates.append(configured)
+    detected = shutil.which("ffprobe")
+    if detected:
+        candidates.append(detected)
+    for candidate in candidates:
+        resolved = shutil.which(candidate) or (candidate if Path(candidate).is_file() else None)
+        if resolved:
+            return str(resolved)
+    return None
+
+
+def probe_duration(source: Path, *, ffprobe_path: str | None = None) -> float | None:
+    source = _validate_video(source)
+    binary = resolve_ffprobe(ffprobe_path)
+    if not binary:
+        return None
+    command = [binary, "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", str(source)]
+    try:
+        completed = subprocess.run(command, capture_output=True, text=True, check=False)
+    except OSError:
+        return None
+    if completed.returncode != 0:
+        return None
+    duration = _safe_float(completed.stdout.strip(), 0.0)
+    return duration if duration > 0 else None
+
+
+def validate_cut_request(
+    *,
+    source: Path,
+    output_format: str,
+    strategy: str,
+    max_clips: int,
+    min_duration: float,
+    max_duration: float,
+    rights_confirmed: bool,
+    manual_start: float = 0.0,
+    manual_end: float | None = None,
+) -> dict[str, Any]:
+    source = _validate_video(source)
+    output_format = normalize_output_format(output_format)
+    if strategy not in {"automatic", "manual"}:
+        raise CutsError("Seleccione uma estratégia de corte válida.")
+    if not rights_confirmed:
+        raise CutsError("Confirme que possui os direitos ou autorização para processar este conteúdo.")
+    max_clips = int(max_clips)
+    if max_clips < 1 or max_clips > 20:
+        raise CutsError("A quantidade de clips deve estar entre 1 e 20.")
+    min_duration = _safe_float(min_duration)
+    max_duration = _safe_float(max_duration)
+    if min_duration < 1 or max_duration > 600 or max_duration < min_duration:
+        raise CutsError("Defina uma duração válida: mínimo ≥ 1s, máximo ≤ 600s e máximo ≥ mínimo.")
+    manual_start = _safe_float(manual_start)
+    if manual_start < 0:
+        raise CutsError("O início manual não pode ser negativo.")
+    normalized_end = None if manual_end is None else _safe_float(manual_end)
+    if strategy == "manual" and (normalized_end is None or normalized_end <= manual_start):
+        raise CutsError("No modo manual, o fim deve ser superior ao início.")
+    return {
+        "source": str(source),
+        "source_name": source.name,
+        "output_format": output_format,
+        "strategy": strategy,
+        "max_clips": max_clips,
+        "min_duration": min_duration,
+        "max_duration": max_duration,
+        "manual_start": manual_start,
+        "manual_end": normalized_end,
+        "rights_confirmed": True,
+    }
+
+
+def plan_segments(
+    duration: float | None,
+    *,
+    strategy: str,
+    max_clips: int,
+    min_duration: float,
+    max_duration: float,
+    manual_start: float = 0.0,
+    manual_end: float | None = None,
+) -> list[dict[str, float]]:
+    if strategy == "manual":
+        if manual_end is None or manual_end <= manual_start:
+            raise CutsError("No modo manual, o fim deve ser superior ao início.")
+        return [{"index": 1, "start": round(float(manual_start), 3), "end": round(float(manual_end), 3), "duration": round(float(manual_end - manual_start), 3)}]
+    if duration is None or duration <= 0:
+        raise CutsError("Não foi possível detectar a duração do vídeo. Use o modo manual ou instale/configure FFprobe.")
+    if duration < min_duration:
+        raise CutsError(f"O vídeo tem apenas {duration:.1f}s e é menor que a duração mínima configurada.")
+    count = min(int(max_clips), max(1, int(duration // min_duration)))
+    clip_duration = min(float(max_duration), max(float(min_duration), duration / count))
+    if clip_duration > duration:
+        clip_duration = duration
+    if count == 1:
+        starts = [0.0]
+    else:
+        starts = [(duration - clip_duration) * index / (count - 1) for index in range(count)]
+    return [
+        {"index": index + 1, "start": round(start, 3), "end": round(min(duration, start + clip_duration), 3), "duration": round(min(duration, start + clip_duration) - start, 3)}
+        for index, start in enumerate(starts)
+    ]
+
+
+def _video_filter(output_format: str) -> str:
+    dimensions = OUTPUT_FORMATS[normalize_output_format(output_format)]
+    width = dimensions["width"]
+    height = dimensions["height"]
+    return f"scale={width}:{height}:force_original_aspect_ratio=decrease,pad={width}:{height}:(ow-iw)/2:(oh-ih)/2"
+
+
+def build_clip_command(source: Path, output: Path, segment: dict[str, float], output_format: str, *, ffmpeg_path: str) -> list[str]:
+    start = max(0.0, float(segment["start"]))
+    duration = max(0.1, float(segment["duration"]))
+    return [
+        ffmpeg_path,
+        "-y",
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-ss",
+        f"{start:.3f}",
+        "-t",
+        f"{duration:.3f}",
+        "-i",
+        str(source),
+        "-map",
+        "0:v:0",
+        "-map",
+        "0:a?",
+        "-vf",
+        _video_filter(output_format),
+        "-c:v",
+        "libx264",
+        "-preset",
+        "veryfast",
+        "-crf",
+        "22",
+        "-c:a",
+        "aac",
+        "-movflags",
+        "+faststart",
+        str(output),
+    ]
+
+
+def _run_ffmpeg(command: list[str], output: Path, *, source: Path, segment: dict[str, float]) -> dict[str, Any]:
+    try:
+        completed = subprocess.run(command, capture_output=True, text=True, check=False)
+    except OSError as exc:
+        raise CutsError(f"Não foi possível iniciar FFmpeg: {exc}") from exc
+    if completed.returncode != 0 or not output.is_file() or output.stat().st_size == 0:
+        if output.exists():
+            output.unlink()
+        detail = (completed.stderr or completed.stdout or "erro desconhecido").strip()
+        raise CutsError(f"O clip não pôde ser gerado: {detail[-1200:]}")
+    return {"source": str(source), "output": str(output), "command": command, "segment": segment, "created_at": _now()}
+
+
+def _write_manifest(record: dict[str, Any], run_dir: Path) -> Path:
+    path = run_dir / "manifest.json"
+    path.write_text(json.dumps(record, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    return path
+
+
+def generate_clips(
+    source: Path,
+    *,
+    output_format: str,
+    strategy: str,
+    max_clips: int,
+    min_duration: float,
+    max_duration: float,
+    rights_confirmed: bool,
+    ffmpeg_path: str | None = None,
+    manual_start: float = 0.0,
+    manual_end: float | None = None,
+) -> dict[str, Any]:
+    request = validate_cut_request(
+        source=source,
+        output_format=output_format,
+        strategy=strategy,
+        max_clips=max_clips,
+        min_duration=min_duration,
+        max_duration=max_duration,
+        rights_confirmed=rights_confirmed,
+        manual_start=manual_start,
+        manual_end=manual_end,
+    )
+    duration = probe_duration(source)
+    segments = plan_segments(
+        duration,
+        strategy=strategy,
+        max_clips=max_clips,
+        min_duration=min_duration,
+        max_duration=max_duration,
+        manual_start=manual_start,
+        manual_end=manual_end,
+    )
+    run_id = f"cut_{datetime.now().strftime('%Y%m%d-%H%M%S')}_{uuid.uuid4().hex[:8]}"
+    run_dir = _runs_root() / run_id
+    run_dir.mkdir(parents=True, exist_ok=True)
+    record: dict[str, Any] = {
+        "id": run_id,
+        "created_at": _now(),
+        "status": "processing",
+        "source": request["source"],
+        "source_name": request["source_name"],
+        "source_duration": duration,
+        "output_format": output_format,
+        "strategy": strategy,
+        "parameters": {key: value for key, value in request.items() if key not in {"source", "source_name"}},
+        "clips": [],
+        "error": "",
+    }
+    try:
+        binary = resolve_ffmpeg(ffmpeg_path)
+        for segment in segments:
+            output = run_dir / f"clip-{int(segment['index']):02d}-{_safe_filename(source.stem, 'video')}-{output_format.replace(':', 'x')}.mp4"
+            command = build_clip_command(source, output, segment, output_format, ffmpeg_path=binary)
+            run_info = _run_ffmpeg(command, output, source=source, segment=segment)
+            record["clips"].append({
+                "index": int(segment["index"]),
+                "path": str(output),
+                "name": output.name,
+                "start": segment["start"],
+                "end": segment["end"],
+                "duration": segment["duration"],
+                "size_bytes": output.stat().st_size,
+                "command": run_info["command"],
+            })
+        record["status"] = "complete"
+    except (CutsError, OSError, ValueError) as exc:
+        record["status"] = "error"
+        record["error"] = str(exc)
+    _write_manifest(record, run_dir)
+    storage.append_json("cuts_runs.json", record)
+    if record["status"] == "error":
+        raise CutsError(record["error"])
+    return record
+
+
+def list_runs() -> list[dict[str, Any]]:
+    records = storage.read_json("cuts_runs.json", [])
+    return list(reversed(records)) if isinstance(records, list) else []
+
+
+def manifest_bytes(record: dict[str, Any]) -> bytes:
+    return (json.dumps(record, ensure_ascii=False, indent=2) + "\n").encode("utf-8")
+
+
+def zip_run(record: dict[str, Any]) -> tuple[Path, bytes]:
+    run_id = _safe_filename(str(record.get("id") or "run"), "run")
+    run_dir = _runs_root() / run_id
+    if not run_dir.is_dir():
+        raise CutsError("A execução seleccionada já não existe no storage local.")
+    archive = run_dir / f"{run_id}.zip"
+    with zipfile.ZipFile(archive, "w", compression=zipfile.ZIP_DEFLATED) as handle:
+        for clip in record.get("clips", []):
+            path = Path(str(clip.get("path") or ""))
+            if path.is_file() and run_dir.resolve() in path.resolve().parents:
+                handle.write(path, arcname=path.name)
+        manifest = run_dir / "manifest.json"
+        if manifest.is_file():
+            handle.write(manifest, arcname=manifest.name)
+    return archive, archive.read_bytes()
+
+
+def download_direct_video_url(url: str, *, timeout: int = 30) -> Path:
+    parsed = urlparse(str(url).strip())
+    if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+        raise CutsError("Informe uma URL HTTP/HTTPS directa para um ficheiro de vídeo.")
+    try:
+        response = requests.get(url, stream=True, timeout=timeout, headers={"User-Agent": "Thunderbolt/0.2"})
+        response.raise_for_status()
+    except requests.RequestException as exc:
+        raise CutsError(f"Não foi possível descarregar a URL do vídeo: {exc}") from exc
+    content_length = _safe_float(response.headers.get("content-length"), 0.0)
+    if content_length > MAX_SOURCE_BYTES:
+        raise CutsError("A fonte excede o limite de 500 MB.")
+    suffix = Path(parsed.path).suffix.lower()
+    if suffix not in VIDEO_SUFFIXES:
+        content_type = str(response.headers.get("content-type") or "").lower()
+        suffix = ".mp4" if "mp4" in content_type or "video" in content_type else ""
+    if suffix not in VIDEO_SUFFIXES:
+        raise CutsError("A URL deve apontar para um ficheiro de vídeo MP4, MOV ou formato suportado.")
+    digest = hashlib.sha256(url.encode("utf-8")).hexdigest()[:16]
+    target = _inputs() / f"{digest}-url{suffix}"
+    if target.exists():
+        return target.resolve()
+    total = 0
+    temporary = target.with_suffix(target.suffix + ".part")
+    try:
+        with temporary.open("wb") as handle:
+            for chunk in response.iter_content(chunk_size=1024 * 1024):
+                if not chunk:
+                    continue
+                total += len(chunk)
+                if total > MAX_SOURCE_BYTES:
+                    raise CutsError("A fonte excede o limite de 500 MB.")
+                handle.write(chunk)
+        temporary.replace(target)
+    except CutsError:
+        temporary.unlink(missing_ok=True)
+        raise
+    except OSError as exc:
+        temporary.unlink(missing_ok=True)
+        raise CutsError(f"Não foi possível guardar o vídeo descarregado: {exc}") from exc
+    return target.resolve()

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,

package/package.json

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