@danhachuel/thunderbolt 0.3.68 → 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.68
+> **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)
@@ -128,13 +128,13 @@ Execute:
 Windows PowerShell ou MobaXterm:
 
 ```powershell
-npx.cmd --yes --prefer-online @danhachuel/thunderbolt@0.3.68 install
+npx.cmd --yes --prefer-online @danhachuel/thunderbolt@0.3.69 install
 ```
 
 Linux/macOS:
 
 ```bash
-npx --yes --prefer-online @danhachuel/thunderbolt@0.3.68 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.68 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.68 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

@@ -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/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.68",
+  "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",