@danhachuel/thunderbolt 0.3.76 → 0.3.78

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.76
+> **Versão deste manual:** 0.3.78
 > **Pacote npm:** `@danhachuel/thunderbolt`
 > **Porta padrão da UI:** `localhost:3030`  
 > **Repositório:** [github.com/DanHachuel/thunderbolt](https://github.com/DanHachuel/thunderbolt)
@@ -132,13 +132,13 @@ Execute:
 Windows PowerShell ou MobaXterm:
 
 ```powershell
-npx.cmd --yes --prefer-online @danhachuel/thunderbolt@0.3.76 install
+npx.cmd --yes --prefer-online @danhachuel/thunderbolt@0.3.77 install
 ```
 
 Linux/macOS:
 
 ```bash
-npx --yes --prefer-online @danhachuel/thunderbolt@0.3.76 install
+npx --yes --prefer-online @danhachuel/thunderbolt@0.3.77 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.
@@ -146,7 +146,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.76 install --purge-data
+npx.cmd --yes --prefer-online @danhachuel/thunderbolt@0.3.77 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.
@@ -574,7 +574,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.76 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.77 install`; o instalador detecta e reutiliza o que já estiver válido.
 
 ### Niche Finder Apify
 
@@ -811,3 +811,15 @@ O worker local guarda a etapa actual e os artefactos de cada tarefa. Ao reinicia
 
 ### Selector de modelos LLM
 No card **OpenAI / NVIDIA NIM**, o campo **Modelo** é uma lista suspensa. Use **Consultar modelos** para actualizar as opções do endpoint; se o identificador não estiver disponível, escolha **Escrever modelo manualmente**.
+
+## 16. Diagnóstico prioritário do Azure Speech V2
+
+Quando Azure Speech SDK V2 estiver seleccionado, o Thunderbolt prepara a narração em segmentos antes de iniciar o MoneyPrinterTurbo. O tamanho interno dos segmentos é reduzido automaticamente para velocidades de fala lentas, o áudio final é validado e a CLI recebe `--custom-audio-file`. A geração é bloqueada se não houver confirmação dos segmentos; isto evita regressar à chamada monolítica do Azure que pode falhar com `maximum media duration of 600000ms`.
+
+Na interface, uma tarefa em execução mostra a última actividade do helper e o tempo decorrido da etapa Vídeo. Se ocorrer uma falha, consulte o caminho `LOG_FILE` ou `RESULT_FILE` apresentado no erro. A linha `updated configuration fields` é apenas sincronização inicial de configuração e não é a causa terminal. Nunca copie chaves, cookies, tokens ou o conteúdo integral do roteiro para pedidos de suporte.
+
+## 17. Quando o card mostra apenas o início da falha de vídeo
+
+A partir da versão 0.3.78, o card **Backlog Vídeos** mostra a causa terminal e disponibiliza **Ver diagnóstico completo**. As mensagens `Pexels key validation completed`, `installing or verifying project dependencies with uv` e `TASK_DIR` são apenas progresso ou metadados; não são, por si só, uma falha.
+
+Se o `uv` falhar, o erro inclui o detalhe seguro do resolver. Se a CLI do MoneyPrinterTurbo falhar, o resumo inclui `MPT_ERROR` e mantém `Log completo` e `Manifesto`. A interface não exibe chaves, cookies ou tokens. O tempo limite da verificação de dependências é de 15 minutos; a etapa é encerrada em vez de ficar indefinidamente sem resposta.

package/README.md

@@ -107,7 +107,7 @@ No topo da área principal da aplicação existe o menu nativo de idioma no padr
 
 A UI suporta os temas **Dark** e **Light** através do menu nativo de três pontos do Streamlit, no local original do toolbar. Não existe um selector Theme adicional dentro da página. A configuração distribuída em `.streamlit/config.toml` disponibiliza as variantes nomeadas **Dark** e **Light**, e o menu nativo continua responsável por alternar entre os modos, seguindo o padrão do [MoneyPrinterTurbo](https://github.com/harry0703/MoneyPrinterTurbo). O CSS próprio do Thunderbolt usa cores semânticas, `currentColor` e `color-mix` para acompanhar o tema activo, sem alterar a posição nem a funcionalidade do toolbar, do botão Deploy e do menu principal.
 
-## Navegação da UI 0.3.76
+## Navegação da UI 0.3.77
 
 A barra lateral apresenta os níveis principais nesta ordem: **Início**, **Automação**, **Niche Finder**, **Canais/Perfis (Vídeos)**, **Pipeline Vídeos**, **Pipeline Música**, **AI Influencers**, **Edição**, **Growth**, **Documentação** e **Configurações**. **Canais/Perfis (Vídeos)** é expansível e contém **Canais YouTube**, **Blueprints Youtube**, **Contas TikTok**, **Prompt Masters** e **Facebook Pages**, nessa ordem. O menu **Arquivos Base** foi removido por ficar vazio.
 **Pipeline Vídeos** contém **Criação de Vídeos**, **Backlog Vídeos**, **Roteiros**, **Thumbnails** e **Upload**; **Pipeline Música** contém **Criação de Músicas** e **Upload Música**; **Automação** contém **Automação Youtube**; **Niche Finder** contém **Niche Finder Kaggle** e **Niche Finder Apify**; **AI Influencers** contém **Personagens**, **Geração de Conteúdo IA**, **Motion Control**, **UGC Products** e **Redes Sociais**. O Início reúne o dashboard e as filas do Pipeline, sem botões de acções rápidas.
@@ -426,3 +426,15 @@ A pipeline do worker usa agora um orquestrador local em cascata, com artefactos
 
 ## Selector de modelos LLM
 O campo **Modelo** em **Configuração API > API Keys > LLM — providers e modelos** é apresentado como lista suspensa permanente. A lista usa os modelos descobertos pelo endpoint e preserva o modelo guardado; a opção manual continua disponível apenas como fallback explícito.
+
+## Correcção prioritária de geração de vídeo
+
+No fluxo MoneyPrinterTurbo, a voz Azure Speech SDK V2 é preparada antes da CLI upstream. O Thunderbolt divide o roteiro em segmentos conservadores ajustados à velocidade, concatena o áudio localmente e só inicia o motor depois de confirmar o ficheiro e a contagem de segmentos. Se essa preparação falhar, a tarefa é interrompida e não existe fallback silencioso para uma chamada monolítica sujeita ao limite de 600000 ms.
+
+Durante a execução, o backlog mostra a actividade recente do helper e o tempo da etapa Vídeo. Em caso de falha, a mensagem terminal é extraída do output accionável, enquanto as linhas `using existing project` e `updated configuration fields` deixam de ser tratadas como causa. Os caminhos do log e do manifesto são preservados mesmo quando a falha ocorre antes da criação do MP4.
+
+## Correcção de diagnóstico da etapa Vídeo — 0.3.78
+
+A mensagem do card de vídeo deixou de mostrar apenas os primeiros 240 caracteres. A UI apresenta um resumo de erro com até 700 caracteres e disponibiliza um expander não editável com o diagnóstico completo, incluindo os caminhos do log e do manifesto quando existem. Linhas de sucesso de Pexels, sincronização do projecto, verificação do `uv` e marcadores de caminho são excluídas do resumo terminal.
+
+A verificação `uv sync --frozen` tem agora timeout controlado, detalhe seguro do resolver em caso de falha e confirmação explícita quando termina. O estado do manifesto é marcado como `failed` mesmo quando a falha acontece antes de a CLI do MoneyPrinterTurbo iniciar.

package/app/main.py

@@ -3582,8 +3582,25 @@ def _render_video_task_state(task: dict[str, Any]) -> None:
     st.write(state or "—")
     st.caption(VIDEO_TASK_STATE_LABELS.get(state, state.replace("_", " ").capitalize() or "Desconhecido"))
     st.progress(progress, text=f"{progress}%")
+    helper_status = str(task.get("video_helper_status") or "").strip()
+    if state == "doing" and helper_status:
+        st.caption(f"Actividade: {helper_status[-240:]}")
+    if state == "doing" and task.get("video_elapsed_seconds") is not None:
+        try:
+            elapsed_seconds = max(0, int(task.get("video_elapsed_seconds") or 0))
+            st.caption(f"Tempo da etapa Vídeo: {elapsed_seconds // 60}m {elapsed_seconds % 60:02d}s")
+        except (TypeError, ValueError):
+            pass
     if task.get("error"):
-        st.caption(str(task.get("error"))[:240])
+        error_text = str(task.get("error") or "").strip()
+        st.error(error_text[:700])
+        if len(error_text) > 700 or task.get("video_log") or task.get("video_result"):
+            with st.expander("Ver diagnóstico completo", expanded=False):
+                st.code(error_text[:6000])
+                if task.get("video_log"):
+                    st.caption(f"Log completo: {task.get('video_log')}")
+                if task.get("video_result"):
+                    st.caption(f"Manifesto: {task.get('video_result')}")
 
 
 def render_videos():

package/hermes_ui/pipeline_worker.py

@@ -310,12 +310,23 @@ def _helper_output_value(output: str, key: str) -> str:
 
 
 def _redact_helper_output(text: str) -> str:
-    for key in ("MPT_LLM_API_KEY", "MPT_PEXELS_API_KEY", "MPT_PIXABAY_API_KEY"):
+    for key in ("MPT_LLM_API_KEY", "MPT_PEXELS_API_KEY", "MPT_PIXABAY_API_KEY", "AZURE_SPEECH_KEY", "AZURE_SPEECH_REGION"):
         secret = os.environ.get(key, "").strip()
         if secret:
             text = text.replace(secret, "[redacted]")
     return text
 
+def _terminal_helper_detail(output: str) -> str:
+    """Return concise actionable failure lines, never startup or path markers."""
+    raw_lines = [_redact_helper_output(line).strip() for line in str(output or "").splitlines()]
+    lines = [line for line in raw_lines if line]
+    metadata_prefixes = ("TASK_DIR=", "LOG_FILE=", "RESULT_FILE=", "VIDEO_FILE=")
+    noise_markers = ("using existing project:", "updated configuration fields:", "starting video generation, task id:", "installing or verifying project dependencies with uv", "pexels key validation completed:")
+    useful = [line for line in lines if not line.startswith(metadata_prefixes) and not any(marker in line.casefold() for marker in noise_markers)]
+    failure_markers = ("mpt_error=", "traceback", "exception", "error", "failed", "falhou", "failure", "missing", "invalid", "timeout", "timed out", "not found", "exceeded", "excedeu")
+    failures = [line for line in useful if any(marker in line.casefold() for marker in failure_markers)]
+    return "\n".join((failures or useful)[-8:]).strip()
+
 
 def _helper_failure_markers(output: str) -> dict[str, Any]:
     missing = [item.strip() for item in re.findall(r"(?m)^MISSING=(.+)$", output) if item.strip()]
@@ -378,6 +389,16 @@ def _failure_attribution(
             "failure_stage": stage,
         }
 
+    if stage == "video" and any(marker in combined for marker in ("azure speech sdk v2", "azure speech v2", "azure_tts_v2")):
+        return {
+            "failure_api": "Azure Speech SDK V2 API",
+            "failure_provider": "azure_speech",
+            "failure_service": "Narração TTS — segmentação Azure",
+            "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",
@@ -504,12 +525,13 @@ def _failure_message(message: str, metadata: dict[str, Any]) -> str:
 
 
 def _persist_video_diagnostics(task: dict[str, Any], output: str) -> dict[str, str]:
-    """Persist only bounded helper diagnostics and return its declared file paths."""
+    """Persist bounded helper diagnostics and a safe terminal summary."""
     task_id = str(task.get("id") or "").strip()
     if not task_id:
         return {}
     log_file = _helper_output_value(output, "LOG_FILE")
     result_file = _helper_output_value(output, "RESULT_FILE")
+    terminal_detail = _terminal_helper_detail(output)
     try:
         markers = _helper_failure_markers(output)
         payload: dict[str, Any] = {
@@ -517,6 +539,7 @@ def _persist_video_diagnostics(task: dict[str, Any], output: str) -> dict[str, s
             "log_file": log_file,
             "result_file": result_file,
             "output_tail": _redact_helper_output(output[-6000:]),
+            "terminal_detail": terminal_detail,
             "helper_provider": markers["helper_provider"],
             "missing_fields": markers["missing_fields"],
             "invalid_fields": markers["invalid_fields"],
@@ -525,7 +548,10 @@ def _persist_video_diagnostics(task: dict[str, Any], output: str) -> dict[str, s
         current = _task_by_id(task_id) or task
         artifacts = dict(current.get("artifacts") or {})
         artifacts["video_diagnostics"] = artifact_path
-        updates: dict[str, Any] = {"artifacts": artifacts}
+        updates: dict[str, Any] = {
+            "artifacts": artifacts,
+            "video_diagnostic_summary": terminal_detail,
+        }
         if log_file:
             updates["video_log"] = log_file
             artifacts["video_log"] = log_file
@@ -707,10 +733,13 @@ def _moneyprinter_cli_args(task: dict[str, Any], route: str, settings: dict[str,
         args.append("--match-materials-to-script")
 
     voice_mode = str(generation_settings.get("voiceover_mode") or "").strip().casefold()
+    azure_service = str(generation_settings.get("voiceover_service") or "").strip().casefold()
     voice = str(task.get("voice") or generation_settings.get("voice") or "").strip()
     if voice_mode == "none" or voice_mode == "upload":
         args.extend(["--voice-name", "no-voice"])
-    elif voice:
+    elif voice or azure_service in {"azure speech sdk v2", "azure speech", "azure tts v2", "azure speech sdk"}:
+        if not voice:
+            voice = "en-US-JennyNeural"
         if _uses_azure_speech_sdk_v2(generation_settings, settings):
             voice = _azure_speech_v2_voice_name(voice)
         args.extend(["--voice-name", voice])
@@ -847,6 +876,7 @@ def _run_video_helper(task: dict[str, Any]) -> Path:
     reader.start()
     output_finished = False
     last_heartbeat = 0.0
+    last_output_line = ""
     try:
         while True:
             try:
@@ -854,6 +884,7 @@ def _run_video_helper(task: dict[str, Any]) -> Path:
                 if line is None:
                     output_finished = True
                 elif line:
+                    last_output_line = _redact_helper_output(line).strip()
                     output_lines.append(line)
             except queue.Empty:
                 pass
@@ -870,6 +901,7 @@ def _run_video_helper(task: dict[str, Any]) -> Path:
                 _update(
                     task_id,
                     progress=video_progress,
+                    video_helper_status=last_output_line[-500:] if last_output_line else "",
                     video_elapsed_seconds=int(elapsed),
                 )
                 _worker_heartbeat(
@@ -877,6 +909,7 @@ def _run_video_helper(task: dict[str, Any]) -> Path:
                     status="running",
                     stage="video",
                     progress=video_progress,
+                    video_helper_status=last_output_line[-500:] if last_output_line else "",
                     video_elapsed_seconds=int(elapsed),
                 )
                 last_heartbeat = elapsed
@@ -897,10 +930,13 @@ def _run_video_helper(task: dict[str, Any]) -> Path:
     _persist_video_diagnostics(task, output)
     if result_code == 10:
         metadata = _failure_attribution(task, settings, "video", output=output)
+        detail = _terminal_helper_detail(output)
         message = "A geração de vídeo precisa de credenciais adicionais do MoneyPrinterTurbo"
+        if detail:
+            message += f". Detalhe do helper: {detail}"
         raise PipelineError(_failure_message(message, metadata), failure_metadata=metadata)
     if result_code != 0:
-        detail = _redact_helper_output(output[-1200:]).strip() or "erro sem detalhes devolvidos pelo helper"
+        detail = _terminal_helper_detail(output) or "erro sem detalhes devolvidos pelo helper"
         metadata = _failure_attribution(task, settings, "video", error=detail, output=output)
         message = f"MoneyPrinterTurbo falhou na etapa Vídeo: {detail}"
         raise PipelineError(_failure_message(message, metadata), failure_metadata=metadata)

package/integrations/moneyprinter_config.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 from pathlib import Path
+import os
+import tempfile
 from typing import Any
 
 from hermes_ui.languages import language_code
@@ -177,6 +179,28 @@ def build_moneyprinter_config(settings: dict[str, Any], existing: dict[str, Any]
     return config
 
 
+def _atomic_write_text(target: Path, text: str) -> None:
+    """Replace TOML atomically so a failed write cannot truncate the prior file."""
+    temporary_path: Path | None = None
+    try:
+        with tempfile.NamedTemporaryFile(
+            mode="w", encoding="utf-8", dir=str(target.parent),
+            prefix=f".{target.name}.", suffix=".tmp", delete=False,
+        ) as handle:
+            temporary_path = Path(handle.name)
+            handle.write(text)
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(temporary_path, target)
+    except Exception:
+        if temporary_path is not None:
+            try:
+                temporary_path.unlink(missing_ok=True)
+            except OSError:
+                pass
+        raise
+
+
 def sync_moneyprinter_config(settings: dict[str, Any], moneyprinter_path: str) -> Path | None:
     if not moneyprinter_path or toml is None:
         return None
@@ -191,5 +215,5 @@ def sync_moneyprinter_config(settings: dict[str, Any], moneyprinter_path: str) -
         except Exception:
             existing = {}
     payload = build_moneyprinter_config(settings, existing)
-    target.write_text(toml.dumps(payload), encoding="utf-8")
+    _atomic_write_text(target, toml.dumps(payload))
     return target

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danhachuel/thunderbolt",
-  "version": "0.3.76",
+  "version": "0.3.78",
   "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

@@ -1,10 +1,10 @@
-"""Generate long Azure Speech V2 audio by synthesizing safe sequential chunks.
+"""Generate long Azure Speech V2 audio through conservative 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.
+The Azure real-time TTS endpoint limits the produced audio of one request to
+10 minutes.  This helper deliberately stays far below that limit, adjusts the
+text budget for slow voices, and concatenates the completed segments locally.
+Secrets are read only from environment variables and are never printed.
 """
-
 from __future__ import annotations
 
 import argparse
@@ -18,12 +18,19 @@ from tempfile import TemporaryDirectory
 from xml.sax.saxutils import escape
 
 
-MAX_CHUNK_CHARACTERS = 1800
+# Azure documents a 600000 ms maximum for real-time TTS.  This is an internal
+# character budget, not a claim that characters map to a fixed duration.  The
+# deliberately conservative ceiling leaves room for slow voices, pauses and
+# punctuation before the service limit can be approached.
+MAX_CHUNK_CHARACTERS = 900
+MIN_CHUNK_CHARACTERS = 180
 RETRY_COUNT = 3
 
 
 def _build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(description="Synthesize Azure Speech V2 audio in safe chunks.")
+    parser = argparse.ArgumentParser(
+        description="Synthesize Azure Speech V2 audio in conservative chunks."
+    )
     parser.add_argument("--text-file", type=Path, required=True)
     parser.add_argument("--output", type=Path, required=True)
     parser.add_argument("--voice", required=True)
@@ -57,18 +64,27 @@ def _split_long_piece(piece: str, limit: int) -> list[str]:
     return chunks
 
 
-def split_text(text: str, limit: int = MAX_CHUNK_CHARACTERS) -> list[str]:
-    """Split paragraphs and sentences without sending a 10-minute request."""
+def split_text(text: str, limit: int | None = None) -> list[str]:
+    """Split paragraphs and sentences without sending an oversized request."""
+    try:
+        effective_limit = int(limit if limit is not None else MAX_CHUNK_CHARACTERS)
+    except (TypeError, ValueError):
+        effective_limit = MAX_CHUNK_CHARACTERS
+    effective_limit = max(1, effective_limit)
     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()]
+    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):
+        for fragment in _split_long_piece(piece, effective_limit):
             candidate = f"{current} {fragment}".strip()
-            if current and len(candidate) > limit:
+            if current and len(candidate) > effective_limit:
                 chunks.append(current)
                 current = fragment
             else:
@@ -86,8 +102,20 @@ def _normalise_rate(value: float) -> float:
     return max(0.25, min(4.0, rate))
 
 
+def chunk_character_limit(rate: float) -> int:
+    """Return a conservative text budget adjusted to the requested speech rate."""
+    normalized_rate = _normalise_rate(rate)
+    # A slow rate stretches the audio, so reduce the text budget proportionally.
+    # A fast rate is capped: the service limit is not a reason to send huge SSML.
+    return max(
+        MIN_CHUNK_CHARACTERS,
+        min(MAX_CHUNK_CHARACTERS, int(round(MAX_CHUNK_CHARACTERS * normalized_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"
+    parts = voice.split("-", 2)
+    locale = "-".join(parts[:2]) if len(parts) >= 2 else "en-US"
     return (
         '<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" '
         f'xml:lang="{escape(locale)}">'
@@ -97,35 +125,51 @@ def _build_ssml(text: str, voice: str, rate: float) -> str:
     )
 
 
-def _synthesise_chunk(speechsdk, text: str, voice: str, rate: float, target: Path) -> None:
+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.")
+        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)
+    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", "")
+        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]}")
+        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.")
+        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")
+    ffmpeg_binary = os.environ.get("IMAGEIO_FFMPEG_EXE", "").strip() or shutil.which(
+        "ffmpeg"
+    )
     if not ffmpeg_binary:
         try:
             import imageio_ffmpeg
@@ -133,16 +177,21 @@ def generate(text: str, voice: str, rate: float, output: Path) -> int:
             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 ffmpeg_binary:
+        raise RuntimeError(
+            "FFmpeg não está disponível para concatenar os segmentos Azure Speech V2."
+        )
+    AudioSegment.converter = ffmpeg_binary
+
+    normalized_rate = _normalise_rate(rate)
+    limit = chunk_character_limit(normalized_rate)
+    chunks = split_text(text, limit=limit)
     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:
+    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):
@@ -150,21 +199,28 @@ def generate(text: str, voice: str, rate: float, output: Path) -> int:
             last_error: Exception | None = None
             for attempt in range(1, RETRY_COUNT + 1):
                 try:
-                    _synthesise_chunk(speechsdk, chunk, voice, rate, segment_path)
+                    segment_path.unlink(missing_ok=True)
+                    _synthesise_chunk(
+                        speechsdk, chunk, voice, normalized_rate, segment_path
+                    )
                     last_error = None
                     break
-                except Exception as exc:  # Azure SDK exposes provider-specific exception classes.
+                except Exception as exc:  # Azure SDK exposes provider-specific 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
+                raise RuntimeError(
+                    f"Falha no segmento Azure Speech {index}/{len(chunks)}: {last_error}"
+                ) from last_error
             segment_paths.append(segment_path)
+            print(f"AZURE_CHUNK_PROGRESS={index}/{len(chunks)}", flush=True)
 
         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)
@@ -180,6 +236,7 @@ def main(argv: list[str] | None = None) -> int:
         return 1
     print(f"AZURE_CHUNKED_AUDIO={args.output.resolve()}")
     print(f"AZURE_CHUNK_COUNT={count}")
+    print(f"AZURE_CHUNK_CHARACTER_LIMIT={chunk_character_limit(args.rate)}")
     return 0
 
 

package/seed/skills/mpt_agent.py

@@ -24,6 +24,8 @@ PROJECT_ARCHIVE_URL = (
     "https://github.com/harry0703/MoneyPrinterTurbo/archive/refs/heads/main.zip"
 )
 DEFAULT_ROOT = Path.home() / "MoneyPrinterTurbo"
+CHUNKED_SYNTHESIS_TIMEOUT_SECONDS = 15 * 60
+DEPENDENCY_SYNC_TIMEOUT_SECONDS = 15 * 60
 DEFAULT_VOICE_NAME = "zh-CN-XiaoxiaoNeural-Female"
 NEEDS_INPUT_EXIT_CODE = 10
 SUPPORTED_SOURCES = {"pexels", "pixabay", "coverr", "local"}
@@ -72,6 +74,33 @@ def log(message: str) -> None:
     print(f"[MoneyPrinterTurbo] {message}", flush=True)
 
 
+def _atomic_write_text(path: Path, text: str) -> None:
+    """Replace a text file atomically so an interrupted Windows write keeps the old file."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary_path: Path | None = None
+    try:
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            encoding="utf-8",
+            dir=str(path.parent),
+            prefix=f".{path.name}.",
+            suffix=".tmp",
+            delete=False,
+        ) as handle:
+            temporary_path = Path(handle.name)
+            handle.write(text)
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(temporary_path, path)
+    except Exception:
+        if temporary_path is not None:
+            try:
+                temporary_path.unlink(missing_ok=True)
+            except OSError:
+                pass
+        raise
+
+
 def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
     parser = argparse.ArgumentParser(
         description="Install MoneyPrinterTurbo and generate a final video from a topic."
@@ -239,7 +268,7 @@ def apply_environment_config(config_path: Path) -> None:
     if pixabay_keys:
         text = _replace_config_value(text, "pixabay_api_keys", pixabay_keys)
         changes.append("pixabay_api_keys")
-    config_path.write_text(text, encoding="utf-8")
+    _atomic_write_text(config_path, text)
     log("updated configuration fields: " + ", ".join(changes))
 
 
@@ -279,7 +308,7 @@ def reuse_existing_llm_provider(config_path: Path) -> str:
     for provider in reusable_providers:
         if _provider_is_ready(text, provider):
             text = _replace_config_value(text, "llm_provider", provider)
-            config_path.write_text(text, encoding="utf-8")
+            _atomic_write_text(config_path, text)
             log(f"reusing configured LLM provider: {provider}")
             return provider
     return current_provider
@@ -325,12 +354,10 @@ def _forwarded_option_value(cli_args: list[str], option: str) -> str:
 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"):
+    if "-v2" not in voice.casefold():
         return ""
-    base_voice = re.sub(r"-V2(?=-|$)", "", voice, count=1).strip()
-    return re.sub(r"-(?:Female|Male)$", "", base_voice, flags=re.IGNORECASE).strip()
-
-
+    base_voice = re.sub("-v2", "", voice, count=1, flags=re.IGNORECASE).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:
@@ -358,7 +385,7 @@ def _prepare_azure_v2_chunked_audio(
     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")
+    _atomic_write_text(text_file, text.strip() + "\n")
     chunk_script = Path(__file__).with_name("azure_tts_chunked.py")
     command = [
         uv,
@@ -382,24 +409,55 @@ def _prepare_azure_v2_chunked_audio(
     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,
-    )
+    try:
+        result = subprocess.run(
+            command,
+            cwd=root,
+            env=environment,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            errors="replace",
+            check=False,
+            timeout=CHUNKED_SYNTHESIS_TIMEOUT_SECONDS,
+        )
+    except subprocess.TimeoutExpired as exc:
+        raise SkillError(
+            "A síntese segmentada Azure Speech SDK V2 excedeu 15 minutos; "
+            "a chamada monolítica não será usada."
+        ) from exc
+    chunk_match = re.search(r"(?m)^AZURE_CHUNK_COUNT=(\d+)$", result.stdout or "")
+    if not chunk_match:
+        detail = "\n".join((result.stdout or "").splitlines()[-12:]).strip()
+        detail = detail.replace(speech_key, "[redacted]").replace(speech_region, "[redacted]")
+        raise SkillError(
+            "Azure Speech SDK V2 não confirmou segmentos e áudio customizado. "
+            + (detail or "O helper não devolveu detalhes.")
+        )
     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()
+        detail = detail.replace(speech_key, "[redacted]").replace(speech_region, "[redacted]")
         raise SkillError(
             "Azure Speech SDK V2 falhou na síntese segmentada. "
             + (detail or "O helper não devolveu detalhes.")
         )
-    return audio_file
+    chunk_count = int(chunk_match.group(1))
+    if chunk_count <= 0:
+        raise SkillError("Azure Speech SDK V2 não confirmou segmentos de áudio válidos.")
+    _atomic_write_text(
+        audio_file.with_suffix(".json"),
+        json.dumps(
+            {
+                "status": "completed",
+                "audio_file": str(audio_file.resolve()),
+                "chunk_count": chunk_count,
+            },
+            ensure_ascii=False,
+            indent=2,
+        ) + "\n",
+    )
+    log(f"Azure Speech V2 segmentado: {chunk_count} segmentos; áudio customizado preparado")
+    return audio_file.resolve()
 
 
 def missing_config(config_path: Path, cli_args: list[str]) -> tuple[str, list[str]]:
@@ -524,7 +582,7 @@ def validate_pexels_config(config_path: Path, cli_args: list[str]) -> bool:
     if valid_keys:
         if valid_keys != keys:
             text = _replace_config_value(text, "pexels_api_keys", valid_keys)
-            config_path.write_text(text, encoding="utf-8")
+            _atomic_write_text(config_path, text)
         log(
             "Pexels key validation completed: "
             f"valid={len(valid_keys)}, rejected={rejected_count}, "
@@ -566,24 +624,37 @@ def write_result_manifest(root: Path, payload: dict[str, object]) -> Path:
     temp_path.replace(result_path)
     return result_path.resolve()
 
-
 def run_checked(command: list[str], *, cwd: Path) -> None:
-    """Run dependency sync quietly and show only the last 30 lines on failure."""
+    """Run dependency sync with a bounded wait and safe failure output."""
     log("installing or verifying project dependencies with uv")
-    result = subprocess.run(
-        command,
-        cwd=cwd,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.STDOUT,
-        text=True,
-        errors="replace",
-        check=False,
-    )
+    try:
+        result = subprocess.run(
+            command,
+            cwd=cwd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            errors="replace",
+            check=False,
+            timeout=DEPENDENCY_SYNC_TIMEOUT_SECONDS,
+        )
+    except subprocess.TimeoutExpired as exc:
+        raise SkillError(
+            "A verificação das dependências com uv excedeu 15 minutos; "
+            "a execução foi interrompida."
+        ) from exc
+    output = result.stdout or ""
+    for key in ("MPT_LLM_API_KEY", "MPT_PEXELS_API_KEY", "MPT_PIXABAY_API_KEY", "AZURE_SPEECH_KEY", "AZURE_SPEECH_REGION"):
+        secret = os.environ.get(key, "").strip()
+        if secret:
+            output = output.replace(secret, "[redacted]")
     if result.returncode != 0:
-        output_tail = (result.stdout or "").splitlines()[-30:]
-        if output_tail:
-            print("\n".join(output_tail), file=sys.stderr)
-        raise SkillError(f"dependency installation failed with exit code {result.returncode}")
+        output_tail = "\n".join(output.splitlines()[-30:]).strip()
+        raise SkillError(
+            f"dependency installation failed with exit code {result.returncode}. "
+            + (f"Detalhe do uv: {output_tail}" if output_tail else "O uv não devolveu detalhes.")
+        )
+    log("project dependencies verified with uv")
 
 
 def generate_video(
@@ -621,7 +692,9 @@ def generate_video(
         else ["--voice-name", DEFAULT_VOICE_NAME]
     )
     forwarded_args = list(cli_args)
-    if not has_cli_option(forwarded_args, "--custom-audio-file"):
+    azure_v2_requested = bool(_azure_v2_voice(forwarded_args))
+    custom_audio_requested = has_cli_option(forwarded_args, "--custom-audio-file")
+    if azure_v2_requested and not custom_audio_requested:
         chunked_audio = _prepare_azure_v2_chunked_audio(
             root,
             config_path,
@@ -629,8 +702,20 @@ def generate_video(
             forwarded_args,
             uv,
         )
-        if chunked_audio is not None:
-            forwarded_args.extend(["--custom-audio-file", str(chunked_audio)])
+        if chunked_audio is None or not chunked_audio.is_file() or chunked_audio.stat().st_size <= 0:
+            raise SkillError(
+                "Azure Speech SDK V2 não produziu áudio segmentado; "
+                "a geração foi interrompida para não usar a chamada monolítica."
+            )
+        forwarded_args.extend(["--custom-audio-file", str(chunked_audio.resolve())])
+    elif azure_v2_requested and custom_audio_requested:
+        custom_audio_value = _forwarded_option_value(forwarded_args, "--custom-audio-file")
+        custom_audio_path = Path(custom_audio_value).expanduser()
+        if not custom_audio_value or not custom_audio_path.is_file() or custom_audio_path.stat().st_size <= 0:
+            raise SkillError(
+                "Azure Speech SDK V2 recebeu um áudio customizado inválido; "
+                "a geração foi interrompida para não usar a chamada monolítica."
+            )
     command = [
         uv,
         "run",
@@ -750,6 +835,18 @@ def main(argv: list[str] | None = None) -> int:
             root, args.subject, args.cli_args
         )
     except (OSError, SkillError, urllib.error.URLError, zipfile.BadZipFile) as exc:
+        manifest_path = result_manifest_path(root)
+        try:
+            manifest_payload = json.loads(manifest_path.read_text(encoding="utf-8")) if manifest_path.is_file() else {}
+        except (OSError, json.JSONDecodeError):
+            manifest_payload = {}
+        if manifest_payload.get("status") == "running":
+            manifest_payload.update({"status": "failed", "error": str(exc)[:1000]})
+            write_result_manifest(root, manifest_payload)
+        for output_key, manifest_key in (("TASK_DIR", "task_dir"), ("LOG_FILE", "log_file"), ("RESULT_FILE", "result_file")):
+            value = str(manifest_payload.get(manifest_key) or "").strip()
+            if value:
+                print(f"{output_key}={value}", file=sys.stderr)
         print(f"MPT_ERROR={exc}", file=sys.stderr)
         return 1