primocode 9.8.0-beta.11 → 9.8.0-beta.12

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v9.8.0-beta.11
+# PrimoCode v9.8.0-beta.12
 
 Agente de engenharia brasileiro para o terminal, no estilo Claude Code.
 Cria arquivos de verdade, roda comandos, **controla o navegador e o desktop** —
@@ -9,7 +9,7 @@ OpenRouter, e cada apelido (`top`/`main`/`fast`) é uma **corrente**: se um mode
 está no limite de pedidos, o próximo atende. Você não vê o erro, e não paga nada.
 
 ```
- ▐▛███▜▌   Primo Code v9.8.0-beta.11
+ ▐▛███▜▌   Primo Code v9.8.0-beta.12
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/lib/claude-engine.js

@@ -61,6 +61,28 @@ function argsDoModelo() {
     return MODELO_CLAUDE ? ['--model', MODELO_CLAUDE] : [];
 }
 
+/* O Claude Code ENXUTO, como motor. Sem isto cada passo do agente abria o
+ * Claude Code da pessoa inteiro: hooks, plugins, skills, CLAUDE.md dela e as
+ * ferramentas nativas — 36 mil tokens e ~6 s por chamada, e a resposta
+ * chegava com recado de hook pessoal ("context-sync pendente"). Medido em
+ * 25/09: com estes argumentos, a mesma chamada leva 473 tokens e ~3,5 s. Um
+ * pedido de 100 passos pagava aquilo 100 vezes — é a demora de 20 minutos.
+ *
+ * Nada disto tira o que o motor precisa: o protocolo vai inteiro no prompt
+ * (corpoDoProtocolo), e as ferramentas que valem são as do PrimoCode, não as
+ * do Claude Code. */
+const ARGS_ENXUTOS = [
+    '--setting-sources', 'project',
+    '--strict-mcp-config',
+    '--disable-slash-commands',
+    '--tools', '',
+    '--no-session-persistence',
+    '--system-prompt', 'Você é o motor de decisão do PrimoCode. Siga à risca o protocolo que vem na mensagem e responda só com o bloco pedido.',
+];
+function argsDoMotor() {
+    return [...ARGS_ENXUTOS, ...argsDoModelo()];
+}
+
 /**
  * Acha o ÚLTIMO bloco marcado no texto (pode vir ruído de terminal — prompt
  * ANSI, texto solto — antes e depois) e devolve o JSON de dentro dele.
@@ -567,7 +589,7 @@ async function requestActViaHeadless(payload, onEvent) {
         '-p',
         '--output-format', 'json',
         '--dangerously-skip-permissions',
-        ...argsDoModelo(),
+        ...argsDoMotor(),
     ], { encoding: 'utf-8', timeout: 180000, input: prompt, maxBuffer: 32 * 1024 * 1024,
         env: process.env, ...SEM_APARECER });
     const r = JSON.parse(saida);
@@ -577,7 +599,7 @@ async function requestActViaHeadless(payload, onEvent) {
     const pedirCorrecao = (aviso) => {
         const s = execFileSync('claude', [
             '-p', '--output-format', 'json', '--dangerously-skip-permissions',
-            ...argsDoModelo(),
+            ...argsDoMotor(),
         ], {
             encoding: 'utf-8', timeout: 120000, maxBuffer: 32 * 1024 * 1024,
             env: process.env,
@@ -622,7 +644,7 @@ module.exports = {
     // o que veio torto. Reimplementar aquilo no outro motor seria manter dois
     // protocolos que divergem na primeira correção de um deles.
     linhaDoHistorico, nomesDasTools, promptDoProtocolo, promptDeCorrecao,
-    MODELO_CLAUDE, argsDoModelo,
+    MODELO_CLAUDE, argsDoModelo, argsDoMotor,
     SKILL_DIR, SKILL_PATH, garantirSkill,
     temClaudeCode, temOrca, orcaAlcancavel, escolherCaminho,
     garantirEngine, requestAct, emitirDecisao,

package/lib/estudio/edicao.js

@@ -85,6 +85,23 @@ const ICONES = [
     [['surpre', 'chocad', 'absurd'], 'exploding-head'],
 ];
 
+/* O termo de busca da IMAGEM DE APOIO, pelo emoji que a palavra ganhou. Em
+   inglês de propósito: os acervos abertos respondem muito melhor assim. */
+const FOTO = {
+    robot: 'humanoid robot', brain: 'human brain', 'light-bulb': 'light bulb idea', 'money-bag': 'money cash',
+    stopwatch: 'clock time', 'chart-increasing': 'business growth', 'chart-decreasing': 'stock market fall',
+    'bar-chart': 'data analytics', rocket: 'rocket launch', fire: 'fire flames', 'mobile-phone': 'smartphone hand',
+    laptop: 'laptop programming', 'globe-showing-americas': 'earth from space', eyes: 'eye closeup',
+    'speaker-high-volume': 'sound waves', memo: 'writing notebook', 'musical-notes': 'music concert',
+    'dog-face': 'puppy', 'cat-face': 'cat', 'red-heart': 'heart love', 'busts-in-silhouette': 'people crowd',
+    house: 'modern house', automobile: 'car road', books: 'library books', warning: 'warning sign',
+    package: 'objects on table', 'puzzle-piece': 'puzzle pieces', 'thinking-face': 'person thinking',
+    'magnifying-glass-tilted-left': 'magnifying glass', 'speech-balloon': 'smart speaker', 'clapper-board': 'watching tv',
+    gear: 'circuit board', calendar: 'city street people', 'graduation-cap': 'students classroom', trophy: 'trophy',
+    'flexed-biceps': 'strength', handshake: 'handshake', 'shopping-cart': 'shopping', briefcase: 'office work',
+    locked: 'cyber security', 'party-popper': 'party celebration', 'exploding-head': 'surprised face',
+};
+
 function limpa(palavra) {
     return String(palavra || '').normalize('NFD').replace(/[̀-ͯ]/g, '')
         .toLowerCase().replace(/[^a-z0-9]/g, '');
@@ -110,6 +127,33 @@ function peso(palavra) {
     return w.length + (iconeDe(palavra) ? 6 : 0);
 }
 
+/** O termo de busca da imagem de apoio para esta palavra, ou null. */
+function termoDeApoio(palavra) {
+    const ic = iconeDe(palavra);
+    return ic ? FOTO[ic.split(':')[1]] || null : null;
+}
+
+// Em quais cenas entra imagem de apoio: uma a cada três, a partir da segunda.
+const temApoio = (i) => i % 3 === 2;
+
+function forteDe(g) {
+    let forte = null;
+    for (const p of g) if (peso(p.texto) > (forte ? peso(forte.texto) : 0)) forte = p;
+    return forte;
+}
+
+/** Os termos das imagens de apoio que o plano vai pedir — para baixar antes. */
+function termosDeApoio(palavras) {
+    const lista = (palavras || []).filter((p) => p && p.texto && p.ate > p.de).sort((a, b) => a.de - b.de);
+    const termos = [];
+    frases(lista).forEach((g, i) => {
+        const f = forteDe(g);
+        const t = f && temApoio(i) ? termoDeApoio(f.texto) : null;
+        if (t && !termos.includes(t)) termos.push(t);
+    });
+    return termos;
+}
+
 const fimDeFrase = (texto) => /[.!?…]$/.test(String(texto || '').trim());
 const r2 = (n) => Math.round(n * 100) / 100;
 
@@ -164,8 +208,8 @@ function camera(i, dur) {
 }
 
 const ESTILOS = {
-    viral: { icones: true, letreiro: true, sons: true, barra: true, destaque: '#FFD400', forte: '#00E0A4' },
-    limpo: { icones: false, letreiro: false, sons: false, barra: false, destaque: '#FFFFFF', forte: '#FFD400' },
+    viral: { icones: true, letreiro: true, sons: true, barra: true, apoio: true, destaque: '#FFD400', forte: '#00E0A4' },
+    limpo: { icones: false, letreiro: false, sons: false, barra: false, apoio: true, destaque: '#FFFFFF', forte: '#FFD400' },
 };
 
 /**
@@ -181,7 +225,7 @@ const ESTILOS = {
  * @param {object} op.sons        { pop, whoosh } — caminhos na pasta do projeto, opcionais
  * @param {Set}    op.iconesOk    os nomes de ícone que existem de verdade (sem isso, todos valem)
  */
-function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, estilo = 'viral', sons = {}, iconesOk = null }) {
+function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, estilo = 'viral', sons = {}, iconesOk = null, imagens = {}, trilha = null }) {
     const e = ESTILOS[estilo] || ESTILOS.viral;
     const lista = (palavras || []).filter((p) => p && p.texto && p.ate > p.de).sort((a, b) => a.de - b.de);
     if (!lista.length) return { ok: false, error: 'a gravação não tem fala transcrita para editar.' };
@@ -202,16 +246,35 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
         const local = (t) => r2(Math.max(0, t - ini));
 
         // A palavra forte da frase: a que mais carrega a ideia.
-        let forte = null;
-        for (const p of g) if (peso(p.texto) > (forte ? peso(forte.texto) : 0)) forte = p;
+        const forte = forteDe(g);
 
         const elementos = [{
             tipo: 'video', src, x: 0, y: 0, largura: '100%', altura: '100%',
             deOrigem: r2(ini), ateOrigem: r2(ini + dur), volume: 1,
         }];
 
+        /* A IMAGEM DE APOIO: na hora da palavra forte, a tela vira a imagem do
+           que está sendo dito, com um zoom lento, e a legenda continua por
+           cima. É o "b-roll" das edições de videomaker. */
+        const apoio = forte && e.apoio && temApoio(i) ? imagens[termoDeApoio(forte.texto)] : null;
+        if (apoio) {
+            const de = local(forte.de - 0.1);
+            const vida = Math.min(2.2, dur - de);
+            if (vida > 0.8) {
+                elementos.push({
+                    tipo: 'imagem', src: apoio, x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover',
+                    de, ate: r2(de + vida),
+                    anima: {
+                        escala: [{ t: 0, v: 1.12 }, { t: vida, v: 1.0, e: 'suave' }],
+                        opacidade: [{ t: 0, v: 0 }, { t: 0.12, v: 1 }, { t: vida - 0.15, v: 1 }, { t: vida, v: 0 }],
+                    },
+                });
+                if (e.sons && sons.whoosh) efeitos.push({ t: r2(Math.max(0, ini + de - 0.1)), src: sons.whoosh, volume: 0.55 });
+            }
+        }
+
         // O ícone salta na hora da palavra; sem ícone, o letreiro da ideia.
-        const icone = forte && e.icones ? iconeDe(forte.texto) : null;
+        const icone = forte && e.icones && !apoio ? iconeDe(forte.texto) : null;
         const temIcone = icone && (!iconesOk || iconesOk.has(icone));
         const x = lado++ % 2 === 0 ? '78%' : '22%';
         if (temIcone) {
@@ -229,7 +292,7 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
                         opacidade: [{ t: vida - 0.2, v: 1 }, { t: vida, v: 0 }],
                     },
                 });
-                if (e.sons && sons.pop) efeitos.push({ t: r2(ini + de), src: sons.pop, volume: 0.45 });
+                if (e.sons && sons.pop) efeitos.push({ t: r2(ini + de), src: sons.pop, volume: 0.8 });
             }
         } else if (forte && e.letreiro && i % 2 === 0 && peso(forte.texto) >= 7) {
             const de = local(forte.de);
@@ -245,12 +308,12 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
                         rotacao: [{ t: 0, v: -6 }, { t: 0.3, v: -3, e: 'saida' }],
                     },
                 });
-                if (e.sons && sons.pop) efeitos.push({ t: r2(ini + de), src: sons.pop, volume: 0.35 });
+                if (e.sons && sons.pop) efeitos.push({ t: r2(ini + de), src: sons.pop, volume: 0.7 });
             }
         }
 
         // A legenda palavra por palavra.
-        const fala = blocos(g, deitado ? 4 : 3).map((b, j, todos) => ({
+        const fala = blocos(g, 3).map((b, j, todos) => ({
             de: local(b[0].de - 0.04),
             ate: j < todos.length - 1 ? local(todos[j + 1][0].de - 0.04) : r2(dur),
             texto: b.map((p) => p.texto).join(' '),
@@ -260,10 +323,10 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
             })),
         }));
         elementos.push({
-            tipo: 'legenda', x: '50%', y: deitado ? '80%' : '70%', ancora: 'centro', fala,
+            tipo: 'legenda', x: '50%', y: deitado ? '76%' : '68%', ancora: 'centro', fala,
             estilo: {
                 fonte: 'Montserrat', peso: 900, tamanho: Math.round(base * (deitado ? 0.078 : 0.072)),
-                destaque: e.destaque, corForte: e.forte, caixa: 'uppercase',
+                destaque: e.destaque, corForte: e.forte, caixa: 'uppercase', largura: '92%',
             },
         });
 
@@ -277,7 +340,7 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
         }
 
         // O whoosh entra no punch-in: é o corte que ele anuncia.
-        if (e.sons && sons.whoosh && i > 0 && i % 3 === 1) efeitos.push({ t: r2(Math.max(0, ini - 0.12)), src: sons.whoosh, volume: 0.3 });
+        if (e.sons && sons.whoosh && i > 0 && i % 3 === 1) efeitos.push({ t: r2(Math.max(0, ini - 0.12)), src: sons.whoosh, volume: 0.6 });
 
         cenas.push({ duracao: dur, camera: camera(i, dur), elementos, transicao: { tipo: 'corte' } });
     });
@@ -288,11 +351,18 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
             formato: { largura, altura, fps: 30 },
             fundoGeral: '#000',
             cenas,
-            ...(efeitos.length ? { audio: { efeitos } } : {}),
+            ...(efeitos.length || trilha ? { audio: {
+                ...(efeitos.length ? { efeitos } : {}),
+                // A música fica BAIXA: quem fala para a câmera fala o vídeo
+                // inteiro, e a trilha é cama, não disputa.
+                ...(trilha ? { trilha: { src: trilha, volume: 0.07, loop: true } } : {}),
+            } } : {}),
         },
         resumo: {
             cenas: cenas.length,
             icones: cenas.reduce((n, c) => n + c.elementos.filter((x) => x.tipo === 'icone').length, 0),
+            imagens: cenas.reduce((n, c) => n + c.elementos.filter((x) => x.tipo === 'imagem').length, 0),
+            musica: Boolean(trilha),
             letreiros: cenas.reduce((n, c) => n + c.elementos.filter((x) => x.tipo === 'texto').length, 0),
             efeitos: efeitos.length,
         },
@@ -328,4 +398,4 @@ async function prepararSons(pasta, video) {
     return sons;
 }
 
-module.exports = { montarEdicao, prepararSons, iconeDe, peso, frases, blocos, ESTILOS, ICONES };
+module.exports = { montarEdicao, prepararSons, iconeDe, peso, frases, blocos, termosDeApoio, termoDeApoio, ESTILOS, ICONES, FOTO };

package/lib/estudio/index.js

@@ -413,6 +413,15 @@ async function ferramentaVideo(args, ctx = {}) {
             const c = await video.cortarSilencio(alvo, saida, args);
             if (c.ok && !c.semCorte) { fonte = saida; cortes = c.cortes || 0; }
         }
+        /* A VOZ NO VOLUME CERTO. A gravação de celular sai baixa (medido em
+           25/09: -37,6 dB de média no vídeo pronto, e "está sem som"). O
+           loudnorm leva a fala a -15 LUFS, o volume de vídeo de internet; o
+           vídeo em si não é recodificado. */
+        const normal = path.join(p.pasta, 'midia', `voz-normal-${Date.now().toString(36)}.mp4`);
+        const ln = await video.rodar(video.ffmpeg(), ['-y', '-i', fonte, '-c:v', 'copy',
+            '-af', 'loudnorm=I=-15:TP=-1.5:LRA=11', '-c:a', 'aac', '-b:a', '192k', normal], { timeout: 10 * 60000 });
+        if (ln.ok) fonte = normal;
+
         const m = await video.medir(fonte);
         if (!m.ok) return m;
 
@@ -430,10 +439,36 @@ async function ferramentaVideo(args, ctx = {}) {
         }
         const sons = await edicao.prepararSons(p.pasta, video);
 
+        // As imagens de apoio: uma por termo, a primeira que baixar.
+        const imagens = {};
+        if ((args.estilo || 'viral') !== 'sem-apoio') {
+            for (const termo of edicao.termosDeApoio(palavras).slice(0, 8)) {
+                try {
+                    const b = await assets.procurarImagens(termo, { quantas: 4 });
+                    for (const item of (b.ok ? b.imagens : [])) {
+                        const d = await assets.baixar(item, { pasta: p.pasta, nome: 'apoio-' + termo });
+                        if (d.ok) { imagens[termo] = d.relativo; break; }
+                    }
+                } catch { /* segue sem esta */ }
+            }
+        }
+
+        // A música de fundo: uma trilha longa, de licença aberta.
+        let trilha = null;
+        if (args.musica !== false) {
+            try {
+                const b = await assets.procurarSom(args.trilha || 'upbeat corporate background', { quantas: 6, duracaoMin: 45 });
+                for (const item of (b.ok ? b.sons : [])) {
+                    const d = await assets.baixar(item, { pasta: p.pasta, nome: 'trilha' });
+                    if (d.ok) { trilha = d.relativo; break; }
+                }
+            } catch { /* segue sem música */ }
+        }
+
         const montado = edicao.montarEdicao({
             src: path.relative(p.pasta, fonte).replace(/\\/g, '/'),
             duracao: m.segundos, palavras, largura: m.largura, altura: m.altura,
-            estilo: args.estilo || 'viral', sons, iconesOk,
+            estilo: args.estilo || 'viral', sons, iconesOk, imagens, trilha,
         });
         if (!montado.ok) return montado;
         const salvo = await ferramentaPlano({ id: args.id, plano: montado.plano, motivo: `edição automática (${args.estilo || 'viral'})` });

package/lib/estudio/remotion.js

@@ -478,6 +478,7 @@ export const Video = () => {
         <Audio
           src={staticFile(plano.audio.trilha.src || plano.audio.trilha)}
           volume={plano.audio.trilha.volume ?? 0.18}
+          loop={plano.audio.trilha.loop !== false}
         />
       )}
       {(plano.audio && plano.audio.efeitos ? plano.audio.efeitos : []).map((e, i) => (

package/lib/local/motor-cli.js

@@ -37,7 +37,7 @@ function motorDe(id) {
 function perguntar(id, texto) {
     if (id === 'codex') return String(motorDe('codex').chamarCodex(texto) || '').trim();
     const claude = motorDe('claude-code');
-    const saida = execFileSync('claude', ['-p', '--output-format', 'json', ...claude.argsDoModelo()], {
+    const saida = execFileSync('claude', ['-p', '--output-format', 'json', ...claude.argsDoMotor()], {
         encoding: 'utf-8', timeout: 120000, input: texto, maxBuffer: 8 * 1024 * 1024, ...SEM_APARECER,
     });
     try { return String(JSON.parse(saida).result || '').trim(); } catch { return String(saida || '').trim(); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "9.8.0-beta.11",
+  "version": "9.8.0-beta.12",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Requer conta Conecta Primo AI (Premium ou Super). Cria arquivos, roda comandos, controla navegador e desktop: abre apps, clica em botões e ícones pelo nome, digita e usa atalhos.",
   "main": "bin/primocode.js",
   "bin": {

package/studio/narrar.py

@@ -200,19 +200,22 @@ def falar_edge(texto, saida, voz, ritmo, tom):
 
 def falar_elevenlabs(texto, saida, voz):
     """Só quando há chave. Sem ela, nem se tenta — e não é erro."""
-    chave = os.environ.get("ELEVENLABS_API_KEY", "").strip()
-    if not chave:
-        return None
+    # A chave mora na variável OU em ~/.primocode/elevenlabs.key — antes só a
+    # variável era lida, e a função chamada (elevenlabs.falar) nem existia:
+    # a ElevenLabs nunca narrou nada, mesmo com a chave no lugar.
     try:
         sys.path.insert(0, str(AQUI))
-        import elevenlabs  # o módulo que já existia no Studio
-        r = elevenlabs.falar(texto, str(saida), voz=voz, chave=chave)
-        if r and r.get("ok"):
-            r["motor"] = "elevenlabs"
-            return r
+        import elevenlabs
+        if not elevenlabs.configurado():
+            return None
+        dados, segundos = elevenlabs.sintetizar(texto, {"voz": voz})
+        if not dados:
+            return None
+        Path(saida).write_bytes(dados)
+        return {"ok": True, "arquivo": str(saida), "motor": "elevenlabs", "segundos": segundos,
+                "falas": [{"de": 0, "ate": segundos, "texto": texto}]}
     except Exception:
-        pass
-    return None
+        return None
 
 
 def comando_falar(args):
@@ -245,6 +248,96 @@ def comando_falar(args):
     return falar_edge(texto, args.saida, v["voz"], ritmo, tom)
 
 
+# ── o roteiro inteiro, com entonação por parte ─────────────────────────────
+# "A voz está sem entonação." (25/09/2026). Uma chamada só, com o texto todo,
+# sai no mesmo ritmo e no mesmo tom do começo ao fim. Aqui cada parte do
+# roteiro é falada com o registro dela — o gancho mais aceso, o número mais
+# devagar, o fecho mais alto — e as partes são costuradas com um respiro. O
+# tempo de CADA PALAVRA volta junto (WordBoundary do edge-tts): é o que
+# sincroniza a tipografia com a voz.
+REGISTRO = {
+    "gancho":   {"ritmo": "+6%",  "tom": "+3Hz", "respiro": 0.35},
+    "numero":   {"ritmo": "-7%",  "tom": "-1Hz", "respiro": 0.45},
+    "contraste": {"ritmo": "+2%", "tom": "+1Hz", "respiro": 0.4},
+    "lista":    {"ritmo": "+0%",  "tom": "+0Hz", "respiro": 0.35},
+    "citacao":  {"ritmo": "-10%", "tom": "-2Hz", "respiro": 0.5},
+    "cta":      {"ritmo": "+4%",  "tom": "+2Hz", "respiro": 0.2},
+    "normal":   {"ritmo": "+0%",  "tom": "+0Hz", "respiro": 0.3},
+}
+
+
+def _parte_edge(texto, voz, ritmo, tom, saida):
+    import asyncio
+    import edge_tts
+
+    async def rodar():
+        c = edge_tts.Communicate(texto, voz, rate=ritmo, pitch=tom, boundary="WordBoundary")
+        palavras = []
+        with open(saida, "wb") as fh:
+            async for ch in c.stream():
+                if ch["type"] == "audio":
+                    fh.write(ch["data"])
+                elif ch["type"] == "WordBoundary":
+                    de = ch["offset"] / 1e7
+                    palavras.append({"de": round(de, 3), "ate": round(de + ch["duration"] / 1e7, 3),
+                                     "texto": ch["text"]})
+        return palavras
+    return asyncio.run(rodar())
+
+
+def _duracao(arquivo):
+    r = subprocess.run(["ffprobe", "-v", "error", "-show_entries", "format=duration",
+                        "-of", "csv=p=0", str(arquivo)], capture_output=True, text=True, timeout=30)
+    try:
+        return float(r.stdout.strip())
+    except ValueError:
+        return 0.0
+
+
+def comando_roteiro(args):
+    partes = json.loads(Path(args.arquivo).read_text(encoding="utf-8"))
+    if not partes:
+        return {"ok": False, "error": "o roteiro veio vazio"}
+    if not edge_disponivel() and not instalar_edge():
+        return {"ok": False, "error": "a narração precisa do pacote edge-tts",
+                "comoResolver": f"{sys.executable} -m pip install edge-tts"}
+    v = voz_de(args.voz)
+    with tempfile.TemporaryDirectory() as tmp:
+        lista, trechos, palavras, t = [], [], [], 0.0
+        for i, parte in enumerate(partes):
+            texto = re.sub(r"\s+", " ", str(parte.get("texto") or "")).strip()
+            if not texto:
+                trechos.append({"de": round(t, 3), "ate": round(t, 3), "palavras": []})
+                continue
+            reg = REGISTRO.get(parte.get("registro") or "normal", REGISTRO["normal"])
+            mp3 = Path(tmp) / f"p{i:02d}.mp3"
+            try:
+                ps = _parte_edge(texto, v["voz"], reg["ritmo"], reg["tom"], mp3)
+            except Exception as e:
+                return {"ok": False, "error": f"a voz falhou na parte {i + 1}: {str(e)[:200]}"}
+            dur = _duracao(mp3)
+            wav = Path(tmp) / f"p{i:02d}.wav"
+            # Cada parte vira wav com o respiro no fim: costurar mp3 direto
+            # deixa um clique e um silêncio de enchimento entre as partes.
+            subprocess.run(["ffmpeg", "-y", "-loglevel", "error", "-i", str(mp3), "-af",
+                            f"apad=pad_dur={reg['respiro']}", "-ar", "44100", "-ac", "1", str(wav)],
+                           capture_output=True, timeout=60)
+            lista.append(wav)
+            ws = [{"de": round(t + w["de"], 3), "ate": round(t + w["ate"], 3), "texto": w["texto"]} for w in ps]
+            palavras += ws
+            trechos.append({"de": round(t, 3), "ate": round(t + dur, 3), "palavras": ws})
+            t += dur + reg["respiro"]
+        roteiro_txt = Path(tmp) / "lista.txt"
+        roteiro_txt.write_text("".join(f"file '{w}'\n" for w in lista), encoding="utf-8")
+        r = subprocess.run(["ffmpeg", "-y", "-loglevel", "error", "-f", "concat", "-safe", "0",
+                            "-i", str(roteiro_txt), "-c:a", "libmp3lame", "-q:a", "3", str(args.saida)],
+                           capture_output=True, timeout=180)
+        if r.returncode != 0:
+            return {"ok": False, "error": (r.stderr or b"").decode("utf-8", "ignore")[-300:]}
+    return {"ok": True, "arquivo": str(args.saida), "motor": "edge", "voz": v["voz"],
+            "segundos": round(t, 3), "partes": trechos, "palavras": palavras}
+
+
 def main():
     p = argparse.ArgumentParser(description="Narração do PrimoCode Studio")
     sub = p.add_subparsers(dest="comando", required=True)
@@ -258,11 +351,18 @@ def main():
     f.add_argument("--ritmo", default="")
     f.add_argument("--tom", default="")
 
+    r = sub.add_parser("roteiro")
+    r.add_argument("--arquivo", required=True)
+    r.add_argument("--saida", required=True)
+    r.add_argument("--voz", default="thalita")
+
     sub.add_parser("vozes")
 
     args = p.parse_args()
     if args.comando == "vozes":
         saida = {"ok": True, "vozes": VOZES, "estilos": list(ESTILOS.keys())}
+    elif args.comando == "roteiro":
+        saida = comando_roteiro(args)
     else:
         saida = comando_falar(args)