@danhachuel/thunderbolt 0.3.67 → 0.3.69

package/MANUAL-INSTALACAO.md

@@ -2,7 +2,7 @@
 
 Este manual descreve a instalação local da UI Thunderbolt, baseada no MoneyPrinterTurbo, utilizando o pacote npm `@danhachuel/thunderbolt`. O fluxo recomendado instala automaticamente o ambiente Python, as dependências da aplicação, as dependências do MoneyPrinterTurbo, o Streamlit e o suporte FFmpeg através de `imageio-ffmpeg`.
 
-> **Versão deste manual:** 0.3.67
+> **Versão deste manual:** 0.3.69
 > **Pacote npm:** `@danhachuel/thunderbolt`
 > **Porta padrão da UI:** `localhost:3030`  
 > **Repositório:** [github.com/DanHachuel/thunderbolt](https://github.com/DanHachuel/thunderbolt)
@@ -31,9 +31,9 @@ O MoneyPrinterTurbo declara Python 3.11 ou superior como requisito e documenta a
 
 A área **AI Influencers > Personagens** permite criar personagens com nome, biografia, idioma, Instagram Business ID opcional, várias imagens de referência e ficheiros `.md`/`.json`. O campo **Idioma** é um selector e reutiliza exactamente a mesma lista, os códigos e os labels visuais de **Pipeline Vídeos > Criação de Vídeos**. No uploader, seleccione vários ficheiros de uma vez; cada imagem pode ser pré-visualizada e cada documento é validado como UTF-8, Markdown ou JSON válido. Os assets são deduplicados por SHA-256 e não são gravados como base64 dentro das tabelas.
 
-O backend local predefinido é **SQLite**, pelo que Personagens e Geração de Conteúdo IA podem ser usados sem credenciais externas. Abra **Configurações > Configuração API > AI Influencers > Banco de Dados Influencers** para confirmar **SQLite** ou seleccionar **Supabase**. Se seleccionar Supabase, preencha **Supabase Project URL**, **Supabase API key** e **Supabase Storage bucket**, clique em **Testar ligação do backend**, aplique primeiro `seed/references/ai_influencers_schema.sql` no SQL Editor do projecto, exponha as quatro tabelas na Data API e configure permissões/RLS adequadas. O bucket deve existir com o nome configurado, por defeito `ai-influencers`.
+O backend local predefinido é **SQLite**, pelo que Personagens e Geração de Conteúdo IA podem ser usados sem credenciais externas. Em **Configurações > Configuração API > AI Influencers**, o selector **Backend da base de dados de AI Influencers** fica imediatamente abaixo da frase de estado. O card foi renomeado para **Supabase** e contém apenas **Supabase Project URL** e **Supabase API key**. Se seleccionar Supabase mas faltar qualquer uma dessas credenciais, o **Backend activo** permanece automaticamente em SQLite; só muda para Supabase quando ambas estão configuradas. Clique em **Testar ligação do backend** e, para uma base remota, aplique primeiro `seed/references/ai_influencers_schema.sql` no SQL Editor do projecto, exponha as quatro tabelas na Data API e configure permissões/RLS adequadas.
 
-Se pretender trabalhar sem serviço externo, seleccione **SQLite** no selector da aba **Configuração API > AI Influencers** e indique o caminho do ficheiro. O padrão é `storage/state/ai_influencers.db`; o SQLite cria o schema e guarda os assets em `storage/influencers/`. Apenas um backend é usado de cada vez. A aba **AI Influencers** mostra o estado e permite editar directamente o selector, os campos Supabase e o caminho SQLite. A base fica na pasta persistente do Thunderbolt, fora da instalação temporária do pacote npm; numa actualização normal, personagens, assets e configurações são preservados. O instalador também procura uma base `ai_influencers.db` válida em instalações anteriores do cache npm e recupera-a sem substituir uma base persistente já existente.
+Se pretender trabalhar sem serviço externo, seleccione **SQLite** no selector da aba **Configuração API > AI Influencers**. O caminho `storage/state/ai_influencers.db` e a pasta `storage/influencers/` são geridos internamente, sem campos editáveis para o utilizador. Apenas um backend é usado de cada vez. A base fica na pasta persistente do Thunderbolt, fora da instalação temporária do pacote npm; numa actualização normal, personagens, assets e configurações são preservados. O instalador também procura uma base `ai_influencers.db` válida em instalações anteriores do cache npm e recupera-a sem substituir uma base persistente já existente.
 
 Em **AI Influencers > Geração de Conteúdo IA**, utilize as subabas **Imagens**, **Vídeos** e **Motion Control**. Seleccione um personagem, prompt e destinos sociais. A subaba **Imagens** usa o pool de imagem configurado em **Imagem e Video**. A subaba **Vídeos** requer uma imagem inicial e usa o pool de vídeo; escolha o provider/modelo no cartão configurado, sem dependência obrigatória do Veo 3.1. KIE AI, Replicate e FAL AI podem usar tarefas assíncronas; o Thunderbolt consulta o estado e guarda o resultado local antes da revisão. Na Replicate, o campo Modelo deve ser o identificador do modelo ou da versão, e os inputs específicos dependem do modelo configurado.
 
@@ -128,13 +128,13 @@ Execute:
 Windows PowerShell ou MobaXterm:
 
 ```powershell
-npx.cmd --yes --prefer-online @danhachuel/thunderbolt@0.3.67 install
+npx.cmd --yes --prefer-online @danhachuel/thunderbolt@0.3.69 install
 ```
 
 Linux/macOS:
 
 ```bash
-npx --yes --prefer-online @danhachuel/thunderbolt@0.3.67 install
+npx --yes --prefer-online @danhachuel/thunderbolt@0.3.69 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.
@@ -142,7 +142,7 @@ A instalação normal é **segura para actualizações**: preserva `storage`, Bl
 Se quiser apagar absolutamente tudo de forma intencional, use o comando destrutivo separado:
 
 ```powershell
-npx.cmd --yes --prefer-online @danhachuel/thunderbolt@0.3.67 install --purge-data
+npx.cmd --yes --prefer-online @danhachuel/thunderbolt@0.3.69 install --purge-data
 ```
 
 O parâmetro `--purge-data` apaga Blueprints, Brandings, configurações, storage e artefactos locais. Não o use numa actualização normal.
@@ -405,7 +405,7 @@ O botão de teste é read-only. Sem um token OAuth TikTok já autorizado, o Thun
 
 Na criação de vídeo, abra **Configurações de áudio** e escolha **Upload** em **Modo de narração**. Use **Ficheiro de narração** para seleccionar o áudio, clique em **Guardar áudio de narração** e confirme a pré-visualização. O Thunderbolt valida que o ficheiro existe antes de criar a tarefa e encaminha o caminho ao MoneyPrinterTurbo com `--custom-audio-file`; este argumento é necessário porque o motor não persiste automaticamente o caminho carregado. São aceites ficheiros `.mp3`, `.wav`, `.m4a`, `.aac`, `.flac` e `.ogg`, guardados no storage local em `voiceovers`.
 
-O selector **Voiceover Service** oferece **Azure Speech SDK V2** e **Azure TTS V1**. Quando existe **Azure Speech key + região**, a opção V2 é preferida e o worker marca internamente a voz com `-V2`, activando o SDK Azure Speech e evitando o stream `edge_tts`. Tarefas antigas que ainda tenham `Azure TTS V1` guardado também são migradas para V2 quando essas credenciais estão configuradas. Sem credenciais Azure, o V1 continua disponível como fallback sem key; nesse caso o timeout interno do stream passa a 90 segundos para tolerar scripts longos e redes lentas. Um erro de TTS identifica explicitamente **Azure Speech / edge_tts API**, a etapa **Narração TTS** e os providers envolvidos.
+O selector **Voiceover Service** oferece **Azure Speech SDK V2** e **Azure TTS V1**. Quando existe **Azure Speech key + região**, a opção V2 é preferida e o worker marca internamente a voz com `-V2`, activando o SDK Azure Speech e evitando o stream `edge_tts`. Para roteiros longos, o helper divide automaticamente o texto em segmentos seguros, sintetiza cada segmento com retry e concatena o MP3 antes de o entregar ao MoneyPrinterTurbo como `--custom-audio-file`; isto evita o limite de 10 minutos da síntese em tempo real documentado pela [Microsoft](https://learn.microsoft.com/en-us/azure/ai-services/speech-service/speech-services-quotas-and-limits). Tarefas antigas que ainda tenham `Azure TTS V1` guardado também são migradas para V2 quando essas credenciais estão configuradas. Sem credenciais Azure, o V1 continua disponível como fallback sem key; nesse caso o timeout interno do stream passa a 90 segundos para tolerar scripts longos e redes lentas. O erro `1007`/`600000ms` é atribuído explicitamente à **Azure Speech SDK V2 API**, à etapa **Narração TTS** e ao limite de duração.
 
 As notificações novas são verificadas automaticamente na sessão activa e aparecem como pop-ups no canto inferior direito, mesmo quando está aberta outra página. O pop-up não marca o registo como lido: a aba **Notificações** continua a ser o centro persistente para consultar o histórico, gerir preferências e marcar eventos como lidos. Cada ID é apresentado no máximo uma vez por sessão do navegador.
 
@@ -568,7 +568,7 @@ Ao abrir a página, o Thunderbolt não prepara dados públicos, não descarrega
 
 Os parâmetros da UI são número de clusters entre 2 e 10, suporte mínimo entre 0,01 e 0,50, país, engagement, intervalo de datas e tags, todos dentro da área principal da aba. O núcleo normaliza os dados, calcula engagement, aplica filtros, faz transformação logarítmica e standardização, executa K-Means e calcula itemsets/regras com FP-Growth. Não são apresentados resultados até ao primeiro clique em **Analisar Nichos**; o mesmo botão aplica alterações posteriores aos filtros. Os resultados são DataFrames de clusters, itemsets frequentes, regras de associação e dados analisados; o gráfico de dispersão é criado nativamente com Plotly.
 
-As dependências adicionais — `scikit-learn`, `mlxtend`, `plotly`, `seaborn`, `matplotlib` e `kagglehub` — são instaladas pelo procedimento normal de `npx`. Em instalações existentes, execute novamente `npx.cmd --yes --prefer-online @danhachuel/thunderbolt@0.3.67 install`; o instalador detecta e reutiliza o que já estiver válido.
+As dependências adicionais — `scikit-learn`, `mlxtend`, `plotly`, `seaborn`, `matplotlib` e `kagglehub` — são instaladas pelo procedimento normal de `npx`. Em instalações existentes, execute novamente `npx.cmd --yes --prefer-online @danhachuel/thunderbolt@0.3.69 install`; o instalador detecta e reutiliza o que já estiver válido.
 
 ### Niche Finder Apify
 

package/README.md

@@ -32,7 +32,7 @@ A primeira versão implementa a camada UI independente com:
 
 A área **AI Influencers > Personagens** permite guardar um personagem com nome, biografia, idioma, Instagram Business ID opcional, várias imagens de referência e documentos `.md` ou `.json`. O campo **Idioma** é um selector que reutiliza exactamente a lista, os códigos e os labels visuais de **Pipeline Vídeos > Criação de Vídeos**. Cada asset é validado, sanitizado, deduplicado por SHA-256 e guardado separado do perfil; imagens têm pré-visualização e documentos são mostrados como Markdown ou JSON estruturado.
 
-O backend local predefinido é **SQLite**, por isso Personagens e Geração de Conteúdo IA funcionam imediatamente sem credenciais externas. Em **Configurações > Configuração API > AI Influencers > Banco de Dados Influencers**, pode manter **SQLite** ou seleccionar **Supabase** quando quiser uma base remota; nesse caso, configure o **Supabase Project URL**, a **Supabase API key** e o bucket de Storage, aplique `seed/references/ai_influencers_schema.sql` no SQL Editor e confirme Data API/RLS. SQLite cria localmente `storage/state/ai_influencers.db` e `storage/influencers/`; apenas um backend fica activo de cada vez. A aba **AI Influencers** mostra o estado actual e permite editar directamente o selector, as credenciais Supabase, o bucket de Storage e o caminho do SQLite. O botão **Testar ligação do backend** é read-only e não bloqueia a utilização local. A base SQLite fica na pasta persistente do Thunderbolt, fora da instalação temporária do pacote npm; durante uma actualização normal, personagens, assets e configurações são preservados. Se uma versão anterior tiver guardado `ai_influencers.db` no cache npm, o instalador procura uma cópia válida e recupera-a sem substituir uma base persistente já existente.
+O backend local predefinido é **SQLite**, por isso Personagens e Geração de Conteúdo IA funcionam imediatamente sem credenciais externas. Em **Configurações > Configuração API > AI Influencers**, o selector **Backend da base de dados de AI Influencers** aparece logo abaixo do estado do backend. O card **Supabase** contém apenas **Supabase Project URL** e **Supabase API key**. Se **Supabase** estiver seleccionado mas faltar qualquer uma dessas credenciais, o **Backend activo** muda automaticamente para **SQLite**; quando ambas estão preenchidas, passa para Supabase. O SQLite usa internamente `storage/state/ai_influencers.db` e `storage/influencers/`, sem campos editáveis de caminho ou Storage bucket. O botão **Testar ligação do backend** é read-only e não bloqueia a utilização local. A base SQLite fica na pasta persistente do Thunderbolt, fora da instalação temporária do pacote npm; durante uma actualização normal, personagens, assets e configurações são preservados. Se uma versão anterior tiver guardado `ai_influencers.db` no cache npm, o instalador procura uma cópia válida e recupera-a sem substituir uma base persistente já existente.
 
 A página **AI Influencers > Geração de Conteúdo IA** contém as subabas **Imagens**, **Vídeos** e **Motion Control**. Imagens usam os cartões activos do **Pool Imagem**; Vídeos usam os cartões activos do **Pool Vídeo** e exigem uma imagem inicial image-to-video. O selector de modelo não está preso ao Veo 3.1: pode utilizar KIE AI, Replicate, FAL AI, Pollinations ou outro cartão que declare suporte para vídeo. Para Replicate, o campo Modelo deve conter o identificador aceito pela API, como `owner/model` ou `owner/model:version`; a tarefa usa `POST /v1/predictions`, consulta o estado assíncrono e guarda o resultado localmente. A publicação para Instagram, TikTok, YouTube Shorts ou Facebook não é automática: os destinos são registados para revisão e o envio exige uma acção posterior explícita.
 
@@ -44,7 +44,7 @@ Em **Pipeline Vídeos > Criação de Vídeos** e **Automação Youtube**, a opç
 
 A ordem persistida da criação é **Tema → Script → Título → Keywords opcional → Vídeo → Prompt Thumbnail em JSON → Thumbnail → Upload**. O vídeo é materializado antes do prompt e da imagem da thumbnail; uma falha posterior de thumbnail não invalida um MP4 já pronto. **Full IA** é uma rota separada e usa o pool de vídeo configurável com **FAL AI, KIE AI, Agnes AI, Nano Banana, Replicate AI, Pollinations.ai, Hugging Face Inference API, InferencePort Proxy e HeyGen**, respeitando apenas cartões activos que declarem capacidade de vídeo. **Apenas Música** não chama a pipeline de vídeo nem tenta gerar thumbnail: reutiliza o áudio local/Suno já descarregado e deixa-o pronto para a integração de upload musical.
 
-Quando uma etapa falha, a tarefa, a notificação e a página **Configurações > Logs** guardam e mostram sempre a coluna **API/Provider**, o serviço, a rota e, quando aplicável, os campos de configuração em falta. No caso do MoneyPrinterTurbo, os marcadores `LLM_PROVIDER`, `MISSING` e `INVALID` são convertidos em attribution legível; por exemplo, um erro pode indicar simultaneamente **OpenAI / NVIDIA NIM API** e **Pexels API**, em vez de apresentar apenas a mensagem genérica de credenciais adicionais. Os timeouts `azure_tts_v1`/`edge_tts` são identificados como **Azure Speech / edge_tts API**. Quando há Azure Speech key e região, o worker encaminha a voz para o SDK Azure Speech V2; sem essas credenciais, o fallback edge_tts usa um timeout interno de 90 segundos. O worker invoca o helper com `--` antes das flags MoneyPrinterTurbo, porque `mpt_agent.py` reserva esses argumentos para a CLI filha. Registos históricos sem metadata são identificados explicitamente como anteriores à attribution estruturada.
+Quando uma etapa falha, a tarefa, a notificação e a página **Configurações > Logs** guardam e mostram sempre a coluna **API/Provider**, o serviço, a rota e, quando aplicável, os campos de configuração em falta. No caso do MoneyPrinterTurbo, os marcadores `LLM_PROVIDER`, `MISSING` e `INVALID` são convertidos em attribution legível; por exemplo, um erro pode indicar simultaneamente **OpenAI / NVIDIA NIM API** e **Pexels API**, em vez de apresentar apenas a mensagem genérica de credenciais adicionais. Os timeouts `azure_tts_v1`/`edge_tts` são identificados como **Azure Speech / edge_tts API**. Quando há Azure Speech key e região, o worker encaminha a voz para o SDK Azure Speech V2. Para evitar o limite de 10 minutos da síntese em tempo real documentado pela [Microsoft](https://learn.microsoft.com/en-us/azure/ai-services/speech-service/speech-services-quotas-and-limits), o helper divide o roteiro em segmentos seguros, sintetiza-os sequencialmente com retry e concatena o MP3 antes de o entregar ao MoneyPrinterTurbo como áudio customizado. O erro `1007`/`600000ms` é atribuído explicitamente à **Azure Speech SDK V2 API**. Sem credenciais Azure, o fallback edge_tts usa um timeout interno de 90 segundos. O worker invoca o helper com `--` antes das flags MoneyPrinterTurbo, porque `mpt_agent.py` reserva esses argumentos para a CLI filha. Registos históricos sem metadata são identificados explicitamente como anteriores à attribution estruturada.
 
 Na subaba **Configuração API > API Keys > Imagem e Video**, o selector **Provider de media** inclui a mesma lista do pool Full IA. O cartão **HeyGen** usa a API V3, apresenta os campos **Avatar ID** e **Voice ID**, valida a credencial com uma chamada read-only e participa no failover de vídeo quando estiver activo e configurado. Nano Banana e Hugging Face permanecem disponíveis no catálogo; a participação efectiva no pool de vídeo depende da capacidade declarada pelo cartão, para não encaminhar vídeo para um endpoint que apenas suporte imagem.
 

package/app/influencers_ui.py

@@ -103,9 +103,7 @@ def _provider_label(card: Mapping[str, Any]) -> str:
 
 
 def render_ai_influencers_api_status(settings: dict[str, Any]) -> None:
-    """Show backend status; editable selector and credentials are rendered by the settings page."""
-    st.subheader("AI Influencers")
-    st.caption("Estado do backend usado por Personagens e Geração de Conteúdo IA. O selector e as credenciais são editados nesta aba, em Banco de Dados Influencers.")
+    """Show the effective backend status after selector and credentials are loaded."""
     status = backend_status(settings)
     cols = st.columns(3)
     with cols[0]:
@@ -118,7 +116,7 @@ def render_ai_influencers_api_status(settings: dict[str, Any]) -> None:
         st.info(f"{status['message']} Destino: `{status['target']}`")
     else:
         st.warning(status["message"])
-    st.markdown("A migração SQL idempotente está disponível em `seed/references/ai_influencers_schema.sql`. No Supabase, aplique-a no SQL Editor e confirme as políticas RLS e o bucket configurado.")
+    st.markdown("A migração SQL idempotente está disponível em `seed/references/ai_influencers_schema.sql`. No Supabase, aplique-a no SQL Editor e confirme as políticas RLS.")
     if st.button("Testar backend AI Influencers", key="influencers_api_status_test"):
         result = test_backend(settings)
         if result.get("ok"):

package/app/main.py

@@ -5762,34 +5762,36 @@ def render_settings():
         render_material_source_api_keys(settings)
 
     with ai_influencers_tab:
-        render_ai_influencers_api_status(settings)
-        st.divider()
-        st.subheader("Banco de Dados Influencers")
-        st.caption("Escolha o backend usado por Personagens e Geração de Conteúdo IA. SQLite local funciona sem credenciais externas; Supabase é opcional. Se Supabase estiver seleccionado mas ainda incompleto, o sistema mantém SQLite como fallback operacional.")
-        with st.form("influencer_database_settings_form"):
-            saved_backend = str(settings.get("influencer_db_backend") or "SQLite").strip()
-            backend_index = list(BACKEND_OPTIONS).index(saved_backend) if saved_backend in BACKEND_OPTIONS else list(BACKEND_OPTIONS).index("SQLite")
-            influencer_db_backend = st.selectbox(
-                "Backend da base de dados de AI Influencers",
-                list(BACKEND_OPTIONS),
-                index=backend_index,
-                key="settings_influencer_db_backend",
-                help="Seleccione Supabase para usar a base remota ou SQLite para guardar tudo localmente.",
-            )
-            db_cols = st.columns(2)
-            with db_cols[0]:
-                influencer_supabase_url = text_setting("Supabase Project URL", "influencer_supabase_url", help_text="URL do projecto, por exemplo https://project-id.supabase.co")
-                influencer_supabase_key = text_setting("Supabase API key", "influencer_supabase_key", secret=True, help_text="Use uma chave com as permissões RLS adequadas. Nunca é colocada no GitHub ou nos logs.")
-                influencer_supabase_bucket = text_setting("Supabase Storage bucket", "influencer_supabase_bucket", help_text="Bucket usado para imagens e documentos, por defeito ai-influencers.")
-            with db_cols[1]:
-                influencer_sqlite_path = text_setting("SQLite ficheiro local", "influencer_sqlite_path", help_text="Caminho absoluto ou relativo ao projecto. Por defeito: storage/state/ai_influencers.db")
-                st.caption("SQLite usa a biblioteca standard do Python e cria o schema automaticamente ao testar ou usar o backend.")
-            test_backend_clicked = st.form_submit_button("Testar ligação do backend", use_container_width=True)
-            save_backend_clicked = st.form_submit_button("Guardar configuração do backend", type="primary", use_container_width=True)
+        st.subheader("AI Influencers")
+        st.caption("Estado do backend usado por Personagens e Geração de Conteúdo IA. O selector e as credenciais são editados nesta aba, em Banco de Dados Influencers.")
+        saved_backend = str(settings.get("influencer_db_backend") or "SQLite").strip()
+        backend_index = list(BACKEND_OPTIONS).index(saved_backend) if saved_backend in BACKEND_OPTIONS else list(BACKEND_OPTIONS).index("SQLite")
+        influencer_db_backend = st.selectbox(
+            "Backend da base de dados de AI Influencers",
+            list(BACKEND_OPTIONS),
+            index=backend_index,
+            key="settings_influencer_db_backend",
+            help="Seleccione Supabase para usar a base remota ou SQLite para guardar tudo localmente.",
+        )
+        with st.container(border=True):
+            st.subheader("Supabase")
+            st.caption("Configure apenas os dados da ligação Supabase. Se o selector estiver em Supabase mas faltar qualquer credencial, o backend activo permanece SQLite.")
+            with st.form("influencer_database_settings_form"):
+                db_cols = st.columns(2)
+                with db_cols[0]:
+                    influencer_supabase_url = text_setting("Supabase Project URL", "influencer_supabase_url", help_text="URL do projecto, por exemplo https://project-id.supabase.co")
+                with db_cols[1]:
+                    influencer_supabase_key = text_setting("Supabase API key", "influencer_supabase_key", secret=True, help_text="Use uma chave com as permissões RLS adequadas. Nunca é colocada no GitHub ou nos logs.")
+                test_backend_clicked = st.form_submit_button("Testar ligação do backend", use_container_width=True)
+                save_backend_clicked = st.form_submit_button("Guardar configuração do backend", type="primary", use_container_width=True)
+        effective_settings = dict(settings)
+        effective_settings.update({
+            "influencer_db_backend": influencer_db_backend,
+            "influencer_supabase_url": influencer_supabase_url,
+            "influencer_supabase_key": influencer_supabase_key,
+        })
         if test_backend_clicked:
-            test_settings = dict(settings)
-            test_settings.update({"influencer_db_backend": influencer_db_backend, "influencer_supabase_url": influencer_supabase_url, "influencer_supabase_key": influencer_supabase_key, "influencer_supabase_bucket": influencer_supabase_bucket, "influencer_sqlite_path": influencer_sqlite_path})
-            db_result = test_backend(test_settings)
+            db_result = test_backend(effective_settings)
             if db_result.get("ok"):
                 st.success(db_result.get("message") or "Backend disponível.")
             else:
@@ -5799,12 +5801,11 @@ def render_settings():
                 "influencer_db_backend": influencer_db_backend,
                 "influencer_supabase_url": influencer_supabase_url.strip(),
                 "influencer_supabase_key": influencer_supabase_key.strip(),
-                "influencer_supabase_bucket": influencer_supabase_bucket.strip() or "ai-influencers",
-                "influencer_sqlite_path": influencer_sqlite_path.strip() or "storage/state/ai_influencers.db",
             })
             write_json("settings.json", settings)
             st.success("Configuração do backend AI Influencers guardada.")
             st.rerun()
+        render_ai_influencers_api_status(effective_settings)
 
     with voice_test_tab:
         st.subheader("Teste de Voz")

package/hermes_ui/pipeline_worker.py

@@ -308,6 +308,22 @@ def _provider_api_label(provider: str) -> str:
     return f"{provider_definition(code).label} API"
 
 
+def _is_azure_long_audio_error(text: str) -> bool:
+    combined = str(text or "").casefold()
+    duration_marker = any(
+        marker in combined
+        for marker in (
+            "600000ms",
+            "600000 ms",
+            "maximum media duration",
+            "maximum audio length",
+        )
+    )
+    code_marker = any(marker in combined for marker in ("error code: 1007", "error code=1007", "code 1007"))
+    speech_marker = any(marker in combined for marker in ("azure", "speech synthesis", "speech sdk", "tts"))
+    return speech_marker and (duration_marker or code_marker)
+
+
 def _failure_attribution(
     task: dict[str, Any],
     settings: dict[str, Any],
@@ -324,6 +340,16 @@ def _failure_attribution(
     provider_code = str(markers["helper_provider"] or "").strip().casefold()
     combined = f"{output} {error}".casefold()
 
+    if stage == "video" and _is_azure_long_audio_error(combined):
+        return {
+            "failure_api": "Azure Speech SDK V2 API",
+            "failure_provider": "azure_speech",
+            "failure_service": "Narração TTS — limite de 600000 ms",
+            "failure_route": route,
+            "failure_config_fields": "",
+            "failure_stage": stage,
+        }
+
     if stage == "video" and any(marker in combined for marker in ("edge_tts", "edge tts", "azure_tts_v1", "azure speech")):
         return {
             "failure_api": "Azure Speech / edge_tts API",

package/package.json

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

package/seed/skills/azure_tts_chunked.py

@@ -0,0 +1,187 @@
+"""Generate long Azure Speech V2 audio by synthesizing safe sequential chunks.
+
+This helper runs inside the MoneyPrinterTurbo uv project so it can use the
+same Azure Speech SDK and audio dependencies as the installed engine. Secrets
+are read only from environment variables and are never printed.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import re
+import shutil
+import sys
+import time
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from xml.sax.saxutils import escape
+
+
+MAX_CHUNK_CHARACTERS = 1800
+RETRY_COUNT = 3
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Synthesize Azure Speech V2 audio in safe chunks.")
+    parser.add_argument("--text-file", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--voice", required=True)
+    parser.add_argument("--rate", type=float, default=1.0)
+    return parser
+
+
+def _split_long_piece(piece: str, limit: int) -> list[str]:
+    piece = " ".join(piece.split())
+    if len(piece) <= limit:
+        return [piece]
+    words = piece.split(" ")
+    chunks: list[str] = []
+    current = ""
+    for word in words:
+        if len(word) > limit:
+            if current:
+                chunks.append(current)
+                current = ""
+            for start in range(0, len(word), limit):
+                chunks.append(word[start : start + limit])
+            continue
+        candidate = f"{current} {word}".strip()
+        if current and len(candidate) > limit:
+            chunks.append(current)
+            current = word
+        else:
+            current = candidate
+    if current:
+        chunks.append(current)
+    return chunks
+
+
+def split_text(text: str, limit: int = MAX_CHUNK_CHARACTERS) -> list[str]:
+    """Split paragraphs and sentences without sending a 10-minute request."""
+    normalized = re.sub(r"\r\n?", "\n", text).strip()
+    if not normalized:
+        return []
+    pieces = [part.strip() for part in re.split(r"\n+|(?<=[.!?。！？；;])\s+", normalized) if part.strip()]
+    chunks: list[str] = []
+    current = ""
+    for piece in pieces:
+        for fragment in _split_long_piece(piece, limit):
+            candidate = f"{current} {fragment}".strip()
+            if current and len(candidate) > limit:
+                chunks.append(current)
+                current = fragment
+            else:
+                current = candidate
+    if current:
+        chunks.append(current)
+    return chunks
+
+
+def _normalise_rate(value: float) -> float:
+    try:
+        rate = float(value)
+    except (TypeError, ValueError):
+        rate = 1.0
+    return max(0.25, min(4.0, rate))
+
+
+def _build_ssml(text: str, voice: str, rate: float) -> str:
+    locale = "-".join(voice.split("-", 2)[:2]) if len(voice.split("-", 2)) >= 2 else "en-US"
+    return (
+        '<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" '
+        f'xml:lang="{escape(locale)}">'
+        f'<voice name="{escape(voice, {"\"": "&quot;"})}">'
+        f'<prosody rate="{_normalise_rate(rate):g}">{escape(text)}</prosody>'
+        "</voice></speak>"
+    )
+
+
+def _synthesise_chunk(speechsdk, text: str, voice: str, rate: float, target: Path) -> None:
+    speech_key = os.environ.get("AZURE_SPEECH_KEY", "").strip()
+    region = os.environ.get("AZURE_SPEECH_REGION", "").strip()
+    if not speech_key or not region:
+        raise RuntimeError("Azure Speech SDK V2 requer AZURE_SPEECH_KEY e AZURE_SPEECH_REGION.")
+    speech_config = speechsdk.SpeechConfig(subscription=speech_key, region=region)
+    speech_config.speech_synthesis_voice_name = voice
+    speech_config.set_speech_synthesis_output_format(
+        speechsdk.SpeechSynthesisOutputFormat.Audio48Khz192KBitRateMonoMp3
+    )
+    audio_config = speechsdk.audio.AudioOutputConfig(filename=str(target), use_default_speaker=False)
+    synthesizer = speechsdk.SpeechSynthesizer(audio_config=audio_config, speech_config=speech_config)
+    try:
+        result = synthesizer.speak_ssml_async(_build_ssml(text, voice, rate)).get()
+    finally:
+        synthesizer.close()
+    if result.reason != speechsdk.ResultReason.SynthesizingAudioCompleted:
+        details = getattr(getattr(result, "cancellation_details", None), "error_details", "")
+        reason = str(details or getattr(result, "reason", "unknown"))
+        raise RuntimeError(f"Azure Speech SDK V2 não concluiu um segmento: {reason[:500]}")
+    if not target.is_file() or target.stat().st_size <= 0:
+        raise RuntimeError("Azure Speech SDK V2 terminou sem produzir o áudio do segmento.")
+
+
+def generate(text: str, voice: str, rate: float, output: Path) -> int:
+    import azure.cognitiveservices.speech as speechsdk
+    from pydub import AudioSegment
+
+    ffmpeg_binary = os.environ.get("IMAGEIO_FFMPEG_EXE", "").strip() or shutil.which("ffmpeg")
+    if not ffmpeg_binary:
+        try:
+            import imageio_ffmpeg
+
+            ffmpeg_binary = imageio_ffmpeg.get_ffmpeg_exe()
+        except Exception:
+            ffmpeg_binary = ""
+    if ffmpeg_binary:
+        AudioSegment.converter = ffmpeg_binary
+    else:
+        raise RuntimeError("FFmpeg não está disponível para concatenar os segmentos Azure Speech V2.")
+
+    chunks = split_text(text)
+    if not chunks:
+        raise RuntimeError("O roteiro não contém texto para síntese Azure Speech.")
+    output.parent.mkdir(parents=True, exist_ok=True)
+    with TemporaryDirectory(prefix="azure-v2-chunks-", dir=str(output.parent)) as temporary:
+        temporary_path = Path(temporary)
+        segment_paths: list[Path] = []
+        for index, chunk in enumerate(chunks, start=1):
+            segment_path = temporary_path / f"segment-{index:04d}.mp3"
+            last_error: Exception | None = None
+            for attempt in range(1, RETRY_COUNT + 1):
+                try:
+                    _synthesise_chunk(speechsdk, chunk, voice, rate, segment_path)
+                    last_error = None
+                    break
+                except Exception as exc:  # Azure SDK exposes provider-specific exception classes.
+                    last_error = exc
+                    if attempt < RETRY_COUNT:
+                        time.sleep(2 ** (attempt - 1))
+            if last_error is not None:
+                raise RuntimeError(f"Falha no segmento Azure Speech {index}/{len(chunks)}: {last_error}") from last_error
+            segment_paths.append(segment_path)
+
+        combined = AudioSegment.empty()
+        for segment_path in segment_paths:
+            combined += AudioSegment.from_file(segment_path, format="mp3")
+        combined.export(output, format="mp3", bitrate="192k")
+    if not output.is_file() or output.stat().st_size <= 0:
+        raise RuntimeError("A concatenação Azure Speech V2 não produziu áudio válido.")
+    return len(chunks)
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = _build_parser().parse_args(argv)
+    text = args.text_file.read_text(encoding="utf-8")
+    try:
+        count = generate(text, args.voice, args.rate, args.output)
+    except Exception as exc:
+        print(f"Azure Speech V2 chunked synthesis failed: {exc}", file=sys.stderr)
+        return 1
+    print(f"AZURE_CHUNKED_AUDIO={args.output.resolve()}")
+    print(f"AZURE_CHUNK_COUNT={count}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/seed/skills/mpt_agent.py

@@ -11,6 +11,7 @@ import shutil
 import subprocess
 import sys
 import tempfile
+import tomllib
 import urllib.error
 import urllib.request
 import uuid
@@ -299,6 +300,108 @@ def has_cli_option(cli_args: list[str], option: str) -> bool:
     return any(item == option or item.startswith(f"{option}=") for item in cli_args)
 
 
+def _toml_section_value(config_path: Path, section: str, key: str) -> str:
+    """Read one nested TOML value without logging the value or its contents."""
+    try:
+        payload = tomllib.loads(config_path.read_text(encoding="utf-8"))
+    except (OSError, tomllib.TOMLDecodeError):
+        return ""
+    section_payload = payload.get(section)
+    if not isinstance(section_payload, dict):
+        return ""
+    value = section_payload.get(key, "")
+    return str(value or "").strip()
+
+
+def _forwarded_option_value(cli_args: list[str], option: str) -> str:
+    for index, item in enumerate(cli_args):
+        if item == option and index + 1 < len(cli_args):
+            return str(cli_args[index + 1]).strip()
+        if item.startswith(f"{option}="):
+            return item.split("=", 1)[1].strip()
+    return ""
+
+
+def _azure_v2_voice(cli_args: list[str]) -> str:
+    """Return the unmarked Azure voice when this invocation requests Azure V2."""
+    voice = _forwarded_option_value(cli_args, "--voice-name")
+    if "-V2-" not in voice and not voice.endswith("-V2"):
+        return ""
+    base_voice = re.sub(r"-V2(?=-|$)", "", voice, count=1).strip()
+    return re.sub(r"-(?:Female|Male)$", "", base_voice, flags=re.IGNORECASE).strip()
+
+
+def _voice_rate(cli_args: list[str]) -> float:
+    value = _forwarded_option_value(cli_args, "--voice-rate")
+    try:
+        return float(value) if value else 1.0
+    except ValueError:
+        return 1.0
+
+
+def _prepare_azure_v2_chunked_audio(
+    root: Path,
+    config_path: Path,
+    task_dir: Path,
+    cli_args: list[str],
+    uv: str,
+) -> Path | None:
+    """Create task-local audio in chunks before MPT starts its normal pipeline."""
+    voice = _azure_v2_voice(cli_args)
+    text = _forwarded_option_value(cli_args, "--video-script")
+    if not voice or not text.strip():
+        return None
+    speech_key = _toml_section_value(config_path, "azure", "speech_key")
+    speech_region = _toml_section_value(config_path, "azure", "speech_region")
+    if not speech_key or not speech_region:
+        raise SkillError("Azure Speech SDK V2 foi seleccionado, mas as credenciais não estão completas.")
+    text_file = task_dir / "azure-v2-script.txt"
+    audio_file = task_dir / "azure-v2-audio.mp3"
+    text_file.parent.mkdir(parents=True, exist_ok=True)
+    text_file.write_text(text.strip(), encoding="utf-8")
+    chunk_script = Path(__file__).with_name("azure_tts_chunked.py")
+    command = [
+        uv,
+        "run",
+        "--project",
+        str(root),
+        "python",
+        str(chunk_script),
+        "--text-file",
+        str(text_file),
+        "--output",
+        str(audio_file),
+        "--voice",
+        voice,
+        "--rate",
+        str(_voice_rate(cli_args)),
+    ]
+    environment = os.environ.copy()
+    environment["AZURE_SPEECH_KEY"] = speech_key
+    environment["AZURE_SPEECH_REGION"] = speech_region
+    ffmpeg_path = _toml_section_value(config_path, "app", "ffmpeg_path")
+    if ffmpeg_path:
+        environment["IMAGEIO_FFMPEG_EXE"] = ffmpeg_path
+    log("synthesizing Azure Speech V2 in safe chunks before MoneyPrinterTurbo")
+    result = subprocess.run(
+        command,
+        cwd=root,
+        env=environment,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        errors="replace",
+        check=False,
+    )
+    if result.returncode != 0 or not audio_file.is_file() or audio_file.stat().st_size <= 0:
+        detail = "\n".join((result.stdout or "").splitlines()[-12:]).strip()
+        raise SkillError(
+            "Azure Speech SDK V2 falhou na síntese segmentada. "
+            + (detail or "O helper não devolveu detalhes.")
+        )
+    return audio_file
+
+
 def missing_config(config_path: Path, cli_args: list[str]) -> tuple[str, list[str]]:
     """Return the active provider and only the fields required by this run."""
     text = config_path.read_text(encoding="utf-8")
@@ -493,9 +596,11 @@ def generate_video(
     if not uv:
         raise SkillError("uv was not found; reopen the terminal or add uv to PATH")
     run_checked([uv, "sync", "--frozen"], cwd=root)
+    config_path = ensure_config(root)
 
     task_id = str(uuid.uuid4())
     task_dir = root / "storage" / "tasks" / task_id
+    task_dir.mkdir(parents=True, exist_ok=True)
     log_dir = root / ".agent-logs" / "moneyprinterturbo-video"
     log_dir.mkdir(parents=True, exist_ok=True)
     log_path = log_dir / f"run-{task_id}.log"
@@ -515,12 +620,23 @@ def generate_video(
         if has_cli_option(cli_args, "--voice-name")
         else ["--voice-name", DEFAULT_VOICE_NAME]
     )
+    forwarded_args = list(cli_args)
+    if not has_cli_option(forwarded_args, "--custom-audio-file"):
+        chunked_audio = _prepare_azure_v2_chunked_audio(
+            root,
+            config_path,
+            task_dir,
+            forwarded_args,
+            uv,
+        )
+        if chunked_audio is not None:
+            forwarded_args.extend(["--custom-audio-file", str(chunked_audio)])
     command = [
         uv,
         "run",
         "python",
         "cli.py",
-        *cli_args,
+        *forwarded_args,
         "--video-subject",
         subject,
         "--task-id",