primocode 9.8.0-beta.21 → 9.8.0-beta.23

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v9.8.0-beta.21
+# PrimoCode v9.8.0-beta.23
 
 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.21
+ ▐▛███▜▌   Primo Code v9.8.0-beta.23
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/lib/estudio/cinema.js

@@ -35,11 +35,46 @@ const tokens = (t) => String(t || '').normalize('NFD').replace(/[̀-ͯ]/g, '').t
 const leitura = (t) => 0.55 + 0.22 * String(t || '').split(/\s+/).filter(Boolean).length;
 
 /** A fala desta parte (o que a voz diz): a "fala", ou os textos da tela. */
+/* A voz lê EXATAMENTE o que está na tela, na ordem da tela ("a narração tem
+   que ser a mesma dos textos", 25/09). Caixa alta vira frase normal (senão a
+   voz soletra), "IA" fica "IA", o separador vira pausa e "/SC" sai da fala. */
+function paraFala(x) {
+    let t = String(x || '').replace(/\b0(\d)\b/g, '$1').replace(/[·→]/g, ',').replace(/\/(SC|SP|RJ|PR|RS|MG)\b/g, '').replace(/\s+,/g, ',').trim();
+    if (t && t === t.toUpperCase()) {
+        // Sigla de até 3 letras fica sigla ("AI" minúsculo a voz lê como "ai").
+        const SIGLAS = new Set(['IA', 'AI', 'TI', 'RH', 'CEO', 'KPI', 'BI', 'CRM', 'ERP', 'SC', 'SP', 'PR', 'RS', 'RJ', 'MG']);
+        t = t.split(/(\s+)/).map((w) => (SIGLAS.has(w.replace(/[:.,!?]$/, '')) ? w : w.toLowerCase())).join('')
+            .replace(/(^|[.!?:]\s+)(\p{L})/gu, (m, a, b) => a + b.toUpperCase());
+    }
+    t = t.replace(/[,;:\s]+$/, '');
+    if (!/[.!?]$/.test(t)) t += '.';
+    return t;
+}
 function falaDe(p) {
     if (p.fala) return p.fala;
     if (p.tipo === 'depoimento') return '';
-    const partes = [p.antes, ...(p.linhas || []), ...(p.itens || []), p.num ? `Dia ${p.num}.` : '', p.titulo, p.final];
-    return partes.filter(Boolean).map((x) => String(x).replace(/[·→]/g, ',')).join(' ');
+    const tela = p.tipo === 'dia' ? [`Dia ${p.num}`, p.titulo, ...(p.linhas || [])]
+        : p.tipo === 'escada' ? [...(p.itens || []), p.final]
+            : p.tipo === 'numeros' ? [p.antes, ...(p.itens || [])]
+                : (p.linhas || []);
+    /* A linha só emenda na seguinte quando não termina em pontuação E a
+       seguinte começa em minúscula ("E se 3 dias fossem suficientes" / "para
+       mudar…"); o resto é frase inteira. A frase repetida em seguida
+       ("CONSTRUIR" / "Construir.") a voz diz uma vez só. */
+    const linhas = tela.filter(Boolean).map((x) => String(x).trim());
+    const frases = [];
+    let atual = '';
+    linhas.forEach((bruto, k) => {
+        const prox = linhas[k + 1];
+        const emenda = !/[.!?…·→:]$/.test(bruto) && prox && /^[a-zà-ú]/.test(prox);
+        let pedaco = paraFala(bruto);
+        if (emenda) pedaco = pedaco.replace(/\.$/, '');
+        atual = atual ? `${atual} ${pedaco.charAt(0).toLowerCase()}${pedaco.slice(1)}` : pedaco;
+        if (!emenda) { frases.push(atual); atual = ''; }
+    });
+    if (atual) frases.push(atual);
+    const chave = (f) => f.toLowerCase().replace(/[^\p{L}\p{N}]/gu, '');
+    return frases.filter((f, k) => k === 0 || chave(f) !== chave(frases[k - 1])).join(' ');
 }
 
 /* Quando cada texto começa, pelo tempo das palavras da voz: procura a
@@ -351,4 +386,4 @@ function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
     };
 }
 
-module.exports = { montarCinema, falaDe, quando, leitura };
+module.exports = { montarCinema, falaDe, paraFala, quando, leitura };

package/lib/estudio/index.js

@@ -701,11 +701,21 @@ function alinharPartes(lista, palavras, total) {
     for (let i = 1; i < lista.length; i++) {
         acum += chars[i - 1];
         const esperado = Math.round(ws.length * acum / soma);
-        const alvo = tokens(lista[i].texto).find((w) => w.length >= 3) || tokens(lista[i].texto)[0];
+        /* As DUAS primeiras palavras da parte, seguidas: achar só pela primeira
+           palavra longa deixava o "E" de "E sair com algo" no fim da fala
+           anterior, e ele soava duas vezes (medido em 25/09, aos 38 s). */
+        const tk = tokens(lista[i].texto);
         let achado = -1;
-        // Procura perto de onde a proporção diz que a parte começa.
-        for (let j = Math.max(cursor + 1, esperado - 12); j < Math.min(ws.length, esperado + 12); j++) {
-            if (ws[j].k === alvo) { achado = j; break; }
+        for (let j = Math.max(cursor + 1, esperado - 14); j < Math.min(ws.length, esperado + 14); j++) {
+            if (ws[j].k === tk[0] && (!tk[1] || (ws[j + 1] && ws[j + 1].k === tk[1]))) { achado = j; break; }
+        }
+        if (achado < 0) {
+            const alvo = tk.find((w) => w.length >= 3) || tk[0];
+            for (let j = Math.max(cursor + 1, esperado - 12); j < Math.min(ws.length, esperado + 12); j++) {
+                if (ws[j].k === alvo) { achado = j; break; }
+            }
+            // A palavra curta que vem antes da achada ("e", "a", "o") é desta parte, não da anterior.
+            while (achado > cursor + 1 && ws[achado - 1].k.length <= 2 && tk.slice(0, 3).includes(ws[achado - 1].k)) achado--;
         }
         const idx = achado > cursor ? achado : Math.max(cursor + 1, Math.min(ws.length - 1, esperado));
         inicios.push(idx);
@@ -723,11 +733,22 @@ async function narrarComGemini(lista, mp3, { voz, direcao } = {}) {
     try {
         const cfg = require('../config').loadConfig();
         const api = require('../api');
-        const r = await api.request(cfg.server, '/api/voz', {
-            texto: lista.map((x) => x.texto).join('\n\n'),
-            voz: VOZ_GEMINI[String(voz || '').toLowerCase()] || voz || 'Charon',
-            ...(direcao ? { direcao } : {}),
-        }, cfg.token);
+        /* A cota grátis da voz é por MINUTO e pequena: "quota" é esperar e
+           tentar de novo, não desistir para a voz de reserva (medido em 25/09:
+           a mesma chamada passava meio minuto depois). */
+        let r = null;
+        for (let tentativa = 0; tentativa < 4; tentativa++) {
+            try {
+                r = await api.request(cfg.server, '/api/voz', {
+                    texto: lista.map((x) => x.texto).join('\n\n'),
+                    voz: VOZ_GEMINI[String(voz || '').toLowerCase()] || voz || 'Charon',
+                    ...(direcao ? { direcao } : {}),
+                }, cfg.token);
+            } catch (e) { r = { ok: false, erro: e.message }; }
+            if (r && r.ok) break;
+            if (!/quota|rate|429|exhaust/i.test(String(r && r.erro))) break;
+            await new Promise((ok) => setTimeout(ok, 30000));
+        }
         if (!r || !r.ok) return { ok: false, error: (r && r.erro) || 'sem voz no servidor' };
         const pcm = mp3.replace(/\.mp3$/, '.pcm');
         fs.writeFileSync(pcm, Buffer.from(r.audio, 'base64'));
@@ -791,20 +812,30 @@ async function prepararDepoimento(p, c) {
         try { fs.unlinkSync(amostra); } catch { /* fica */ }
         const base0 = Math.max(0, c.de - 1.5);
         const ws = ((tr && tr.palavras) || []).map((w) => ({ ...w, de: w.de + base0, ate: w.ate + base0 }));
+        /* Só a FRASE de efeito: começa na primeira palavra dela e termina na
+           última. "Fala a frase que tem que falar e continua antes de trocar"
+           (25/09): o resto da conversa não tem nada a ver com o vídeo. */
         const alvo = tokens(c.frase || '');
-        // A primeira palavra da frase depois do começo pedido, e a última antes do fim pedido.
-        const iniW = ws.find((w) => w.de >= c.de - 0.6 && (!alvo.length || alvo.includes(tokens(w.texto)[0])));
-        const fimWs = ws.filter((w) => w.ate <= c.ate + 0.8);
+        const k0 = (w) => tokens(w.texto)[0] || '';
+        const iniW = ws.find((w) => w.de >= c.de - 1.2 && alvo.length && k0(w) === alvo[0])
+            || ws.find((w) => w.de >= c.de - 0.6 && alvo.includes(k0(w)));
+        const ultimo = alvo[alvo.length - 1];
+        const fimW = [...ws].reverse().find((w) => w.ate <= c.ate + 1.5 && (!iniW || w.de > iniW.de) && k0(w) === ultimo);
         if (iniW) de = Math.max(0, iniW.de - 0.08);
-        if (fimWs.length) ate = fimWs[fimWs.length - 1].ate;
+        if (fimW) ate = fimW.ate;
+        else { const fimWs = ws.filter((w) => w.ate <= c.ate + 0.3); if (fimWs.length) ate = fimWs[fimWs.length - 1].ate; }
+        // A frase na tela é o que a pessoa FALA no trecho — palavra por palavra.
+        const ditas = ws.filter((w) => w.de >= de - 0.05 && w.ate <= ate + 0.05).map((w) => w.texto).join(' ').trim();
+        if (ditas.split(/\s+/).length >= 3) c.fraseDita = ditas.replace(/^./, (x) => x.toUpperCase()).replace(/[,;]$/, '.');
     } catch { /* fica o trecho pedido */ }
-    const dur = ate - de + 0.7;   // o respiro depois da última palavra
+    const dur = ate - de + 0.45;   // um respiro curto depois da última palavra
     const saida = path.join(p.pasta, 'midia', `depo-${path.basename(c.src, path.extname(c.src))}-${Math.round(de)}.mp4`);
     const r = await video.rodar(video.ffmpeg(), ['-y', '-ss', String(de), '-t', String(dur), '-i', origem,
-        '-af', `loudnorm=I=-14:TP=-1.5:LRA=9,afade=t=in:d=0.12,afade=t=out:st=${Math.max(0, dur - 0.55).toFixed(2)}:d=0.55`,
+        '-af', `loudnorm=I=-14:TP=-1.5:LRA=9,afade=t=in:d=0.1,afade=t=out:st=${Math.max(0, dur - 0.4).toFixed(2)}:d=0.4`,
         '-c:v', 'libx264', '-preset', 'veryfast', '-crf', '18', '-c:a', 'aac', '-b:a', '192k', saida], { timeout: 5 * 60000 });
     if (!r.ok) return {};
-    return { src: path.relative(p.pasta, saida).replace(/\\/g, '/'), de: 0, ate: Math.round((dur - 0.3) * 100) / 100, pronto: true };
+    return { src: path.relative(p.pasta, saida).replace(/\\/g, '/'), de: 0, ate: Math.round((dur - 0.3) * 100) / 100, pronto: true,
+        origem: { src: c.src, de: c.de, ate: c.ate, frase: c.frase }, ...(c.fraseDita ? { frase: c.fraseDita } : {}) };
 }
 
 /* A narração com cache (a mesma fala, na mesma direção, não é gerada duas vezes). */
@@ -946,6 +977,17 @@ async function prepararRoteiro(p, args) {
         if (fs.existsSync(cacheMp3) && fs.existsSync(cacheJson)) {
             fs.copyFileSync(cacheMp3, mp3);
             v = { ok: true, ...JSON.parse(fs.readFileSync(cacheJson, 'utf8')), doCache: true };
+            // Cache sem as palavras (vindo de um plano antigo): transcreve de novo e realinha — sem gastar voz.
+            if (!(v.partes || []).some((pt) => (pt.palavras || []).length)) {
+                try {
+                    const cfg = require('../config').loadConfig();
+                    const tr = await require('../api').requestTranscricao(cfg.server, { token: cfg.token, audio: fs.readFileSync(mp3).toString('base64'), nome: 'voz.mp3', idioma: 'pt' });
+                    if (tr && (tr.palavras || []).length) {
+                        v.partes = alinharPartes(lista, tr.palavras, v.segundos);
+                        fs.writeFileSync(cacheJson, JSON.stringify({ voz: v.voz, segundos: v.segundos, partes: v.partes }));
+                    }
+                } catch { /* fica o alinhamento guardado */ }
+            }
         } else {
             v = await narrarComGemini(lista, mp3, { voz: args.voz || roteiro.voz,
                 direcao: 'Leia em português do Brasil como narrador de trailer de marca premium: voz grave, confiante e humana, '
@@ -997,6 +1039,15 @@ async function prepararRoteiro(p, args) {
                 }
             } catch { /* o próximo termo */ }
         }
+        /* A MÚSICA mais baixa na origem: a faixa vem masterizada alta e comprimida,
+           e mesmo a 30% ela cobria a voz e o depoimento ("a música tá muito
+           alta, não dá pra ouvir as pessoas", 25/09). Ela vai a -28 LUFS antes
+           da mistura; os volumes do plano partem daí. */
+        if (trilhaC) {
+            const norm = path.join(p.pasta, 'midia', 'trilha-baixa-' + path.basename(trilhaC).replace(/\.[a-z0-9]+$/i, '.mp3'));
+            const c = await video.rodar(video.ffmpeg(), ['-y', '-i', path.join(p.pasta, trilhaC), '-af', 'loudnorm=I=-28:TP=-6:LRA=11', '-ar', '44100', norm], { timeout: 5 * 60000 });
+            if (c.ok) trilhaC = path.relative(p.pasta, norm).replace(/\\/g, '/');
+        }
         /* AS FOTOS, separadas e enquadradas. "Uma sala, 20 cadeiras" com foto de
            dashboard "não tem nada a ver" (25/09): foto de gente e print de tela
            são coisas diferentes, e a miniatura de depoimento fica de fora. E
@@ -1019,9 +1070,12 @@ async function prepararRoteiro(p, args) {
             if (pt.tipo === 'depoimento') continue;
             if (pt.falaForte) {
                 const arqF = path.join(p.pasta, 'midia', `voz-forte-${i + 1}-${Date.now().toString(36)}.mp3`);
-                const vf = await narrarComCache([{ texto: pt.falaForte }], arqF, { voz: args.voz || roteiro.voz,
-                    direcao: pt.entonacao || 'Leia em português do Brasil como a VIRADA de um trailer: voz grave, intensa e muito firme, '
-                        + 'com peso em cada palavra, pausa dramática no meio, sem gritar.' });
+                // falaForte: true → a voz forte lê o texto da tela.
+                const textoForte = pt.falaForte === true ? cinema.falaDe({ ...pt, fala: undefined }) : pt.falaForte;
+                const vf = await narrarComCache([{ texto: textoForte }], arqF, { voz: args.voz || roteiro.voz,
+                    // A MESMA voz do narrador, só com um pouco mais de ênfase: "não é mudar a voz, é só um pouco a entonação" (25/09).
+                    direcao: pt.entonacao || 'Leia em português do Brasil com a mesma voz e o mesmo ritmo de um narrador de trailer de marca: '
+                        + 'confiante e natural, só um pouco mais de ênfase nas palavras principais. Sem dramatizar.' });
                 if (vf.ok) fortes[iNarr] = { src: path.relative(p.pasta, arqF).replace(/\\/g, '/'), segundos: vf.segundos, palavras: (vf.partes[0] || {}).palavras || [] };
             }
             iNarr++;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "9.8.0-beta.21",
+  "version": "9.8.0-beta.23",
   "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": {