primocode 9.8.0-beta.20 → 9.8.0-beta.22

package/README.md

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

package/lib/estudio/cinema.js

@@ -56,7 +56,7 @@ function quando(textos, palavras, dur, t0 = 0.25) {
     });
 }
 
-function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], narracao = null, sons = {}, trilha = null, fotos = [] }) {
+function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], narracao = null, sons = {}, trilha = null, fotos = [], fortes = {} }) {
     const partes = (roteiro && roteiro.partes) || [];
     if (!partes.length) return { ok: false, error: 'o roteiro veio sem partes.' };
     const marca = roteiro.marca || {};
@@ -70,7 +70,17 @@ function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
     const base = Math.min(W, H);
     const cenas = [], trechos = [], efeitos = [], volumes = [];
     let t = 0, fotoI = 0;
-    const foto = () => fotos[fotoI++ % Math.max(1, fotos.length)];
+    /* A foto certa para o texto: "projetos", "construir", "funcionando" pedem
+       a TELA (o dashboard); o resto pede GENTE. Foto de tela em "uma sala, 20
+       cadeiras" era o que "não tem nada a ver" (25/09). */
+    const pool = { pessoas: fotos.filter((f) => f.cat !== 'tela'), tela: fotos.filter((f) => f.cat === 'tela') };
+    const idx = { pessoas: 0, tela: 0 };
+    const foto = (cat = 'pessoas') => {
+        const l = pool[cat] && pool[cat].length ? pool[cat] : (pool.pessoas.length ? pool.pessoas : fotos);
+        const k = pool[cat] && pool[cat].length ? cat : 'pessoas';
+        return l.length ? l[idx[k]++ % l.length] : null;
+    };
+    const catDe = (texto) => (/projet|constru|funcion|dashboard|sistema|ferramenta/i.test(String(texto || '')) ? 'tela' : 'pessoas');
     const som = (tt, nome, volume = 0.6) => { if (sons[nome]) efeitos.push({ t: r2(Math.max(0, tt)), src: sons[nome], volume }); };
     const vol = (tt, v) => volumes.push({ t: r2(tt), v });
 
@@ -82,16 +92,46 @@ function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
         (d) => ({ escala: [{ t: 0, v: 1.14 }, { t: d, v: 1.14 }], x: [{ t: 0, v: W * 0.04 }, { t: d, v: -W * 0.04, e: 'linear' }] }),
     ];
     let mov = 0;
+    /* O ENQUADRAMENTO pelas pessoas: com os rostos achados (studio/rostos.py),
+       o recorte centra neles; se eles não cabem no recorte (a foto deitada num
+       quadro em pé perde 2/3 da largura), a foto entra INTEIRA, com ela mesma
+       borrada de fundo. "Aparecem três homens ali, está cortada, não dá pra
+       ver ninguém" (25/09). */
+    const enquadrar = (f) => {
+        const ro = f.rosto;
+        if (!ro || !ro.largura) return { foco: 'center 30%', inteira: false };
+        const aF = W / H, aI = ro.largura / ro.altura;
+        if (aI > aF) {   // a foto é mais larga que o quadro: sobra largura
+            const vis = aF / aI;
+            if (ro.n && ro.x1 - ro.x0 > vis * 0.92) return { inteira: true };
+            const cx = ro.n ? ro.cx : 0.5;
+            const px = vis >= 1 ? 50 : Math.round(Math.max(0, Math.min(1, (cx - vis / 2) / (1 - vis))) * 100);
+            return { foco: `${px}% ${ro.n ? Math.round(Math.min(0.6, ro.cy) * 100) : 35}%`, inteira: false };
+        }
+        const vis = aI / aF;   // mais alta que o quadro: sobra altura
+        const cy = ro.n ? ro.cy : 0.35;
+        const py = vis >= 1 ? 50 : Math.round(Math.max(0, Math.min(1, (cy - vis / 2) / (1 - vis))) * 100);
+        return { foco: `50% ${py}%`, inteira: false };
+    };
     const pFoto = (els, f, de, ate, { veu = 0.5, entrada = 'corte' } = {}) => {
         if (!f) return;
         const d = r2(ate - de), v = f.tipo === 'video';
-        els.push({ tipo: v ? 'video' : 'imagem', src: f.src, ...(v ? { volume: 0 } : {}), x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover', foco: 'center 30%', de: r2(de), ate: r2(ate),
-            anima: { ...movs[mov++ % movs.length](d), ...(entrada === 'suave' ? { opacidade: [{ t: 0, v: 0 }, { t: 0.4, v: 1 }] } : {}) } });
+        const q = enquadrar(f);
+        const suave = entrada === 'suave' ? { opacidade: [{ t: 0, v: 0 }, { t: 0.4, v: 1 }] } : {};
+        if (q.inteira) {
+            els.push({ tipo: 'imagem', src: f.src, x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover', de: r2(de), ate: r2(ate),
+                anima: { desfoque: [{ t: 0, v: 36 }], brilho: [{ t: 0, v: 0.5 }], escala: [{ t: 0, v: 1.15 }, { t: d, v: 1.25, e: 'linear' }] } });
+            els.push({ tipo: 'imagem', src: f.src, x: 0, y: Math.round(H * 0.22), largura: '100%', altura: Math.round(H * 0.56), ajuste: 'contain', de: r2(de), ate: r2(ate),
+                anima: { escala: [{ t: 0, v: 1.0 }, { t: d, v: 1.07, e: 'linear' }], ...suave } });
+        } else {
+            els.push({ tipo: v ? 'video' : 'imagem', src: f.src, ...(v ? { volume: 0 } : {}), x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover', foco: q.foco, de: r2(de), ate: r2(ate),
+                anima: { ...(deitado ? movs[mov++ % movs.length](d) : movs[(mov++ % 2)](d)), ...suave } });
+        }
         if (veu > 0) els.push({ tipo: 'forma', forma: 'retangulo', x: 0, y: 0, largura: '100%', altura: '100%', de: r2(de), ate: r2(ate),
             fundo: { tipo: 'gradiente', cores: [`rgba(7,7,10,${veu * 0.7})`, `rgba(7,7,10,${veu})`, `rgba(7,7,10,${Math.min(0.95, veu + 0.25)})`], angulo: 180 } });
     };
     // O texto: entra palavra por palavra no tempo da voz e fica; as palavras marcadas no gradiente.
-    const pTexto = (els, texto, de, ate, { y = null, max = deitado ? H * 0.11 : W * 0.13, linhas = 3, peso = 700, caixa = true, marcar = [], cor = BRANCO, pal = [], alinhar = 'center', x = M, larg = W0 } = {}) => {
+    const pTexto = (els, texto, de, ate, { y = null, max = deitado ? H * 0.11 : W * 0.13, linhas = 3, peso = 700, caixa = true, marcar = [], cor = BRANCO, pal = [], alinhar = 'center', x = M, larg = W0, bater = false } = {}) => {
         const txt = caixa ? String(texto).toUpperCase() : String(texto);
         const fit = caber(txt, { largura: larg * 0.86, linhas, max, fonte: F.titulo });
         const h = fit.tamanho * 1.08 * fit.linhas;
@@ -104,7 +144,9 @@ function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
         els.push({ tipo: 'texto', texto: txt, fonte: F.titulo, peso, tamanho: fit.tamanho, cor, entrelinha: 1.08, espacamento: caixa ? 1 : 0,
             x: Math.round(x), y: Math.round(y == null ? (H - h) / 2 : y), largura: Math.round(larg), alinhamento: alinhar, de: r2(de), ate: r2(ate),
             revelar: rev, ...(idx.length ? { destaques: idx, corDestaque: DEST } : {}),
-            anima: { opacidade: [{ t: 0, v: 1 }, { t: Math.max(0.01, ate - de - 0.25), v: 1 }, { t: ate - de, v: 0 }], y: [{ t: 0, v: 10 }, { t: ate - de, v: -6, e: 'linear' }] } });
+            anima: { opacidade: [{ t: 0, v: 1 }, { t: Math.max(0.01, ate - de - 0.25), v: 1 }, { t: ate - de, v: 0 }], y: [{ t: 0, v: 10 }, { t: ate - de, v: -6, e: 'linear' }],
+                // O texto que BATE no fundo: entra grande e assenta de uma vez.
+                ...(bater ? { escala: [{ t: 0, v: 1.35 }, { t: 0.12, v: 0.97, e: 'saida' }, { t: 0.22, v: 1 }] } : {}) } });
         return h;
     };
     const linhaFina = (els, y, de, larg = W * 0.18) => els.push({ tipo: 'forma', forma: 'retangulo', x: Math.round((W - larg) / 2), y: Math.round(y), largura: Math.round(larg), altura: 2,
@@ -118,7 +160,7 @@ function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
         const narrada = p.tipo !== 'depoimento';
         const tp = narrada ? (tempos[narrI++] || null) : null;
         const off = 0.35;                                         // a voz entra um instante depois do corte
-        const falaDur = tp ? Math.min(tp.ate + 0.6, tempos[narrI] ? tempos[narrI].de : tp.ate + 0.6) - tp.de : 0;
+        const falaDur = fortes[narrI - 1] ? fortes[narrI - 1].segundos + 0.3 : (tp ? (tempos[narrI] ? tempos[narrI].de : tp.ate + 0.8) - tp.de : 0);
         const rel = (w) => r2(off + w - (tp ? tp.de : 0));        // tempo da voz → tempo da cena
         const pals = tp ? tp.palavras || [] : [];
         let dur;
@@ -128,8 +170,11 @@ function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
            que a narração não terminou", 25/09). O trecho vai até perto do
            começo da próxima fala, com folga. */
         const proxFala = tempos[narrI] ? tempos[narrI].de : null;
-        const fimFala = tp ? r2(Math.min(proxFala != null ? proxFala - 0.02 : tp.ate + 0.6, tp.ate + 0.6)) : 0;
-        if (tp && narracao) trechos.push({ src: narracao, t: r2(t + off), de: r2(tp.de), ate: fimFala, volume: 1 });
+        // Até o começo da próxima fala, sem teto: o áudio é contínuo, e cortar antes comia sílaba.
+        const forte = fortes[narrI - 1];
+        const fimFala = tp ? r2(proxFala != null ? proxFala - 0.02 : tp.ate + 0.8) : 0;
+        if (tp && narracao && !forte && !p.mudo) trechos.push({ src: narracao, t: r2(t + off), de: r2(tp.de), ate: fimFala, volume: 1 });
+        if (forte) trechos.push({ src: forte.src, t: r2(t + (p.tipo === 'climax' ? 0 : off)), de: 0, ate: r2(forte.segundos + 0.3), volume: 1 });
 
         const textosDaParte = p.tipo === 'escada' ? [...(p.itens || []), p.final].filter(Boolean)
             : p.tipo === 'numeros' ? [p.antes, ...(p.itens || [])].filter(Boolean)
@@ -142,7 +187,9 @@ function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
         /* Cada texto garante o SEU tempo de leitura e empurra o seguinte: sincronia
            com a voz é bom, ler é obrigatório. Se a leitura pede mais que a fala,
            a cena cresce (medido: "EDIÇÕES" ficava meio segundo na tela). */
-        for (let k = 1; k < inicios.length; k++) inicios[k] = r2(Math.max(inicios[k], inicios[k - 1] + leitura(textosDaParte[k - 1])));
+        // Texto curto (um número, "3 DIAS.") se lê de relance: não espera a leitura cheia e não atrasa a voz.
+        const minimo = (x) => Math.min(leitura(x), String(x).split(/\s+/).length <= 3 ? 0.75 : 1.6);
+        for (let k = 1; k < inicios.length; k++) inicios[k] = r2(Math.max(inicios[k], inicios[k - 1] + minimo(textosDaParte[k - 1])));
         if (inicios.length) dur = r2(Math.max(dur, inicios[inicios.length - 1] + leitura(textosDaParte[inicios.length - 1]) + 0.3));
         const fimDe = (k) => (k < inicios.length - 1 ? inicios[k + 1] : dur);
         const palDo = (txt) => { const ws = String(txt).split(/\s+/); const a = pals.findIndex((w) => tokens(w.texto)[0] === tokens(ws[0])[0]); return a < 0 ? [] : ws.map((_, k) => (pals[a + k] ? rel(pals[a + k].de) : null)); };
@@ -153,25 +200,50 @@ function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
             textosDaParte.forEach((x, k) => pTexto(els, x, inicios[k], fimDe(k), { caixa: false, peso: 600, max: deitado ? H * 0.1 : W * 0.12, linhas: deitado ? 3 : 4, marcar: p.marcar || [], pal: palDo(x) }));
         } else if (p.tipo === 'montagem' || p.tipo === 'climax') {
             const rap = p.tipo === 'climax' ? 0.38 : (p.ritmo || 0.75);
-            const fimFotos = p.tipo === 'climax' && textosDaParte.length ? Math.max(1.8, inicios[0] - 0.4) : dur;
-            for (let a = 0; a < fimFotos; a += rap) pFoto(els, foto(), a, Math.min(fimFotos, a + rap), { veu: p.tipo === 'climax' ? 0.15 : 0.5 });
+            let fimFotos = p.tipo === 'climax' && textosDaParte.length ? Math.max(1.8, inicios[0] - 0.4) : dur;
+            const fz = p.tipo === 'climax' ? fortes[narrI - 1] : null;
+            if (fz) {
+                /* A voz forte entra DEPOIS da montagem, junto com o texto que bate. */
+                fimFotos = 2.2;
+                const ini2 = quando(textosDaParte, (fz.palavras || []).map((w) => ({ ...w, de: w.de + fimFotos })), fz.segundos, fimFotos);
+                ini2.forEach((v0, k) => { inicios[k] = k === 0 ? fimFotos : Math.max(v0, inicios[k - 1] + 1.2); });
+                dur = r2(Math.max(fimFotos + fz.segundos + 0.9, inicios[inicios.length - 1] + 1.8));
+                const tr = trechos[trechos.length - 1];
+                if (tr && tr.src === fz.src) tr.t = r2(t + fimFotos - 0.05);
+            }
+            for (let a = 0; a < fimFotos; a += rap) {
+                // A foto do momento acompanha o texto que está na tela.
+                let ativo = textosDaParte[0];
+                textosDaParte.forEach((x, k) => { if (a >= inicios[k] - 0.1) ativo = x; });
+                pFoto(els, foto(catDe(ativo)), a, Math.min(fimFotos, a + rap), { veu: p.tipo === 'climax' ? 0.15 : 0.5 });
+            }
             if (p.tipo === 'climax') {
-                vol(t, 0.5); vol(t + fimFotos - 0.3, 0.75); vol(t + fimFotos, 0.0); vol(t + dur - 0.2, 0.0);
-                som(t + fimFotos, 'impacto', 0.7);
+                /* A virada: a música só ABAIXA (fica perceptível), e o texto bate
+                   no fundo com um impacto forte — "quero um som de impacto bem
+                   forte, do texto batendo no fundo" (25/09). */
+                vol(t, 0.5); vol(t + fimFotos - 0.3, 0.75); vol(t + fimFotos, 0.16); vol(t + dur - 0.2, 0.2);
+                som(t + fimFotos + 0.02, 'estalo', 0.8);
+                cena.tremor = [{ de: fimFotos, ate: fimFotos + 0.45, forca: 16 }];
+                cena.socos = [{ t: fimFotos, forca: 0.12 }];
             } else { vol(t, 0.28); som(t, 'whoosh', 0.35); }
-            textosDaParte.forEach((x, k) => pTexto(els, x, Math.max(inicios[k], p.tipo === 'climax' ? fimFotos : 0), fimDe(k), { peso: 800, marcar: p.marcar || [], pal: palDo(x) }));
+            textosDaParte.forEach((x, k) => {
+                if (p.tipo === 'climax') { som(t + inicios[k], 'impacto', k === 0 ? 1.0 : 0.85); if (k > 0) cena.tremor = [...(cena.tremor || []), { de: inicios[k], ate: inicios[k] + 0.4, forca: 14 }]; }
+                pTexto(els, x, Math.max(inicios[k], p.tipo === 'climax' ? fimFotos : 0), fimDe(k), { peso: 800, marcar: p.marcar || [], pal: palDo(x), bater: p.tipo === 'climax',
+                    // A virada é o texto maior do vídeo.
+                    ...(p.tipo === 'climax' ? { max: deitado ? H * 0.13 : W * 0.17, linhas: deitado ? 3 : 5 } : {}) });
+            });
         } else if (p.tipo === 'numeros') {
             vol(t, 0.3);
-            for (let a = 0; a < dur; a += 1.2) pFoto(els, foto(), a, Math.min(dur, a + 1.2), { veu: 0.62 });
+            for (let a = 0; a < dur; a += 1.2) pFoto(els, foto(), a, Math.min(dur, a + 1.2), { veu: 0.45 });
             textosDaParte.forEach((x, k) => {
                 const m = String(x).match(/^(\d+)\s+(.*)$/);
                 if (k === 0 && p.antes) { pTexto(els, x, inicios[k], fimDe(k), { max: base * 0.08, peso: 700, pal: palDo(x) }); return; }
                 if (!m) { pTexto(els, x, inicios[k], fimDe(k), { pal: palDo(x) }); return; }
                 const tam = Math.round(deitado ? H * 0.24 : W * 0.3);
                 els.push({ tipo: 'texto', texto: m[1], fonte: F.titulo, peso: 800, tamanho: tam, cor: BRANCO, x: M, y: Math.round(H * 0.5 - tam * 0.75), largura: W0, alinhamento: 'center',
-                    de: inicios[k], ate: fimDe(k), contar: { ate: Number(m[1]), dur: 0.9 }, gradienteTexto: undefined,
+                    de: inicios[k], ate: fimDe(k), contar: { ate: Number(m[1]), dur: 0.45 }, gradienteTexto: undefined,
                     anima: { opacidade: [{ t: 0, v: 0 }, { t: 0.25, v: 1 }], escala: [{ t: 0, v: 0.92 }, { t: 0.6, v: 1, e: 'saida' }] } });
-                pTexto(els, m[2], inicios[k] + 0.3, fimDe(k), { y: H * 0.5 + tam * 0.3, max: base * 0.085, peso: 700, cor: DEST });
+                pTexto(els, m[2], inicios[k] + 0.1, fimDe(k), { y: H * 0.5 + tam * 0.3, max: base * 0.085, peso: 700, cor: DEST });
             });
         } else if (p.tipo === 'escada') {
             vol(t, 0.22);
@@ -208,11 +280,12 @@ function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
             /* O aluno falando, com a voz dele; a música quase some. CADA depoimento
                é uma cena: o vídeo conta o tempo do início da cena, e com os três
                na mesma cena o segundo e o terceiro já tinham passado do fim (preto). */
-            vol(t, 0.06);
+            vol(t, 0.035);
             const clipes = p.clipes || [];
             clipes.forEach((c, n) => {
                 const d = r2(c.ate - c.de + 0.3);
-                const ce = { fundo: { tipo: 'cor', valor: PRETO }, elementos: [], transicao: { tipo: n === 0 ? 'esmaecer' : 'corte', duracao: n === 0 ? 0.4 : 0 }, duracao: d };
+                // Entre um depoimento e outro, esmaecer: o corte seco pegava o "é…" de quem começa.
+                const ce = { fundo: { tipo: 'cor', valor: PRETO }, elementos: [], transicao: { tipo: 'esmaecer', duracao: 0.4 }, duracao: d };
                 const el2 = ce.elementos;
                 if (deitado) {
                     const wV = Math.round(H * 0.88 * 9 / 16), xV = Math.round(W * 0.08), xT = xV + wV + Math.round(W * 0.05);
@@ -221,7 +294,11 @@ function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
                     pTexto(el2, `“${c.frase}”`, 0.3, d, { x: xT, larg: W - xT - M, alinhar: 'left', caixa: false, peso: 600, max: H * 0.075, linhas: 5 });
                     if (c.nome) el2.push({ tipo: 'texto', texto: c.nome.toUpperCase(), fonte: F.texto, peso: 700, tamanho: Math.round(H * 0.03), cor: DEST, espacamento: 3, x: xT, y: Math.round(H * 0.8), de: 0.5 });
                 } else {
-                    el2.push({ tipo: 'video', src: c.src, volume: 1, deOrigem: c.de, ateOrigem: c.ate + 0.3, x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover', foco: 'center 30%' });
+                    /* O vídeo do aluno vem com a legenda gravada embaixo (~73% da
+                       altura): aproximado pelo topo, ela sai do quadro e fica só a
+                       nossa frase — antes eram dois textos um sobre o outro. */
+                    el2.push({ tipo: 'video', src: c.src, volume: 1, deOrigem: c.de, ateOrigem: c.ate + 0.3, x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover', foco: 'center top',
+                        origem: 'center top', anima: { escala: [{ t: 0, v: 1.42 }, { t: d, v: 1.48, e: 'linear' }] } });
                     el2.push({ tipo: 'forma', forma: 'retangulo', x: 0, y: 0, largura: '100%', altura: '100%', fundo: { tipo: 'gradiente', cores: ['rgba(7,7,10,0)', 'rgba(7,7,10,0.35)', 'rgba(7,7,10,0.9)'], angulo: 180 } });
                     // Tudo acima de 75% da altura: embaixo disso o Instagram põe a legenda e os botões.
                     pTexto(el2, `“${c.frase}”`, 0.3, d, { y: H * 0.54, caixa: false, peso: 600, max: W * 0.08, linhas: 4 });

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);
@@ -751,6 +761,79 @@ async function narrarComGemini(lista, mp3, { voz, direcao } = {}) {
     }
 }
 
+/* Onde estão os rostos em cada foto (studio/rostos.py, pelo uv). Guardado no
+   projeto: a mesma foto não é analisada duas vezes. */
+async function acharRostos(p, srcs) {
+    const guardado = (p.acervo && p.acervo.rostos) || {};
+    const falta = srcs.filter((s0) => !(s0 in guardado));
+    if (falta.length) {
+        const uv = acharUv();
+        const r = await new Promise((resolve) => {
+            const args = ['run', '--quiet', '--python', '3.12', '--with', 'mediapipe<0.10.22', '--with', 'opencv-python', '--with', 'numpy', 'python', path.join(PY, 'rostos.py'), ...falta.map((x) => path.join(p.pasta, x))];
+            const pr = uv ? spawn(uv, args) : spawn(python() || 'python3', [path.join(PY, 'rostos.py'), ...falta.map((x) => path.join(p.pasta, x))]);
+            let out = '';
+            pr.stdout.on('data', (d) => { out += d; });
+            pr.on('close', () => { try { resolve(JSON.parse(out.trim().split('\n').pop())); } catch { resolve({ ok: false }); } });
+            pr.on('error', () => resolve({ ok: false }));
+        });
+        if (r && r.ok) {
+            for (const [cheio, info] of Object.entries(r.fotos || {})) guardado[path.relative(p.pasta, cheio).replace(/\\/g, '/')] = info;
+            for (const x of falta) if (!(x in guardado)) guardado[x] = null;
+            projeto.salvar(p.id, { acervo: { ...(projeto.ler(p.id).acervo || {}), rostos: guardado } });
+        }
+    }
+    return guardado;
+}
+
+/* O DEPOIMENTO cortado na PALAVRA, não no trecho: começa na primeira palavra
+   da frase e termina logo depois da última, com fade, a voz normalizada e um
+   respiro no fim. "Fica sempre um 'é', um 'e' das pessoas… a música muito
+   alta e não dá pra ouvir as pessoas" (25/09). */
+async function prepararDepoimento(p, c) {
+    const origem = path.join(p.pasta, c.src);
+    if (!fs.existsSync(origem) || c.pronto) return {};
+    let de = c.de, ate = c.ate;
+    try {
+        const cfg = require('../config').loadConfig();
+        const amostra = path.join(p.pasta, 'midia', `depo-amostra-${Date.now().toString(36)}.mp3`);
+        await video.rodar(video.ffmpeg(), ['-y', '-ss', String(Math.max(0, c.de - 1.5)), '-t', String(c.ate - c.de + 3), '-i', origem, '-ac', '1', '-ar', '16000', '-b:a', '32k', amostra], { timeout: 60000 });
+        const tr = await require('../api').requestTranscricao(cfg.server, { token: cfg.token, audio: fs.readFileSync(amostra).toString('base64'), nome: 'd.mp3', idioma: 'pt' });
+        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 || '');
+        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 (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; }
+    } catch { /* fica o trecho pedido */ }
+    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.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, origem: { src: c.src, de: c.de, ate: c.ate } };
+}
+
+/* A narração com cache (a mesma fala, na mesma direção, não é gerada duas vezes). */
+async function narrarComCache(lista, mp3, { voz, direcao } = {}) {
+    const chave = require('crypto').createHash('sha1').update(JSON.stringify([lista.map((x) => x.texto), voz || '', direcao || ''])).digest('hex').slice(0, 16);
+    const dir = path.join(os.homedir(), '.primocode', 'studio', 'cache-voz');
+    const cm = path.join(dir, chave + '.mp3'), cj = path.join(dir, chave + '.json');
+    if (fs.existsSync(cm) && fs.existsSync(cj)) { fs.copyFileSync(cm, mp3); return { ok: true, ...JSON.parse(fs.readFileSync(cj, 'utf8')) }; }
+    const v = await narrarComGemini(lista, mp3, { voz, direcao });
+    if (v.ok) { try { fs.mkdirSync(dir, { recursive: true }); fs.copyFileSync(mp3, cm); fs.writeFileSync(cj, JSON.stringify({ voz: v.voz, segundos: v.segundos, partes: v.partes })); } catch { /* sem cache */ } }
+    return v;
+}
+
 /* A MÚSICA TEM LETRA? O acervo não diz se a faixa é instrumental, então ela
    é ouvida: 25 s do meio vão para a transcrição, e mais de 6 palavras é voz
    cantada. Sem servidor para ouvir, a faixa passa (melhor música que nenhuma). */
@@ -879,6 +962,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, '
@@ -930,9 +1024,47 @@ async function prepararRoteiro(p, args) {
                 }
             } catch { /* o próximo termo */ }
         }
-        const fotosC = acervo.fotos.map((f) => ({ src: f.src, tipo: 'imagem' }));
+        /* 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
+           onde estão os rostos, para o recorte vertical não cortar ninguém. */
+        const TELA = /dashboard|pauta|kpi|tend[eê]ncias|landing|review|tela|screen|painel|relat[oó]rio/i;
+        const MINI = /poster|face \d+|\bthumb/i;
+        const fotosC = acervo.fotos.filter((f) => !MINI.test(f.alt || ''))
+            .map((f) => ({ src: f.src, tipo: 'imagem', cat: TELA.test(f.alt || '') ? 'tela' : 'pessoas', alt: f.alt }));
+        const rostos = await acharRostos(p, fotosC.map((f) => f.src));
+        for (const f of fotosC) if (rostos[f.src]) f.rosto = rostos[f.src];
+        // Os depoimentos: cortados na palavra, com a voz no volume certo e fade.
+        for (const pt of partes) {
+            if (pt.tipo !== 'depoimento') continue;
+            for (const c of pt.clipes || []) Object.assign(c, await prepararDepoimento(p, c));
+        }
+        // A voz FORTE: a parte com "falaForte" é narrada à parte, com a direção dela.
+        const fortes = {};
+        let iNarr = 0;
+        for (const [i, pt] of partes.entries()) {
+            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,
+                    // 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++;
+        }
         const r = cinema.montarCinema({ roteiro, largura, altura, tempos: v.partes, narracao: path.relative(p.pasta, mp3).replace(/\\/g, '/'),
-            sons: sonsC, trilha: trilhaC, fotos: fotosC });
+            sons: sonsC, trilha: trilhaC, fotos: fotosC, fortes });
         if (r.ok) projeto.anotar(p.id, 'plano', `estilo cinema: ${r.resumo.cenas} cenas, ${r.resumo.segundos}s`);
         return r;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "9.8.0-beta.20",
+  "version": "9.8.0-beta.22",
   "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/rostos.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""rostos.py — onde estão as pessoas em cada foto.
+
+    "Aparecem três homens ali, ela está cortada, não dá pra ver ninguém."
+    (25/09/2026)
+
+Foto deitada num vídeo em pé perde dois terços da largura. Recortar pelo
+centro corta as pessoas. Aqui se acha o retângulo que cobre todos os rostos
+da foto (MediaPipe, o mesmo do recorte da pessoa), e o vídeo enquadra nele —
+ou, quando os rostos não cabem no recorte, mostra a foto inteira.
+
+Uso:
+    python3 rostos.py foto1.webp foto2.jpg …
+Saída (JSON): {"ok": true, "fotos": {"foto1.webp": {"largura", "altura", "n",
+               "cx", "cy", "x0", "x1", "y0", "y1"}}}   (tudo de 0 a 1)
+"""
+
+import json
+import sys
+
+
+def main():
+    try:
+        import cv2
+        import mediapipe as mp
+    except Exception as e:  # sem as bibliotecas, ninguém é enquadrado — e não é erro
+        print(json.dumps({"ok": False, "error": f"sem mediapipe: {e}"}))
+        return
+    det = mp.solutions.face_detection.FaceDetection(model_selection=1, min_detection_confidence=0.45)
+    fotos = {}
+    for caminho in sys.argv[1:]:
+        img = cv2.imread(caminho)
+        if img is None:
+            continue
+        h, w = img.shape[:2]
+        r = det.process(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
+        caixas = []
+        for d in (r.detections or []):
+            b = d.location_data.relative_bounding_box
+            caixas.append((max(0, b.xmin), max(0, b.ymin), min(1, b.xmin + b.width), min(1, b.ymin + b.height)))
+        item = {"largura": w, "altura": h, "n": len(caixas)}
+        if caixas:
+            x0 = min(c[0] for c in caixas); y0 = min(c[1] for c in caixas)
+            x1 = max(c[2] for c in caixas); y1 = max(c[3] for c in caixas)
+            item.update({"x0": round(x0, 3), "y0": round(y0, 3), "x1": round(x1, 3), "y1": round(y1, 3),
+                         "cx": round((x0 + x1) / 2, 3), "cy": round((y0 + y1) / 2, 3)})
+        fotos[caminho] = item
+    print(json.dumps({"ok": True, "fotos": fotos}))
+
+
+if __name__ == "__main__":
+    main()