primocode 9.8.0-beta.15 → 9.8.0-beta.17

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v9.8.0-beta.15
+# PrimoCode v9.8.0-beta.17
 
 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.15
+ ▐▛███▜▌   Primo Code v9.8.0-beta.17
 ▝▜█████▛▘  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/assets.js

@@ -120,7 +120,41 @@ const COLECOES = [
  * O SVG vem com `currentColor` no traço para a cor ser decidida na cena — um
  * ícone com cor cravada no arquivo obriga a baixar de novo para mudar de cor.
  */
+/* ── EMOJI 3D ─────────────────────────────────────────────────────────
+ * "Os emojis, quero emojis da Apple." (25/09/2026) Os da Apple têm direito
+ * autoral e não podem ir num vídeo publicado; os Fluent 3D da Microsoft têm
+ * licença MIT e o mesmo visual brilhante e com volume. "fluent-3d:robot" é o
+ * PNG do repositório oficial (pelo jsDelivr), embutido como <img> — o resto
+ * do render trata igual a um ícone SVG. Sem o 3D, cai no emoji plano. */
+const cache3d = new Map();
+async function emoji3d(nome, { pasta = null } = {}) {
+    if (cache3d.has(nome)) return cache3d.get(nome);
+    const palavras = nome.split('-');
+    const pastas = [
+        palavras.join(' ').replace(/^./, (c) => c.toUpperCase()),
+        palavras.map((w) => w[0].toUpperCase() + w.slice(1)).join(' '),
+    ];
+    for (const pastaGit of pastas) {
+        const url = `https://cdn.jsdelivr.net/gh/microsoft/fluentui-emoji@main/assets/${encodeURIComponent(pastaGit)}/3D/${palavras.join('_')}_3d.png`;
+        try {
+            const png = await pegar(url, { binario: true });
+            if (png && png.length > 1000 && png[0] === 0x89) {
+                if (pasta) guardar(path.join(pasta, 'midia', 'icones', `fluent-3d-${nome}.png`), png, { licenca: 'MIT (Microsoft Fluent UI Emoji)', origem: url });
+                const r = { ok: true, nome: 'fluent-3d:' + nome,
+                    svg: `<img src="data:image/png;base64,${png.toString('base64')}" style="width:100%;height:100%;object-fit:contain;display:block" />` };
+                cache3d.set(nome, r);
+                return r;
+            }
+        } catch { /* a próxima grafia */ }
+    }
+    const plano = await icone('fluent-emoji-flat:' + nome, { pasta });
+    const r = plano.ok ? { ...plano, nome: 'fluent-3d:' + nome } : plano;
+    cache3d.set(nome, r);
+    return r;
+}
+
 async function icone(nome, { pasta = null } = {}) {
+    if (/^fluent-3d:/i.test(String(nome))) return emoji3d(String(nome).split(':')[1], { pasta });
     const m = String(nome || '').match(/^([a-z0-9-]+):([a-z0-9-]+)$/i);
     if (!m) return { ok: false, error: 'o ícone é "coleção:nome", como "lucide:zap"' };
     const url = `https://api.iconify.design/${m[1]}/${m[2]}.svg?color=currentColor`;

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),
@@ -58,7 +64,8 @@ function paleta(marca = {}) {
 /* ── a letra que cabe ─────────────────────────────────────────────────────
  * Largura média do caractere em "em" por família. Não é exata — é o
  * bastante para escolher o maior tamanho que cabe em N linhas, com folga. */
-const LARGURA = { condensada: 0.43, display: 0.56, texto: 0.52, serifa: 0.5 };
+// Com folga: medido em 25/09, 0,52 deixava "Fundadores" quebrar no meio no card.
+const LARGURA = { condensada: 0.46, display: 0.6, texto: 0.58, serifa: 0.54 };
 const FAMILIA_TIPO = (f) => (/condensed|narrow|anton|oswald|bebas|teko|league gothic/i.test(f) ? 'condensada'
     : /serif|fraunces|playfair|garamond|lora|newsreader|spectral|baskerville|dm serif/i.test(f) ? 'serifa'
         : /black|bricolage|archivo|sora|grotesk|syne|unbounded/i.test(f) ? 'display' : 'texto');
@@ -106,6 +113,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 +142,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,12 +179,22 @@ 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', foco: 'center 28%',
+                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({
                 tipo: 'forma', forma: 'circulo', largura: R, altura: R, x: Math.round(canto[0]), y: Math.round(canto[1]),
-                cor: p.tipo === 'numero' ? cor.sobreDestaque : cor.destaque, opacidade: p.tipo === 'numero' ? 0.12 : (cor.escuro ? 0.22 : 0.16),
+                // O brilho alterna entre o destaque e a cor de apoio: as duas cores da marca aparecem.
+                cor: p.tipo === 'numero' ? cor.sobreDestaque : (variante && marca.cores && marca.cores.apoio ? cor.apoio : cor.destaque), opacidade: p.tipo === 'numero' ? 0.12 : (cor.escuro ? 0.26 : 0.16),
                 anima: {
                     desfoque: [{ t: 0, v: Math.round(R * 0.22) }],
                     x: [{ t: 0, v: 0 }, { t: dur, v: variante ? 60 : -60, e: 'suave' }],
@@ -210,6 +228,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 +260,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': {
@@ -260,7 +295,7 @@ function comporRoteiro({ roteiro, modo = 'video', largura = 1920, altura = 1080,
                    vazia embaixo. */
                 const fT = p.titulo ? caber(p.titulo, { largura: W0, linhas: 2, max: H * 0.1, fonte: F.titulo }) : { tamanho: 0, linhas: 0 };
                 const hTit = fT.tamanho * 1.04 * fT.linhas;
-                const hCard0 = colunas > 1 ? (p.tipo === 'passos' ? H * 0.26 : H * 0.44) : H * 0.14;
+                const hCard0 = colunas > 1 ? (p.tipo === 'passos' ? H * 0.26 : H * 0.44) : H * (deitado ? 0.14 : 0.13);
                 const hItens = colunas > 1 ? hCard0 : n * hCard0 + (n - 1) * gap;
                 const bloco = hTit + (hTit ? H * 0.07 : 0) + hItens;
                 const yTit = Math.max(M, (H - bloco) / 2);
@@ -268,12 +303,31 @@ function comporRoteiro({ roteiro, modo = 'video', largura = 1920, altura = 1080,
                 const topo = yTit + hTit + (hTit ? H * 0.07 : 0);
                 const hCard = Math.min(hCard0, colunas > 1 ? H - topo - M : (H - topo - M - gap * (n - 1)) / n);
                 const dur0 = vid ? Math.max(1, (tp.ate || dur) - (tp.de || 0)) : 1;
+                /* Um tamanho de letra para TODOS os itens: o do mais apertado. Cada
+                   item com o seu tamanho deixava um card com a letra maior que os
+                   outros, e esse texto saía do card (medido em 25/09). */
+                const padG = Math.round(Math.min(wCard, hCard) * 0.14);
+                const tamIG = Math.round(Math.min(hCard * (colunas > 1 ? 0.28 : 0.5), H * 0.09));
+                const lwG = colunas > 1 ? wCard - 2 * padG : wCard - (tamIG + 3 * padG);
+                // No vertical a linha é estreita: 3 linhas por item, para a letra caber grande.
+                const linhasG = colunas > 1 ? 4 : (deitado ? 2 : 3);
+                const hTexto = colunas > 1 ? hCard - (padG * 1.8 + tamIG + padG) : hCard - padG;
+                const maxItem = deitado ? Math.min(H * 0.05, hCard * 0.3) : Math.min(W * 0.062, hCard * 0.26);
+                const fits = itens.map((it) => caber(it.texto, { largura: lwG, linhas: linhasG, max: maxItem, fonte: F.texto }));
+                let tamItens = Math.min(...fits.map((f) => f.tamanho));
+                // Só na lista o texto mora DENTRO do card: ali a altura também manda.
+                if (p.tipo === 'lista') {
+                    const linhasReais = Math.max(...itens.map((it) => caber(it.texto, { largura: lwG, linhas: linhasG, max: tamItens, min: tamItens, fonte: F.texto }).linhas));
+                    tamItens = Math.min(tamItens, Math.floor(hTexto / (1.2 * linhasReais)));
+                }
                 itens.forEach((it, k) => {
                     const cx = colunas > 1 ? M + k * (wCard + gap) : M;
                     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) {
@@ -292,7 +346,8 @@ function comporRoteiro({ roteiro, modo = 'video', largura = 1920, altura = 1080,
                     const tx = colunas > 1 ? cx + pad : cx + pad + tamI + pad;
                     const ty = colunas > 1 ? cy + pad + tamI + pad * 0.8 : cy + hCard / 2;
                     const lw = colunas > 1 ? wCard - 2 * pad : wCard - (tamI + 3 * pad);
-                    const fit = caber(it.texto, { largura: lw, linhas: colunas > 1 ? 4 : 2, max: Math.min(H * 0.05, hCard * 0.3), fonte: F.texto });
+                    const fit0 = caber(it.texto, { largura: lw, linhas: linhasG, max: tamItens, min: Math.min(18, tamItens), fonte: F.texto });
+                    const fit = { tamanho: Math.min(fit0.tamanho, tamItens), linhas: fit0.linhas };
                     els.push({
                         tipo: 'texto', texto: it.texto, fonte: F.texto, peso: 650, tamanho: fit.tamanho, cor: tinta, entrelinha: 1.2,
                         x: Math.round(tx), y: Math.round(colunas > 1 ? ty : ty - fit.tamanho * 1.2 * fit.linhas / 2), largura: Math.round(lw), anima: entra,
@@ -310,6 +365,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;
             }
@@ -329,13 +385,19 @@ function comporRoteiro({ roteiro, modo = 'video', largura = 1920, altura = 1080,
                 const src = m && typeof m === 'object' ? m.src : m;
                 if (src) {
                     const ehVideo = m && typeof m === 'object' && m.tipo === 'video';
-                    els.push({ tipo: ehVideo ? 'video' : 'imagem', src, ...(ehVideo ? { volume: 0 } : {}), x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover', anima: { escala: [{ t: 0, v: 1.12 }, { t: dur, v: 1, e: 'suave' }] } });
+                    // O enquadramento puxa para cima: é onde ficam os rostos.
+                    els.push({ tipo: ehVideo ? 'video' : 'imagem', src, ...(ehVideo ? { volume: 0 } : {}), x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover', foco: 'center 28%', anima: { escala: [{ t: 0, v: 1.12 }, { t: dur, v: 1, e: 'suave' }] } });
                     els.push({ tipo: 'forma', forma: 'retangulo', x: 0, y: 0, largura: '100%', altura: '100%', fundo: { tipo: 'gradiente', cores: ['rgba(0,0,0,0)', 'rgba(0,0,0,0.25)', 'rgba(0,0,0,0.85)'], angulo: 180 } });
                 }
-                const larg = W0 * 0.8;
-                const fit = caber(p.titulo || '', { largura: larg, linhas: 2, max: H * 0.1, fonte: F.titulo });
+                const larg = W0 * (deitado ? 0.8 : 1);
+                const fit = caber(p.titulo || '', { largura: larg, linhas: 2, max: H * (deitado ? 0.1 : 0.06), fonte: F.titulo });
                 const hT = fit.tamanho * 1.04 * fit.linhas;
-                const yT = H - M - hT - (p.sub ? H * 0.08 : 0);
+                /* Vídeo da marca (depoimento, bastidor) costuma ter o nome da
+                   pessoa gravado embaixo: o título vai para o alto, com o véu
+                   de cima, para não escrever por cima dele. */
+                const noTopo = Boolean(m && typeof m === 'object' && m.tipo === 'video');
+                if (noTopo) els.push({ tipo: 'forma', forma: 'retangulo', x: 0, y: 0, largura: '100%', altura: '100%', fundo: { tipo: 'gradiente', cores: ['rgba(0,0,0,0.8)', 'rgba(0,0,0,0.2)', 'rgba(0,0,0,0)'], angulo: 180 } });
+                const yT = noTopo ? M * 1.2 : H - M - hT - (p.sub ? H * 0.08 : 0);
                 if (p.titulo) titulo(p.titulo, { y: yT, larg, max: fit.tamanho, cor: '#FFFFFF', de: 0.3 });
                 if (p.sub) linhaFina(p.sub, { y: yT + hT + H * 0.02, larg, c: 'rgba(255,255,255,0.8)', de: 0.7 });
                 break;

package/lib/estudio/edicao.js

@@ -116,7 +116,7 @@ function iconeDe(palavra) {
     if (!w || VAZIAS.has(w)) return null;
     for (const [raizes, nome] of ICONES) {
         for (const r of raizes) {
-            if (r.length <= 3 ? w === r : w.startsWith(r)) return 'fluent-emoji-flat:' + nome;
+            if (r.length <= 3 ? w === r : w.startsWith(r)) return 'fluent-3d:' + nome;
         }
     }
     return null;

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');
 
@@ -198,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) {
@@ -217,11 +293,21 @@ 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) };
         }
         projeto.salvarPlano(args.id, r.plano, args.motivo || 'montado do roteiro');
+        // O roteiro fica guardado: ajustar uma frase é mandar o roteiro de novo, não reescrever tudo.
+        try { fs.writeFileSync(path.join(p.pasta, 'roteiro.json'), JSON.stringify(args.roteiro, null, 2)); } catch { /* segue */ }
         projeto.salvar(args.id, { duracao: conferida.duracao });
         return {
             ok: true, duracao: conferida.duracao, ...r.resumo, resumo: plano.resumo(r.plano),
@@ -593,12 +679,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']);
@@ -607,12 +763,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') {
@@ -621,7 +808,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, '/');
@@ -635,7 +824,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,
@@ -772,6 +961,36 @@ async function ferramentaRender(args, ctx = {}) {
 
 // ── estudio_site ─────────────────────────────────────────────────────────
 
+/* A PALETA INTEIRA do site, não só a primeira cor. O fundo é o neutro
+   escuro que o site mais usa (#121218 na Paris Group); o destaque é a cor da
+   marca que mais aparece sobre ele (o laranja, não o azul escuro que some); o
+   apoio é a seguinte. A fonte serifada, quando existe, vai para citação. */
+function paletaDoSite(r) {
+    const hexRgb = (h) => { const n = parseInt(String(h).slice(1).padEnd(6, '0').slice(0, 6), 16); return [n >> 16, (n >> 8) & 255, n & 255]; };
+    const luz = (h) => { const [a, b, c] = hexRgb(h); return (0.299 * a + 0.587 * b + 0.114 * c) / 255; };
+    const sat = (h) => { const v = hexRgb(h); return (Math.max(...v) - Math.min(...v)) / 255; };
+    const neutras = ((r.cores && (r.cores.neutras || r.cores.fundo)) || []).map((x) => x.cor || x).filter((c) => /^#/.test(c));
+    const fundo = neutras.find((c) => luz(c) < 0.15 && luz(c) > 0.02) || neutras.find((c) => luz(c) < 0.2) || undefined;
+    const base = fundo || '#121218';
+    const marca = ((r.cores && r.cores.marca) || []).map((x) => x.cor).filter(Boolean);
+    const nota = (c) => sat(c) * 1.2 + Math.abs(luz(c) - luz(base));
+    const ordenadas = [...marca].sort((a, b) => nota(b) - nota(a));
+    const destaque = ordenadas[0];
+    // O apoio é OUTRA cor, de outro matiz: dois laranjas não fazem paleta.
+    const matiz = (h) => { const [a, b, c] = hexRgb(h).map((v) => v / 255); const mx = Math.max(a, b, c), mn = Math.min(a, b, c), d = mx - mn;
+        if (!d) return 0; const x = mx === a ? ((b - c) / d) % 6 : mx === b ? (c - a) / d + 2 : (a - b) / d + 4; return (x * 60 + 360) % 360; };
+    const longe = (a, b) => { const d = Math.abs(matiz(a) - matiz(b)); return Math.min(d, 360 - d) > 60; };
+    const apoio = ordenadas.find((c) => c !== destaque && longe(c, destaque) && sat(c) > 0.3) || ordenadas[1];
+    const fontes = ((r.fontes && r.fontes.declaradas) || []).map((x) => x.fonte).filter((f) => !/mono|menlo|courier|system|arial|helvetica/i.test(f));
+    return {
+        cores: { ...(fundo ? { fundo } : {}), ...(destaque ? { destaque } : {}), ...(apoio ? { apoio } : {}) },
+        fontes: {
+            ...(fontes[0] ? { titulo: fontes.find((f) => !/serif/i.test(f) || /sans/i.test(f)) || fontes[0], texto: fontes.find((f) => !/serif/i.test(f) || /sans/i.test(f)) || fontes[0] } : {}),
+            ...(fontes.find((f) => /serif/i.test(f) && !/sans/i.test(f)) ? { serifa: fontes.find((f) => /serif/i.test(f) && !/sans/i.test(f)) } : {}),
+        },
+    };
+}
+
 async function ferramentaSite(args) {
     let alvo = String(args.url || args.site || '').trim();
 
@@ -801,6 +1020,10 @@ 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 = paletaDoSite(r);
+        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) {
@@ -817,11 +1040,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/estudio/remotion.js

@@ -323,7 +323,7 @@ function Elemento({ el, t, dados }) {
             startFrom={el.deOrigem ? Math.round(el.deOrigem * dados.fps) : undefined}
             endAt={el.ateOrigem ? Math.round(el.ateOrigem * dados.fps) : undefined}
             volume={el.volume ?? 0}
-            style={{ width: '100%', height: '100%', objectFit: el.ajuste || 'cover' }}
+            style={{ width: '100%', height: '100%', objectFit: el.ajuste || 'cover', objectPosition: el.foco || 'center' }}
           />
         </div>
       );

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.15",
+  "version": "9.8.0-beta.17",
   "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"