primocode 9.8.0-beta.14 → 9.8.0-beta.16

package/README.md

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

package/lib/catalogo.js

@@ -126,7 +126,8 @@ const GRUPOS = [
 
             { tool: 'estudio_site', escreve: false, faz: 'lê a identidade visual de uma marca: cores, fontes, logo e o que ela diz de si',
               args: 'url — OU marca: o nome da empresa, quando não há link ("faça um vídeo para a Paris Group"). '
-                + 'id (opcional): anota no caderno do projeto. '
+                + 'id (opcional): anota no caderno do projeto — e com id traz o ACERVO da marca: as fotos e os vídeos '
+                + 'reais do site (que entram sozinhos no vídeo) e os FATOS das páginas (datas, local, números), para o roteiro. '
                 + 'Devolve FATOS medidos, não um roteiro — o roteiro é seu. '
                 + 'Use SEMPRE que o pedido citar uma empresa de verdade: inventar a cor de uma marca que existe '
                 + 'é erro que sai pronto no vídeo entregue. '

package/lib/estudio/acervo-site.js

@@ -0,0 +1,157 @@
+/**
+ * acervo-site.js — as fotos, os vídeos e os fatos da PRÓPRIA marca, tirados
+ * do site dela.
+ *
+ *   "Eu pedi um vídeo pra Paris Group pra anunciar a imersão: ele poderia
+ *    puxar imagens das imersões, vídeos, fotos, etc. e colocar no decorrer do
+ *    vídeo." · "Os roteiros são nada a ver." (25/09/2026)
+ *
+ * O roteiro saía inventado ("sem data, preço nem local", anotou o próprio
+ * modelo) e as imagens eram de banco. O site da marca tem as duas coisas: a
+ * página da imersão diz "6 a 8 out · Chapecó/SC · 20 cadeiras", e a galeria
+ * tem as fotos da sala. Aqui se lê a página inicial e as páginas internas
+ * que combinam com o pedido, e sai:
+ *
+ *   - fotos: as maiores que o site oferece (o maior "w" do srcset), sem logo,
+ *     ícone, SVG nem miniatura;
+ *   - vídeos: os .mp4 que a página toca (depoimento, bastidor);
+ *   - fatos: o texto de cada página, limpo — a matéria-prima do roteiro.
+ */
+
+'use strict';
+
+const { URL } = require('url');
+
+const PALAVRAS_BOAS = ['galeria', 'imers', 'evento', 'sobre', 'about', 'portfolio', 'cases', 'case', 'turma', 'curso', 'produto', 'servic', 'equipe', 'time'];
+const RUIM = /(logo|icon|favicon|sprite|avatar|emoji|badge|\/brand\/|placeholder|blank|pixel|\.svg(\?|$)|-sm\.|\.sm\.|thumb)/i;
+
+function limpar(t) { return String(t || '').replace(/\s+/g, ' ').trim(); }
+
+/** O texto da página, sem script, estilo, menu nem rodapé repetido. */
+function textoDaPagina(html) {
+    let t = String(html || '')
+        .replace(/<script[\s\S]*?<\/script>|<style[\s\S]*?<\/style>|<noscript[\s\S]*?<\/noscript>/gi, ' ')
+        .replace(/<(nav|footer|header)[\s\S]*?<\/\1>/gi, ' ')
+        .replace(/<br\s*\/?>|<\/(p|h\d|li|div|section)>/gi, '. ')
+        .replace(/<[^>]+>/g, ' ');
+    t = t.replace(/&nbsp;/g, ' ').replace(/&amp;/g, '&').replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&[a-z]+;/g, ' ');
+    return limpar(t).replace(/(\.\s*){2,}/g, '. ').slice(0, 2200);
+}
+
+/** A versão maior de cada imagem: no srcset, o maior "w" até 2000. */
+function maiorDoSrcset(srcset) {
+    let melhor = null, largura = 0;
+    for (const parte of String(srcset).split(',')) {
+        const [u, w] = parte.trim().split(/\s+/);
+        const n = parseInt(w, 10) || 1;
+        if (u && n <= 2000 && n >= largura) { melhor = u; largura = n; }
+    }
+    return melhor;
+}
+
+// A mesma foto em tamanhos diferentes (x.sm.webp, x.md.webp, x.lg.webp) é UMA foto.
+const chaveDe = (u) => u.replace(/[?#].*$/, '').replace(/\.(sm|md|lg|xl|\d{2,4}w?)(?=\.[a-z]+$)/i, '').replace(/-\d{3,4}(?=\.[a-z]+$)/, '');
+
+function colherMidia(html, base) {
+    const abs = (u) => { try { return new URL(String(u).replace(/\\\//g, '/'), base).toString(); } catch { return null; } };
+    const fotos = new Map(), videos = new Map();
+    const pesoDe = (u) => (/\.lg\.|1800w|1920|2000/.test(u) ? 3 : /\.md\.|1280/.test(u) ? 2 : 1);
+    const poe = (mapa, u, alt = '') => {
+        const a = abs(u);
+        if (!a || RUIM.test(a) || a.startsWith('data:')) return;
+        const k = chaveDe(a);
+        const atual = mapa.get(k);
+        // Sem alt, o nome do arquivo descreve a foto ("palestrante-plateia-mesas").
+        const doNome = decodeURIComponent(a.split('/').pop().replace(/\.[a-z0-9]+$/i, '').replace(/\.(sm|md|lg)$/i, ''))
+            .replace(/^\d+[-_]?/, '').replace(/[-_]+/g, ' ').replace(/\b(dsc|img|hero)\b\s*\d*/gi, '').trim();
+        if (!atual || pesoDe(a) > pesoDe(atual.url)) mapa.set(k, { url: a, alt: limpar(alt).slice(0, 120) || (atual && atual.alt) || doNome });
+    };
+    let m;
+    const reImg = /<img\b[^>]*>/gi;
+    while ((m = reImg.exec(html))) {
+        const tag = m[0];
+        const alt = (tag.match(/\balt=["']([^"']*)/i) || [])[1] || '';
+        const srcset = (tag.match(/\b(?:srcset|data-srcset)=["']([^"']+)/i) || [])[1];
+        const src = (srcset && maiorDoSrcset(srcset)) || (tag.match(/\b(?:data-src|src)=["']([^"']+)/i) || [])[1];
+        if (src && /\.(jpe?g|png|webp|avif)(\?|$)/i.test(src)) poe(fotos, src, alt);
+    }
+    // Sites em Next/React guardam a galeria num JSON dentro da página: o
+    // caminho da mídia aparece como texto, não como <img>.
+    const reSolto = /["'(]((?:https?:)?\/[^"'()\s]+?\.(?:jpe?g|png|webp|avif|mp4|webm))(?:\?[^"'()\s]*)?["')]/gi;
+    while ((m = reSolto.exec(html))) {
+        const u = m[1];
+        if (/\.(mp4|webm)$/i.test(u)) poe(videos, u);
+        else poe(fotos, u);
+    }
+    const og = (html.match(/<meta[^>]+property=["']og:image["'][^>]+content=["']([^"']+)/i) || [])[1];
+    if (og) poe(fotos, og, 'capa do site');
+    return { fotos: [...fotos.values()], videos: [...videos.values()] };
+}
+
+/** As páginas internas que valem a leitura para ESTE pedido. */
+function paginasRelevantes(html, base, pedido, max = 5) {
+    const host = new URL(base).hostname;
+    const termos = String(pedido || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase()
+        .split(/[^a-z0-9]+/).filter((w) => w.length >= 4);
+    const vistos = new Set();
+    const lista = [];
+    const re = /href=["']([^"'#]+)["']/gi;
+    let m;
+    while ((m = re.exec(html))) {
+        let u;
+        try { u = new URL(m[1], base); } catch { continue; }
+        if (u.hostname !== host || /\.(css|js|png|jpe?g|svg|webp|pdf|ico|xml|json)$/i.test(u.pathname)) continue;
+        const caminho = u.pathname.replace(/\/$/, '');
+        if (!caminho || vistos.has(caminho) || /privacidade|privacy|termos|terms|login|blog\/|cdn-cgi/.test(caminho)) continue;
+        vistos.add(caminho);
+        const c = caminho.toLowerCase();
+        const pontos = termos.filter((t) => c.includes(t.slice(0, 6))).length * 3
+            + PALAVRAS_BOAS.filter((w) => c.includes(w)).length;
+        if (pontos > 0) lista.push({ url: u.toString(), pontos });
+    }
+    return lista.sort((a, b) => b.pontos - a.pontos).slice(0, max).map((x) => x.url);
+}
+
+/**
+ * Lê o site e baixa o acervo para a pasta do projeto.
+ *
+ * @param {object} op
+ * @param {string} op.url
+ * @param {string} op.pedido      o que o usuário pediu (decide quais páginas ler)
+ * @param {string} op.pasta       a pasta do projeto
+ * @param {function} op.buscar    (url) → {corpo} — o leitor de página do identidade.js
+ * @param {function} op.baixar    (item, {pasta, nome, sub}) → {ok, relativo} — o do assets.js
+ */
+async function colher({ url, pedido = '', pasta, buscar, baixar, maxFotos = 16, maxVideos = 4, htmlInicial = null }) {
+    const paginas = [];
+    const inicial = htmlInicial || (await buscar(url)).corpo;
+    paginas.push({ url, html: inicial });
+    for (const u of paginasRelevantes(inicial, url, pedido)) {
+        try { paginas.push({ url: u, html: (await buscar(u)).corpo }); } catch { /* página que não abriu fica de fora */ }
+    }
+
+    const fatos = paginas.map((p) => ({ pagina: p.url, texto: textoDaPagina(p.html) })).filter((f) => f.texto.length > 80);
+    const fotosVistas = new Map(), videosVistos = new Map();
+    // As páginas internas primeiro: a galeria tem mais foto de verdade que a home.
+    for (const p of [...paginas.slice(1), paginas[0]]) {
+        const { fotos, videos } = colherMidia(p.html, p.url);
+        for (const f of fotos) if (!fotosVistas.has(chaveDe(f.url))) fotosVistas.set(chaveDe(f.url), { ...f, pagina: p.url });
+        for (const v of videos) if (!videosVistos.has(chaveDe(v.url))) videosVistos.set(chaveDe(v.url), { ...v, pagina: p.url });
+    }
+
+    const fotos = [], videos = [];
+    for (const f of fotosVistas.values()) {
+        if (fotos.length >= maxFotos) break;
+        const d = await baixar({ url: f.url, titulo: f.alt || 'foto da marca', licenca: 'da própria marca', fonte: 'site' }, { pasta, nome: 'marca-foto', sub: 'midia/marca' });
+        // Menos de 25 KB é ícone ou miniatura, mesmo sem cara de ícone no nome.
+        if (d.ok && d.bytes > 25000) fotos.push({ src: d.relativo, alt: f.alt, pagina: f.pagina });
+    }
+    for (const v of videosVistos.values()) {
+        if (videos.length >= maxVideos) break;
+        const d = await baixar({ url: v.url, titulo: 'vídeo da marca', licenca: 'da própria marca', fonte: 'site' }, { pasta, nome: 'marca-video', sub: 'midia/marca' });
+        if (d.ok && d.bytes > 50000) videos.push({ src: d.relativo, pagina: v.pagina });
+    }
+    return { ok: true, paginas: paginas.map((p) => p.url), fatos, fotos, videos };
+}
+
+module.exports = { colher, colherMidia, paginasRelevantes, textoDaPagina, maiorDoSrcset };

package/lib/estudio/composicao.js

@@ -44,9 +44,15 @@ function paleta(marca = {}) {
     const fundo = c.fundo || '#0E0F14';
     const escuro = luz(fundo) < 0.5;
     const tinta = c.tinta || (escuro ? '#F4F2EC' : '#15161A');
-    const destaque = c.destaque || '#FF6A3D';
+    let destaque = c.destaque || '#FF6A3D';
+    /* A cor da marca precisa aparecer no fundo: o azul #1e3fae da Paris Group
+       sumia no fundo escuro (medido em 25/09). Pouco contraste, e o destaque
+       clareia (no escuro) ou escurece (no claro) até aparecer. */
+    for (let k = 0; k < 6 && Math.abs(luz(destaque) - luz(fundo)) < 0.38; k++) {
+        destaque = misturar(destaque, escuro ? '#FFFFFF' : '#000000', 0.18);
+    }
     return {
-        fundo, tinta, destaque, escuro,
+        fundo, tinta, destaque, escuro, marca: c.destaque || destaque,
         fundo2: misturar(fundo, tinta, escuro ? 0.07 : 0.05),
         apoio: c.apoio || misturar(destaque, tinta, 0.35),
         suave: alfa(tinta, 0.68),
@@ -106,6 +112,7 @@ function registroDe(p, i, n) {
 function iconesDoRoteiro(roteiro) {
     const nomes = new Set();
     for (const p of roteiro.partes || []) {
+        for (const t of [`${p.titulo || ''} ${p.sub || ''}`, p.sim]) { const ic = iconeDoTexto(t); if (ic) nomes.add(ic); }
         for (const it of p.itens || []) {
             const t = typeof it === 'string' ? it : it.texto;
             const ic = (typeof it === 'object' && it.icone) || iconeDoTexto(t);
@@ -134,7 +141,7 @@ function iconeDoTexto(t) {
  * @param {Set}    op.iconesOk  os ícones que existem
  */
 function comporRoteiro({ roteiro, modo = 'video', largura = 1920, altura = 1080, tempos = [], narracao = null,
-    sons = {}, trilha = null, imagens = {}, iconesOk = null }) {
+    sons = {}, trilha = null, imagens = {}, iconesOk = null, fundos = {} }) {
     const partes = (roteiro && roteiro.partes) || [];
     if (!partes.length) return { ok: false, error: 'o roteiro veio sem partes.' };
     const ruins = partes.map((p, i) => (TIPOS.includes(p.tipo) ? null : `parte ${i + 1}: tipo "${p.tipo}" não existe (use ${TIPOS.join(', ')})`)).filter(Boolean);
@@ -171,7 +178,16 @@ function comporRoteiro({ roteiro, modo = 'video', largura = 1920, altura = 1080,
         let fundo = { tipo: 'cor', valor: variante ? cor.fundo2 : cor.fundo };
         let tinta = cor.tinta, destaque = cor.destaque, suave = cor.suave;
         if (p.tipo === 'numero') { fundo = { tipo: 'cor', valor: cor.destaque }; tinta = cor.sobreDestaque; destaque = cor.sobreDestaque; suave = alfa(cor.sobreDestaque, 0.75); }
-        if (p.tipo !== 'imagem') {
+        /* A FOTO DA MARCA DE FUNDO: a cena de texto ganha a sala de verdade
+           atrás, com um véu da cor do fundo para o texto continuar legível. */
+        const fotoFundo = fundos[i];
+        if (fotoFundo && p.tipo !== 'imagem') {
+            const ehV = fotoFundo.tipo === 'video';
+            els.push({ tipo: ehV ? 'video' : 'imagem', src: fotoFundo.src, ...(ehV ? { volume: 0 } : {}), x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover',
+                anima: { escala: [{ t: 0, v: variante ? 1.14 : 1.02 }, { t: dur, v: variante ? 1.02 : 1.14, e: 'suave' }] } });
+            els.push({ tipo: 'forma', forma: 'retangulo', x: 0, y: 0, largura: '100%', altura: '100%',
+                fundo: { tipo: 'gradiente', cores: [alfa(cor.fundo, 0.93), alfa(cor.fundo, 0.72), alfa(cor.fundo, 0.55)], angulo: 90 } });
+        } else if (p.tipo !== 'imagem') {
             const R = Math.round(Math.max(W, H) * 0.62);
             const canto = [[W - R * 0.55, -R * 0.45], [-R * 0.45, H - R * 0.5], [W - R * 0.4, H - R * 0.55], [-R * 0.5, -R * 0.4]][i % 4];
             els.push({
@@ -210,6 +226,22 @@ function comporRoteiro({ roteiro, modo = 'video', largura = 1920, altura = 1080,
             tipo: 'forma', forma: 'retangulo', x, y: Math.round(y), largura: Math.round(W * 0.06), altura: Math.max(6, Math.round(H * 0.008)),
             cor: c, origem: 'left', anima: { escalaX: [{ t: atraso(de), v: 0 }, { t: atraso(de) + 0.5, v: 1, e: 'saida' }] },
         });
+        /* O ÍCONE DA IDEIA: um emoji grande, que salta e depois flutua, do
+           lado livre da cena — o que dá vida a cena de texto sem virar enfeite. */
+        const iconeDaIdeia = (texto, x, y, tam, de = 0.35) => {
+            const ic = iconeDoTexto(texto);
+            if (!ic || (iconesOk && !iconesOk.has(ic))) return false;
+            const q = atraso(de);
+            const t2 = r2(Math.max(q + 0.6, dur * 0.55)), t3 = r2(Math.max(t2 + 0.3, dur));
+            els.push({ tipo: 'icone', nome: ic, tamanho: Math.round(tam), x: Math.round(x), y: Math.round(y), ancora: 'centro',
+                anima: {
+                    escala: [{ t: q, v: 0 }, { t: q + 0.25, v: 1.18, e: 'saida' }, { t: q + 0.42, v: 1, e: 'suave' }],
+                    rotacao: [{ t: q, v: -18 }, { t: q + 0.42, v: 0, e: 'saida' }, { t: t3, v: 6, e: 'suave' }],
+                    y: [{ t: q + 0.42, v: 0 }, { t: t2, v: -16, e: 'suave' }, { t: t3, v: 4, e: 'suave' }],
+                } });
+            if (vid && sons.pop) efeitos.push({ t: r2((tp.de || 0) + q), src: sons.pop, volume: 0.55 });
+            return true;
+        };
         const logo = (x, y, alt) => { if (marca.logo) els.push({ tipo: 'imagem', src: marca.logo, x, y, altura: alt, largura: Math.round(alt * 4), ajuste: 'contain', foco: 'left center', anima: { opacidade: [{ t: atraso(0.3), v: 0 }, { t: atraso(0.3) + 0.4, v: 1 }] } }); };
 
         switch (p.tipo) {
@@ -226,6 +258,7 @@ function comporRoteiro({ roteiro, modo = 'video', largura = 1920, altura = 1080,
                 if (!centro) traco(M, y - H * 0.05);
                 titulo(p.titulo || '', { y, larg, linhas: 3, max: fit.tamanho, x, alinhar: centro ? 'center' : 'left' });
                 if (p.sub) linhaFina(p.sub, { y: y + hT + H * 0.03, larg, x, alinhar: centro ? 'center' : 'left', de: 0.6 });
+                if (!centro && deitado) iconeDaIdeia(`${p.titulo || ''} ${p.sub || ''}`, W - M - W * 0.09, H * 0.5, H * 0.2, 0.5);
                 break;
             }
             case 'numero': {
@@ -273,7 +306,9 @@ function comporRoteiro({ roteiro, modo = 'video', largura = 1920, altura = 1080,
                     const cy = colunas > 1 ? topo : topo + k * (hCard + gap);
                     // O item entra quando a voz chega nele (ou em cascata, no slide).
                     const quando = atraso(vid ? 0.5 + (dur0 * 0.85 - 0.5) * (k / n) : 0.3 + k * 0.12);
-                    const entra = { opacidade: [{ t: quando, v: 0 }, { t: quando + 0.3, v: 1 }], y: [{ t: quando, v: 40 }, { t: quando + 0.45, v: 0, e: 'saida' }] };
+                    // Entra de baixo e depois respira: nada fica parado como slide.
+                    const entra = { opacidade: [{ t: quando, v: 0 }, { t: quando + 0.3, v: 1 }],
+                        y: [{ t: quando, v: 40 }, { t: quando + 0.45, v: 0, e: 'saida' }, { t: Math.max(quando + 0.5, dur), v: k % 2 ? -8 : 8, e: 'suave' }] };
                     if (p.tipo === 'lista') {
                         els.push({ tipo: 'forma', forma: 'retangulo', x: Math.round(cx), y: Math.round(cy), largura: Math.round(wCard), altura: Math.round(hCard), cor: alfa(tinta, cor.escuro ? 0.07 : 0.06), raio: Math.round(H * 0.025), anima: entra });
                     } else if (k < n - 1 && colunas > 1) {
@@ -310,6 +345,7 @@ function comporRoteiro({ roteiro, modo = 'video', largura = 1920, altura = 1080,
                 els.push({ tipo: 'texto', texto: p.nao || '', fonte: F.texto, peso: 600, tamanho: f1.tamanho, cor: alfa(tinta, 0.5), x: M, y: Math.round(y1), largura: Math.round(larg), entrelinha: 1.2, anima: { opacidade: [{ t: 0.1, v: 0 }, { t: 0.4, v: 1 }] } });
                 els.push({ tipo: 'forma', forma: 'retangulo', x: M, y: Math.round(y1 + f1.tamanho * 0.62), largura: Math.round(Math.min(larg, (p.nao || '').length * f1.tamanho * 0.52)), altura: Math.max(5, Math.round(f1.tamanho * 0.09)), cor: destaque, origem: 'left', anima: { escalaX: [{ t: atraso(meio - 0.3), v: 0 }, { t: atraso(meio), v: 1, e: 'saida' }] } });
                 titulo(p.sim || '', { y: y1 + f1.tamanho * 1.2 * f1.linhas + H * 0.05, larg, linhas: 3, max: f2.tamanho, de: atraso(meio) });
+                if (deitado) iconeDaIdeia(p.sim || '', W - M - W * 0.06, H * 0.22, H * 0.14, meio + 0.3);
                 if (vid && sons.pop) efeitos.push({ t: r2((tp.de || 0) + meio), src: sons.pop, volume: 0.5 });
                 break;
             }

package/lib/estudio/edicao.js

@@ -32,7 +32,10 @@ const VAZIAS = new Set((
     + 'ou mas como mais menos muito muita muitos muitas isso isto esse essa este esta aquele aquela ele ela '
     + 'eles elas eu voce voces nos meu minha seu sua nosso nossa tem ter ser foi era sao esta estao vai vou '
     + 'ja ai aqui la entao tambem so quando onde porque pois ate sobre depois antes cada todo toda todos '
-    + 'todas qual quais quem nao sim ne ta tipo coisa coisas gente fazer faz feito pode podem vamos hoje'
+    + 'todas qual quais quem nao sim ne ta tipo coisa coisas gente fazer faz feito pode podem vamos hoje '
+    // Verbos de ligação e de fala: não são a ideia da frase.
+    + 'mostra mostrar ajuda ajudar deixa deixar usar usa usando sabe saber quer querer precisa precisar '
+    + 'acho olha vem fica ficar falar fala dizer diz ver vai ir estou estava sendo tendo existe chamado'
 ).split(' '));
 
 /* A palavra (sem acento, minúscula, começo dela) → o emoji colorido. Casa
@@ -208,8 +211,8 @@ function camera(i, dur) {
 }
 
 const ESTILOS = {
-    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' },
+    viral: { icones: true, letreiro: true, sons: true, barra: true, apoio: true, recorte: true, fundoRecorte: ['#1B1F3B', '#3A1C71'], destaque: '#FFD400', forte: '#00E0A4' },
+    limpo: { icones: false, letreiro: false, sons: false, barra: false, apoio: true, recorte: false, fundoRecorte: ['#111111', '#333333'], destaque: '#FFFFFF', forte: '#FFD400' },
 };
 
 /**
@@ -225,7 +228,10 @@ 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, imagens = {}, trilha = null }) {
+// Em quais cenas a pessoa é recortada, com a palavra gigante atrás dela.
+const temRecorte = (i) => i % 4 === 2;
+
+function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, estilo = 'viral', sons = {}, iconesOk = null, imagens = {}, trilha = null, recortes = {} }) {
     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.' };
@@ -236,6 +242,7 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
     const total = duracao || lista[lista.length - 1].ate + 0.3;
     const cenas = [];
     const efeitos = [];
+    const infos = [];   // onde cada cena começa e a palavra forte dela — para o recorte
     let lado = 0;
 
     grupos.forEach((g, i) => {
@@ -253,10 +260,37 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
             deOrigem: r2(ini), ateOrigem: r2(ini + dur), volume: 1,
         }];
 
+        infos.push({ ini: r2(ini), dur, forte: forte ? { de: local(forte.de), texto: forte.texto, peso: peso(forte.texto) } : null });
+
+        /* A PALAVRA ATRÁS DA PESSOA: o fundo do quarto some, entra a cor da
+           marca, a palavra forte aparece enorme e a pessoa, recortada, fica
+           na frente dela. É o efeito que mais denuncia edição de videomaker. */
+        const rec = e.recorte && temRecorte(i) ? recortes[i] : null;
+        if (rec && forte) {
+            const vida = r2(rec.ate - rec.de);
+            const some = [{ t: 0, v: 0 }, { t: 0.1, v: 1 }, { t: vida - 0.12, v: 1 }, { t: vida, v: 0 }];
+            elementos.push({
+                tipo: 'forma', forma: 'retangulo', x: 0, y: 0, largura: '100%', altura: '100%', de: rec.de, ate: rec.ate,
+                fundo: { tipo: 'gradiente', cores: [e.fundoRecorte[0], e.fundoRecorte[1]], angulo: 160 }, anima: { opacidade: some },
+            });
+            const palavra = limpaPontuacao(forte.texto).toUpperCase();
+            const fit = Math.round(Math.min(altura * 0.42, (largura * 0.92) / Math.max(3, palavra.length * 0.46)));
+            elementos.push({
+                tipo: 'texto', texto: palavra, fonte: 'Anton', peso: 400, tamanho: fit, cor: e.forte,
+                x: '50%', y: deitado ? '38%' : '34%', ancora: 'centro', de: rec.de, ate: rec.ate,
+                anima: { escala: [{ t: 0, v: 0.6 }, { t: 0.22, v: 1.06, e: 'saida' }, { t: 0.4, v: 1, e: 'suave' }, { t: vida, v: 1.05 }], opacidade: some },
+            });
+            elementos.push({
+                tipo: 'video', src: rec.src, volume: 0, x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover',
+                de: rec.de, ate: rec.ate, anima: { opacidade: some },
+            });
+            if (e.sons && sons.whoosh) efeitos.push({ t: r2(Math.max(0, ini + rec.de - 0.1)), src: sons.whoosh, volume: 0.55 });
+        }
+
         /* 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;
+        const apoio = forte && e.apoio && temApoio(i) && !rec ? imagens[termoDeApoio(forte.texto)] : null;
         if (apoio) {
             const de = local(forte.de - 0.1);
             const vida = Math.min(2.2, dur - de);
@@ -278,7 +312,7 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
         }
 
         // O ícone salta na hora da palavra; sem ícone, o letreiro da ideia.
-        const icone = forte && e.icones && !apoio ? iconeDe(forte.texto) : null;
+        const icone = forte && e.icones && !apoio && !rec ? iconeDe(forte.texto) : null;
         const temIcone = icone && (!iconesOk || iconesOk.has(icone));
         const x = lado++ % 2 === 0 ? '78%' : '22%';
         if (temIcone) {
@@ -298,7 +332,7 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
                 });
                 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) {
+        } else if (forte && e.letreiro && !rec && i % 2 === 0 && peso(forte.texto) >= 7) {
             const de = local(forte.de);
             const vida = Math.min(1.6, dur - de);
             if (vida > 0.5) {
@@ -362,8 +396,10 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
                 ...(trilha ? { trilha: { src: trilha, volume: 0.07, loop: true } } : {}),
             } } : {}),
         },
+        infos,
         resumo: {
             cenas: cenas.length,
+            recortes: Object.keys(recortes).length,
             icones: cenas.reduce((n, c) => n + c.elementos.filter((x) => x.tipo === 'icone').length, 0),
             apoios: cenas.reduce((n, c) => n + c.elementos.filter((x) => x.tipo === 'imagem' || (x.tipo === 'video' && x.volume === 0)).length, 0),
             musica: Boolean(trilha),
@@ -402,4 +438,4 @@ async function prepararSons(pasta, video) {
     return sons;
 }
 
-module.exports = { montarEdicao, prepararSons, iconeDe, peso, frases, blocos, termosDeApoio, termoDeApoio, ESTILOS, ICONES, FOTO };
+module.exports = { montarEdicao, temRecorte, prepararSons, iconeDe, peso, frases, blocos, termosDeApoio, termoDeApoio, ESTILOS, ICONES, FOTO };

package/lib/estudio/index.js

@@ -42,6 +42,7 @@ const identidade = require('./identidade.js');
 const slides = require('./slides.js');
 const edicao = require('./edicao.js');
 const composicao = require('./composicao.js');
+const acervoSite = require('./acervo-site.js');
 
 const PY = path.join(__dirname, '..', '..', 'studio');
 
@@ -81,6 +82,37 @@ function rodarPython(script, args, { timeout = 20 * 60000 } = {}) {
     });
 }
 
+/* O RECORTE DA PESSOA precisa do MediaPipe, e o MediaPipe só existe até o
+   Python 3.12 — no Python 3.14 do Homebrew ele nem instala (medido em
+   25/09: o recorte nunca tinha rodado nesta máquina). Com o `uv`, o script
+   roda num Python 3.12 isolado, baixado uma vez; sem ele, tenta o Python da
+   máquina, como antes. */
+function acharUv() {
+    const { execFileSync } = require('child_process');
+    for (const c of ['uv', path.join(os.homedir(), '.local', 'bin', 'uv'), '/opt/homebrew/bin/uv', '/usr/local/bin/uv']) {
+        try { execFileSync(c, ['--version'], { stdio: 'ignore', timeout: 5000 }); return c; } catch { /* próximo */ }
+    }
+    return null;
+}
+function rodarPessoa(args, { timeout = 40 * 60000 } = {}) {
+    const uv = acharUv();
+    if (!uv) return rodarPython('pessoa.py', args, { timeout });
+    return new Promise((resolve) => {
+        const p = spawn(uv, ['run', '--quiet', '--python', '3.12', '--with', 'mediapipe<0.10.22',
+            '--with', 'opencv-python', '--with', 'numpy', 'python', path.join(PY, 'pessoa.py'), ...args]);
+        let saida = '', erro = '';
+        p.stdout.on('data', (d) => { saida += d.toString(); });
+        p.stderr.on('data', (d) => { erro += d.toString(); });
+        const relogio = setTimeout(() => { try { p.kill(); } catch {} }, timeout);
+        p.on('close', () => {
+            clearTimeout(relogio);
+            try { resolve(JSON.parse(saida.trim().split('\n').pop())); }
+            catch { resolve({ ok: false, error: (erro || saida).slice(-400).trim() || 'o recorte não respondeu' }); }
+        });
+        p.on('error', (e) => { clearTimeout(relogio); resolve({ ok: false, error: e.message }); });
+    });
+}
+
 // ── estudio_projeto ──────────────────────────────────────────────────────
 
 /**
@@ -167,10 +199,85 @@ function listarArquivos(pasta) {
 
 // ── estudio_plano ────────────────────────────────────────────────────────
 
+/* O projeto de AGORA, quando o modelo esquece o id: o criado há menos de
+   30 minutos. Medido com o modelo grátis em 25/09: ele chamou estudio_plano
+   sem id logo depois de criar o projeto, e a tarefa morreu ali. */
+function projetoRecente() {
+    const agora = Date.now();
+    const lista = projeto.listar({ limite: 8 })
+        .filter((x) => x.criado && agora - new Date(x.criado).getTime() < 30 * 60000)
+        .sort((a, b) => new Date(b.criado) - new Date(a.criado));
+    return lista[0] || null;
+}
+
+/** O roteiro é utilizável como veio? (objeto ou JSON, com partes de tipo conhecido) */
+function roteiroValido(r) {
+    let x = r;
+    if (typeof x === 'string') { try { x = JSON.parse(x); } catch { return null; } }
+    const partes = Array.isArray(x) ? x : x && x.partes;
+    if (!Array.isArray(partes) || partes.length < 2) return null;
+    if (!partes.every((pt) => pt && composicao.TIPOS.includes(pt.tipo))) return null;
+    return Array.isArray(x) ? { partes } : x;
+}
+
+// O último site lido, para o projeto que nasceu DEPOIS da leitura.
+let ultimoSite = null;
+
+async function garantirAcervo(p) {
+    if (p.acervo && (p.acervo.fotos || []).length) return p;
+    if (!ultimoSite || Date.now() - ultimoSite.quando > 60 * 60000) return p;
+    try {
+        const a = await acervoSite.colher({ url: ultimoSite.url, pedido: p.pedido || '', pasta: p.pasta, htmlInicial: ultimoSite.html,
+            buscar: identidade.buscar, baixar: assets.baixar });
+        projeto.salvar(p.id, { acervo: { fotos: a.fotos, videos: a.videos, fatos: a.fatos, site: ultimoSite.url }, ...(p.marca ? {} : { marca: ultimoSite.marca }) });
+        projeto.anotar(p.id, 'midia', `acervo do site: ${a.fotos.length} fotos, ${a.videos.length} vídeos`);
+    } catch { /* segue sem acervo */ }
+    return projeto.ler(p.id);
+}
+
+/* O ROTEIRISTA do servidor: quando o modelo não manda um roteiro que preste
+   (nenhum, ou texto corrido), o pedido e os fatos da marca viram o roteiro
+   numa chamada só, com uma tarefa só. */
+async function roteiroDoServidor(p, args) {
+    const cfg = require('../config').loadConfig();
+    const api = require('../api');
+    const pedido = [p.pedido, args.pedido].filter(Boolean).join(' — ');
+    const seg = Number(args.segundos) || Number((pedido.match(/(\d{2,3})\s*(s\b|seg)/i) || [])[1]) || 30;
+    const acervo = p.acervo || {};
+    const r = await api.request(cfg.server, '/api/roteiro', {
+        pedido, segundos: seg,
+        fatos: (acervo.fatos || []).map((f) => f.texto).join('\n\n').slice(0, 5000),
+        fotos: (acervo.fotos || []).length ? `${acervo.fotos.length} fotos reais` : '',
+        site: acervo.site ? new URL(acervo.site).hostname.replace(/^www\./, '') : '',
+        rascunho: typeof args.roteiro === 'string' ? args.roteiro : '',
+    }, cfg.token);
+    if (!r || !r.ok) return { ok: false, error: (r && r.erro) || 'o roteirista não respondeu.' };
+    return { ok: true, roteiro: { ...r.roteiro, marca: (args.roteiro && args.roteiro.marca) || p.marca || undefined } };
+}
+
 async function ferramentaPlano(args) {
-    const p = projeto.ler(args.id);
+    let p = projeto.ler(args.id);
+    // Só quando o id FALTOU: id errado continua sendo erro, para não escrever no projeto errado.
+    if (!p && (args.id == null || String(args.id).trim() === '') && (args.roteiro || args.plano || args.cenas)) {
+        const recente = projetoRecente();
+        if (recente) { args = { ...args, id: recente.id }; p = recente; }
+    }
     if (!p) return semProjeto(args.id);
 
+    /* Roteiro que não serve (texto corrido, JSON quebrado, tipo inventado) ou
+       nenhum, num projeto ainda sem plano: o roteirista escreve. */
+    const valido = args.roteiro ? roteiroValido(args.roteiro) : null;
+    if (!args.plano && !args.cenas && !args.voltarPara && !valido && (args.roteiro || !projeto.lerPlano(args.id))) {
+        p = await garantirAcervo(p);
+        const escrito = await roteiroDoServidor(p, args);
+        if (!escrito.ok) return escrito;
+        args = { ...args, roteiro: escrito.roteiro };
+        projeto.anotar(p.id, 'plano', `roteiro escrito pelo roteirista: ${escrito.roteiro.partes.length} partes`);
+    } else if (valido) {
+        args = { ...args, roteiro: valido };
+        p = await garantirAcervo(p);
+    }
+
     if (args.voltarPara) return projeto.voltarPara(args.id, args.voltarPara);
 
     if (!args.plano && !args.cenas && !args.roteiro) {
@@ -186,7 +293,15 @@ async function ferramentaPlano(args) {
     if (args.roteiro) {
         const r = await prepararRoteiro(p, args);
         if (!r.ok) return r;
-        const conferida = plano.conferir(r.plano, { pasta: p.pasta });
+        let conferida = plano.conferir(r.plano, { pasta: p.pasta });
+        /* A rede de segurança: o elemento que não passa sai, e o vídeo segue.
+           Um defeito num ícone não pode custar o vídeo inteiro. */
+        if (!conferida.ok) {
+            projeto.anotar(p.id, 'defeito', `plano do roteiro reprovou: ${conferida.problemas.slice(0, 4).map((x) => x.onde + ' ' + x.oque).join(' | ')}`);
+            const ruins = new Set(conferida.problemas.map((x) => (String(x.onde).match(/^cenas\[(\d+)\]\.elementos\[(\d+)\]/) || []).slice(1, 3).join(':')).filter((k) => k.includes(':')));
+            r.plano.cenas.forEach((c, i) => { c.elementos = c.elementos.filter((_, j) => !ruins.has(`${i}:${j}`)); });
+            conferida = plano.conferir(r.plano, { pasta: p.pasta });
+        }
         if (!conferida.ok) {
             return { ok: false, error: 'o roteiro virou um plano com problemas (defeito do PrimoCode, não seu).', problemas: conferida.problemas.slice(0, 12) };
         }
@@ -481,12 +596,36 @@ async function ferramentaVideo(args, ctx = {}) {
             } catch { /* segue sem música */ }
         }
 
-        const montado = edicao.montarEdicao({
+        const base = {
             src: path.relative(p.pasta, fonte).replace(/\\/g, '/'),
             duracao: m.segundos, palavras, largura: m.largura, altura: m.altura,
             estilo: args.estilo || 'viral', sons, iconesOk, imagens, trilha,
-        });
+        };
+        let montado = edicao.montarEdicao(base);
         if (!montado.ok) return montado;
+
+        /* A segunda passada: nas frases escolhidas, a pessoa recortada na
+           frente da palavra gigante. Só os trechos que entram são recortados
+           (2 s cada), não o vídeo inteiro — recortar 52 s levaria minutos. */
+        if ((args.estilo || 'viral') === 'viral' && args.recorte !== false) {
+            const recortes = {};
+            for (const [i, info] of montado.infos.entries()) {
+                if (!edicao.temRecorte(i) || !info.forte || info.forte.peso < 9 || Object.keys(recortes).length >= 3) continue;
+                const de = Math.max(0, info.forte.de - 0.15);
+                const ate = Math.min(info.dur, de + 2.2);
+                if (ate - de < 1) continue;
+                const seg = path.join(p.pasta, 'midia', `seg-${i + 1}-${Date.now().toString(36)}.mp4`);
+                const corte = await video.rodar(video.ffmpeg(), ['-y', '-ss', String(info.ini + de), '-t', String(ate - de), '-i', fonte,
+                    '-vf', `scale=${Math.min(1280, m.largura)}:-2`, '-an', '-c:v', 'libx264', '-preset', 'veryfast', seg], { timeout: 120000 });
+                if (!corte.ok) continue;
+                const saida = path.join(p.pasta, 'midia', `pessoa-${i + 1}-${Date.now().toString(36)}.webm`);
+                const r = await rodarPessoa(['recortar', '--entrada', seg, '--saida', saida], { timeout: 10 * 60000 });
+                try { fs.unlinkSync(seg); } catch { /* fica */ }
+                if (!r.ok) break;   // sem MediaPipe, nenhum recorte vai dar: não tenta os outros
+                recortes[i] = { src: path.relative(p.pasta, saida).replace(/\\/g, '/'), de: Math.round(de * 100) / 100, ate: Math.round(ate * 100) / 100 };
+            }
+            if (Object.keys(recortes).length) montado = edicao.montarEdicao({ ...base, recortes });
+        }
         const salvo = await ferramentaPlano({ id: args.id, plano: montado.plano, motivo: `edição automática (${args.estilo || 'viral'})` });
         if (!salvo.ok) return salvo;
         projeto.anotar(p.id, 'edicao', `${montado.resumo.cenas} cenas, ${montado.resumo.icones} ícones, ${cortes} cortes de silêncio`);
@@ -499,7 +638,7 @@ async function ferramentaVideo(args, ctx = {}) {
 
     if (acao === 'recortar-pessoa' || acao === 'pessoa') {
         const saida = path.join(p.pasta, 'midia', `pessoa-${Date.now().toString(36)}.webm`);
-        const r = await rodarPython('pessoa.py', [
+        const r = await rodarPessoa([
             'recortar', '--entrada', alvo, '--saida', saida,
             ...(args.suavizar != null ? ['--suavizar', String(args.suavizar)] : []),
             ...(args.encolher != null ? ['--encolher', String(args.encolher)] : []),
@@ -538,12 +677,82 @@ async function baixarApoio(p, termo, { orientacao = null, video: querVideo = fal
     return null;
 }
 
+/* ── A VOZ DO GEMINI ─────────────────────────────────────────────────────
+ * O roteiro inteiro numa chamada só (o plano grátis tem poucos pedidos por
+ * minuto), e as partes achadas depois na transcrição do próprio áudio: a
+ * primeira palavra de cada parte, procurada em ordem. Sem achar, o tempo é
+ * repartido pelo tamanho do texto de cada parte. */
+const VOZ_GEMINI = { thalita: 'Kore', francisca: 'Aoede', antonio: 'Charon', feminina: 'Kore', masculina: 'Charon' };
+const tokens = (t) => String(t || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+
+function alinharPartes(lista, palavras, total) {
+    const ws = palavras.map((w) => ({ ...w, k: tokens(w.texto)[0] || '' }));
+    const chars = lista.map((x) => x.texto.length);
+    const soma = chars.reduce((a, b) => a + b, 0) || 1;
+    const inicios = [0];
+    let cursor = 0, acum = 0;
+    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];
+        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; }
+        }
+        const idx = achado > cursor ? achado : Math.max(cursor + 1, Math.min(ws.length - 1, esperado));
+        inicios.push(idx);
+        cursor = idx;
+    }
+    return lista.map((_, i) => {
+        const a = ws[inicios[i]], b = ws[(inicios[i + 1] || ws.length) - 1];
+        return { de: i === 0 ? 0 : (a ? a.de : 0), ate: b ? b.ate : total, palavras: [] };
+    });
+}
+
+async function narrarComGemini(lista, mp3, { voz } = {}) {
+    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',
+        }, cfg.token);
+        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'));
+        const taxa = (String(r.formato).match(/rate=(\d+)/) || [])[1] || '24000';
+        const c = await video.rodar(video.ffmpeg(), ['-y', '-f', 's16le', '-ar', taxa, '-ac', '1', '-i', pcm,
+            '-af', 'loudnorm=I=-14:TP=-1.5:LRA=9', '-c:a', 'libmp3lame', '-q:a', '3', mp3], { timeout: 120000 });
+        try { fs.unlinkSync(pcm); } catch { /* fica */ }
+        if (!c.ok) return { ok: false, error: 'não consegui converter a voz' };
+        const med = await video.medir(mp3);
+        const tr = await api.requestTranscricao(cfg.server, { token: cfg.token, audio: fs.readFileSync(mp3).toString('base64'), nome: 'voz.mp3', idioma: 'pt' });
+        const palavras = (tr && tr.palavras) || [];
+        if (!palavras.length) return { ok: false, error: 'sem a transcrição da voz para achar as partes' };
+        return { ok: true, voz: `gemini ${r.voz}`, segundos: med.segundos, partes: alinharPartes(lista, palavras, med.segundos) };
+    } catch (e) {
+        return { ok: false, error: e.message };
+    }
+}
+
 const PROPORCOES = { '16:9': [1920, 1080], '9:16': [1080, 1920], '1:1': [1080, 1080], '4:5': [1080, 1350] };
 
 /** O roteiro vira plano: baixa o que falta, narra, e chama o compositor. */
 async function prepararRoteiro(p, args) {
     const roteiro = typeof args.roteiro === 'string' ? JSON.parse(args.roteiro) : args.roteiro;
     if (Array.isArray(roteiro)) return prepararRoteiro(p, { ...args, roteiro: { partes: roteiro } });
+    /* O que o modelo manda e o disco não tem vira problema de render: um
+       "src" que é endereço da internet vira busca, e um arquivo que não
+       existe na pasta sai. A logo da marca vale só se estiver lá. */
+    const existe = (rel) => rel && !/^https?:/i.test(rel) && fs.existsSync(path.resolve(p.pasta, rel));
+    for (const pt of roteiro.partes || []) {
+        if (pt.src && !existe(pt.src)) { if (!pt.busca && /^https?:/i.test(pt.src)) pt.busca = pt.titulo || ''; delete pt.src; }
+    }
+    if (roteiro.marca) {
+        roteiro.marca = { ...(p.marca || {}), ...roteiro.marca };
+        if (roteiro.marca.logo && !existe(roteiro.marca.logo)) roteiro.marca.logo = (p.marca && existe(p.marca.logo)) ? p.marca.logo : undefined;
+    } else if (p.marca) roteiro.marca = p.marca;
     const partes = roteiro.partes || [];
     const modo = (args.modo || roteiro.modo || (p.formato === 'slides' || p.formato === 'arte' ? 'slides' : 'video'));
     const [largura, altura] = PROPORCOES[roteiro.proporcao || args.proporcao] || (modo === 'slides' ? PROPORCOES['16:9'] : PROPORCOES['16:9']);
@@ -552,12 +761,43 @@ async function prepararRoteiro(p, args) {
     for (const nome of composicao.iconesDoRoteiro(roteiro)) {
         try { const r = await assets.icone(nome); if (r && r.ok) iconesOk.add(nome); } catch { /* sem */ }
     }
-    const imagens = {};
+    /* O ACERVO DA MARCA (guardado pelo estudio_site): as fotos reais entram
+       nas partes de imagem e de FUNDO nas cenas de texto; os vídeos, nas
+       partes de imagem do vídeo. A foto escolhida é a que mais combina, pela
+       descrição, com o que a parte diz. Sem acervo, vale a busca (Pexels). */
+    const acervo = (p.acervo && (p.acervo.fotos || []).length) ? p.acervo : { fotos: [], videos: [] };
+    const usadas = new Set();
+    const palavrasDe = (t) => new Set(String(t || '').normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length >= 4));
+    const melhorFoto = (texto) => {
+        const quer = palavrasDe(texto);
+        let melhor = null, pontos = -1;
+        for (const f of acervo.fotos) {
+            if (usadas.has(f.src)) continue;
+            const n = [...palavrasDe(f.alt)].filter((w) => quer.has(w)).length;
+            if (n > pontos) { melhor = f; pontos = n; }
+        }
+        if (melhor) usadas.add(melhor.src);
+        return melhor ? { src: melhor.src, tipo: 'imagem' } : null;
+    };
+    const videosMarca = [...(acervo.videos || [])];
+    const imagens = {}, fundos = {};
     for (const [i, parte] of partes.entries()) {
-        if (parte.tipo !== 'imagem' || parte.src || !parte.busca) continue;
-        const m = await baixarApoio(p, parte.busca, { orientacao: largura >= altura ? 'landscape' : 'portrait', video: modo === 'video' });
+        if (parte.tipo !== 'imagem' || parte.src) continue;
+        const texto = `${parte.titulo || ''} ${parte.sub || ''} ${parte.fala || ''} ${parte.busca || ''}`;
+        if (modo === 'video' && videosMarca.length && i % 2 === 1) { imagens[i] = { src: videosMarca.shift().src, tipo: 'video' }; continue; }
+        const m = melhorFoto(texto) || (parte.busca ? await baixarApoio(p, parte.busca, { orientacao: largura >= altura ? 'landscape' : 'portrait', video: modo === 'video' }) : null);
         if (m) imagens[i] = m;
     }
+    if (acervo.fotos.length) {
+        const comFundo = ['abertura', 'titulo', 'contraste', 'citacao', 'cta', 'passos'];
+        let alterna = 0;
+        for (const [i, parte] of partes.entries()) {
+            if (!comFundo.includes(parte.tipo)) continue;
+            if (i !== 0 && alterna++ % 2 === 1) continue;   // uma sim, uma não: o respiro também é ritmo
+            const m = melhorFoto(`${parte.titulo || ''} ${parte.sim || ''} ${parte.fala || ''}`);
+            if (m) fundos[i] = m;
+        }
+    }
 
     let tempos = [], narracao = null, sons = {}, trilha = null;
     if (modo === 'video') {
@@ -566,7 +806,9 @@ async function prepararRoteiro(p, args) {
         fs.mkdirSync(path.dirname(arq), { recursive: true });
         fs.writeFileSync(arq, JSON.stringify(lista));
         const mp3 = path.join(p.pasta, 'midia', `narracao-${Date.now().toString(36)}.mp3`);
-        const v = await rodarPython('narrar.py', ['roteiro', '--arquivo', arq, '--saida', mp3, '--voz', String(args.voz || roteiro.voz || 'thalita')], { timeout: 10 * 60000 });
+        // A voz de gente primeiro (Gemini, pelo servidor); o Edge é a reserva.
+        let v = await narrarComGemini(lista, mp3, { voz: args.voz || roteiro.voz });
+        if (!v.ok) v = await rodarPython('narrar.py', ['roteiro', '--arquivo', arq, '--saida', mp3, '--voz', String(args.voz || roteiro.voz || 'thalita')], { timeout: 10 * 60000 });
         if (!v.ok) return v;
         tempos = v.partes;
         narracao = path.relative(p.pasta, mp3).replace(/\\/g, '/');
@@ -580,7 +822,7 @@ async function prepararRoteiro(p, args) {
             }
         } catch { /* sem música */ }
     }
-    return composicao.comporRoteiro({ roteiro, modo, largura, altura, tempos, narracao, sons, trilha, imagens, iconesOk });
+    return composicao.comporRoteiro({ roteiro, modo, largura, altura, tempos, narracao, sons, trilha, imagens, iconesOk, fundos });
 }
 
 /* Sem o tempo de cada palavra, cada trecho é repartido pelas palavras dele,
@@ -746,6 +988,13 @@ async function ferramentaSite(args) {
        uma pasta de projeto, é lixo que ninguém recolhe. */
     const html = r.html;
     delete r.html;                          // o HTML cru não vai para o modelo
+    if (r.ok) {
+        const marcaLida = {
+            cores: { destaque: ((r.cores && r.cores.marca) || [])[0] ? r.cores.marca[0].cor : undefined },
+            fontes: { titulo: ((r.fontes && r.fontes.declaradas) || [])[0] ? r.fontes.declaradas[0].fonte : undefined },
+        };
+        ultimoSite = { url: r.url, html, quando: Date.now(), marca: marcaLida };
+    }
     if (r.ok && args.id && args.logo !== false) {
         const p = projeto.ler(args.id);
         if (p) {
@@ -762,11 +1011,44 @@ async function ferramentaSite(args) {
     if (r.ok && args.id) {
         projeto.anotar(args.id, 'referencia', `leu ${r.url}: ${(r.cores.marca[0] || {}).cor || 'sem cor'} · ${(r.fontes.declaradas[0] || {}).fonte || 'sem fonte'}`);
     }
+
+    /* O ACERVO DA MARCA: as fotos e os vídeos reais do site, e o texto das
+       páginas que combinam com o pedido (lib/estudio/acervo-site.js). As
+       fotos ficam guardadas no projeto e o roteiro as usa sozinho; os fatos
+       voltam para o modelo escrever o roteiro com dado de verdade. */
+    if (r.ok && args.id && args.acervo !== false) {
+        const p = projeto.ler(args.id);
+        if (p) {
+            try {
+                const a = await acervoSite.colher({
+                    url: r.url, pedido: args.pedido || p.pedido || '', pasta: p.pasta, htmlInicial: html,
+                    buscar: identidade.buscar, baixar: assets.baixar,
+                });
+                const marca = { ...ultimoSite.marca, ...(r.logo && r.logo.ok ? { logo: r.logo.src } : {}) };
+                projeto.salvar(args.id, { acervo: { fotos: a.fotos, videos: a.videos, fatos: a.fatos, site: r.url }, marca });
+                projeto.anotar(args.id, 'midia', `acervo do site: ${a.fotos.length} fotos, ${a.videos.length} vídeos, ${a.paginas.length} páginas lidas`);
+                let orcamento = 4200;
+                r.fatos = a.fatos.map((f) => {
+                    const texto = f.texto.slice(0, Math.max(0, Math.min(1400, orcamento)));
+                    orcamento -= texto.length;
+                    return { pagina: f.pagina, texto };
+                }).filter((f) => f.texto);
+                r.acervo = { fotos: a.fotos.length, videos: a.videos.length,
+                    exemplos: a.fotos.slice(0, 6).map((f) => f.alt).filter(Boolean) };
+                r.comoUsar = 'Escreva o roteiro com os FATOS acima (datas, local, números, frases da marca) — nada '
+                    + 'inventado. As fotos e os vídeos reais da marca entram SOZINHOS no vídeo: não precisa pôr '
+                    + '"busca" nas partes de imagem (use tipo "imagem" com só o título). Use as cores, a fonte e '
+                    + 'a logo em roteiro.marca.';
+            } catch (e) {
+                r.acervo = { erro: e.message };
+            }
+        }
+    }
     return r;
 }
 
 module.exports = {
     ferramentaProjeto, ferramentaPlano, ferramentaMidia, ferramentaNarrar,
     ferramentaVideo, ferramentaRender, ferramentaSite,
-    projeto, plano, remotion, assets, video, identidade, slides, python, rodarPython,
+    projeto, plano, remotion, assets, video, identidade, slides, python, rodarPython, alinharPartes,
 };

package/lib/local/cerebro.json

@@ -1,5 +1,5 @@
 {
- "origem": "primocode-server 8.15.0 52f6257",
+ "origem": "primocode-server 8.18.0 437cba2",
  "SYSTEM_NUCLEO": "Você é o PrimoCode, agente de engenharia da ConectaPrimoAI.\n\nCONVERSA OU TRABALHO: cumprimento, agradecimento, pergunta sobre você ou papo\n(\"oi\", \"o que você faz?\") → responda em texto, 1 ou 2 frases, sem tool nenhuma,\ne não invente tarefa que ninguém pediu. Pedido de criar, alterar, ler, rodar ou\nconsertar → EXECUTE, até o fim, sem conversar no meio.\n\nREGRAS ABSOLUTAS (executando):\n1. NUNCA escreva código na resposta. Código vai SEMPRE dentro de uma tool.\n2. NUNCA pergunte ao usuário. Decida e execute.\n3. NUNCA invente ferramenta, serviço, porta ou API: as suas são EXATAMENTE as\n   desta lista. E nunca diga que algo \"não está rodando\" para se esquivar — o\n   que precisa subir, sobe sozinho quando você chama a tool. Prometer o que\n   você não tem, ou culpar um serviço, é o pior erro possível.\n4. Caminhos RELATIVOS (\"index.html\", \"src/game.js\"). Você já está na pasta do\n   projeto: nunca caminho absoluto, nunca \"../\".\n5. Termine SEMPRE com finish(\"frase curta do que foi feito\").\n6. Resposta em texto: no máximo 1 frase, sem markdown.\n7. NUNCA repita uma chamada que já fez. Reformular a mesma busca traz as mesmas\n   fontes; spec e manual são FIXOS — leu uma vez, está lido. Pesquisou e leu a\n   spec? O passo seguinte é CRIAR com o que já tem.\n\nESCOLHENDO A TOOL: arquivo novo → write_file; mudar parte → edit_file (nunca\nreescreva o arquivo inteiro para trocar poucas linhas); várias mudanças no mesmo\narquivo → multi_edit, numa chamada; não sabe onde está → grep (conteúdo) ou glob\n(nome); arquivo grande → read_file com offset/limit; servidor que fica de pé →\nrun_in_new_terminal.\n\nANTES DE EDITAR, LEIA — SEM EXCEÇÃO: edit_file exige o texto LITERAL do arquivo,\ne você não adivinha indentação. read_file (ou grep) PRIMEIRO, edit_file depois.\n\nQUANDO FALHA: leia o erro e conserte. Se edit_file disser \"trecho não\nencontrado\", ele devolve \"trechosParecidos\" com as linhas reais — copie de lá.\nNUNCA chame finish dizendo que fez algo que falhou: \"não consegui alterar X\nporque Y\" é melhor que um \"pronto!\" falso.\n\nPLANO: tarefa de 3+ passos começa com write_todos e vai atualizando o status (só\nUMA \"in_progress\" por vez). Tarefa curta não precisa.\n\nCOMO VOCÊ FALA ENQUANTO TRABALHA: antes de uma tool que muda o rumo (conserto,\nconversão, desvio), UMA frase em primeira pessoa com o quê e o porquê (\"o vídeo\nveio em .avi, vou converter para mp4\"); resolvido, \"feito, continuando\". Passo\nóbvio não precisa. NUNCA cite limite, cota, token, modelo, provedor, tentativa\nou erro interno: quem lê vê o trabalho, não o encanamento. Contornou uma\nfalha? Conte o contorno.\n\nMEMÓRIA: você recebe memory-geral.md (o usuário) e o memory.md do projeto.\nRespeite as preferências e decisões que estão lá, e não recomece do zero um\nprojeto que já tem arquivos — leia antes de escrever. O memory.md do projeto se\ngrava sozinho. Já o memory-geral.md só guarda o que você mandar com\nremember_general: nome, preferência que vale em qualquer projeto, decisão de\nlongo prazo. Sem essa chamada, nada disso sobrevive para a próxima vez.\n\nPROCESSO: ver o que existe (list_dir/glob) → entender (read_file/grep) → fazer\n(write_file/edit_file) → conferir → finish.",
  "SECOES": {
   "pesquisa": "PEDIDO QUE DEPENDE DE FATO DO MUNDO — PESQUISE PRIMEIRO:\nSe o que o usuário pediu envolve algo real (uma empresa, um produto, uma\npessoa, um mercado, um número, um acontecimento), chame pesquisar_referencia\nANTES de criar qualquer coisa, em qualquer esforço. \"Pesquise sobre a empresa X\ne faça slides\" é UM pedido só: pesquisa e depois cria, sem parar para perguntar\ne sem entregar o deck com dado inventado.\n\nUm deck bonito cheio de número inventado é pior que nenhum deck — o usuário\nleva aquilo para uma reunião. Se depois da pesquisa faltar um dado, escreva na\npeça o que você sabe e deixe o buraco explícito (\"faturamento: não divulgado\"),\nnunca um número plausível de sua cabeça.",
@@ -743,7 +743,7 @@
    "type": "function",
    "function": {
     "name": "estudio_site",
-    "description": "Le cores, fontes, logo e discurso de uma marca de verdade. Use SEMPRE que o pedido citar uma empresa. Com id, baixa a logo.",
+    "description": "Le cores, fontes, logo e discurso de uma marca de verdade. Use SEMPRE que o pedido citar uma empresa. Com id, baixa a logo e o ACERVO: fotos e videos reais do site (entram sozinhos no video) e os FATOS das paginas (datas, local, numeros) para escrever o roteiro sem inventar.",
     "parameters": {
      "type": "object",
      "properties": {
@@ -755,6 +755,10 @@
       },
       "id": {
        "type": "string"
+      },
+      "pedido": {
+       "type": "string",
+       "description": "O pedido do usuario: decide quais paginas ler"
       }
      },
      "required": []
@@ -1927,7 +1931,7 @@
    "type": "function",
    "function": {
     "name": "estudio_site",
-    "description": "Le cores, fontes, logo e discurso de uma marca de verdade. Use SEMPRE que o pedido citar uma empresa. Com id, baixa a logo.",
+    "description": "Le cores, fontes, logo e discurso de uma marca de verdade. Use SEMPRE que o pedido citar uma empresa. Com id, baixa a logo e o ACERVO: fotos e videos reais do site (entram sozinhos no video) e os FATOS das paginas (datas, local, numeros) para escrever o roteiro sem inventar.",
     "parameters": {
      "type": "object",
      "properties": {
@@ -1939,6 +1943,10 @@
       },
       "id": {
        "type": "string"
+      },
+      "pedido": {
+       "type": "string",
+       "description": "O pedido do usuario: decide quais paginas ler"
       }
      },
      "required": []

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "9.8.0-beta.14",
+  "version": "9.8.0-beta.16",
   "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": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "start": "node bin/primocode.js",
-    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/skills-de-fora.test.js && node test/skills-novas.test.js && node test/comandos.test.js && node test/estudio.test.js && node test/voz.test.js && node test/voz-conversa.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/nome-projeto.test.js && node test/api-propria.test.js && node test/claude-engine.test.js && node test/codex.test.js && node test/conferir.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/seta.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/autonomia.test.js && node test/desfazer.test.js && node test/desfazer-git.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/app.test.js && node test/app-janela.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js && node test/contexto.test.js && node test/perigo.test.js && node test/rapidez.test.js && node test/mascotes.test.js && node test/comandos-extra.test.js && node test/offline.test.js && node test/edicao.test.js && node test/composicao.test.js"
+    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/skills-de-fora.test.js && node test/skills-novas.test.js && node test/comandos.test.js && node test/estudio.test.js && node test/voz.test.js && node test/voz-conversa.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/nome-projeto.test.js && node test/api-propria.test.js && node test/claude-engine.test.js && node test/codex.test.js && node test/conferir.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/seta.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/autonomia.test.js && node test/desfazer.test.js && node test/desfazer-git.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/app.test.js && node test/app-janela.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js && node test/contexto.test.js && node test/perigo.test.js && node test/rapidez.test.js && node test/mascotes.test.js && node test/comandos-extra.test.js && node test/offline.test.js && node test/edicao.test.js && node test/composicao.test.js && node test/acervo-site.test.js"
   },
   "engines": {
     "node": ">=18.17.0"