primocode 10.4.3 → 10.4.7

package/README.md

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

package/bin/primocode.js

@@ -2875,7 +2875,7 @@ async function main() {
                 vozNaTarefa = false;
                 const ultima = state.history.slice().reverse().find((m) => m.role === 'assistant');
                 if (ultima && ultima.content) vozEmEspera.falar(ultima.content);
-            }
+            } else if (vozEmEspera && vozEmEspera.estado) vozEmEspera.estado('esperando');
             // Recado que chegou tarde demais para a tarefa (ela já tinha
             // acabado): vira o próximo pedido, na ordem. Nada se perde.
             queue.unshift(...sobrasDaCaixa());

package/lib/catalogo.js

@@ -93,7 +93,7 @@ const GRUPOS = [
                 + 'contraste{nao,sim} citacao{texto,autor} imagem{busca,titulo,sub} grafico{titulo,barras:[{rotulo,valor}]} cta{titulo,link} '
                 + 'logo{titulo} cores{cores:[{nome,hex}]} produto{titulo,texto,destaque,selo,barras}. Em qualquer parte: destaque (a palavra-tese), fonte (a fonte citada). O texto da TELA sai da FALA: o título usa palavras que a fala diz, cedo na frase (a tela entra quando a voz diz; palavra que a voz não diz deixa a tela esperando). '
                 + 'visual:{titulo,texto,paleta} (hibrido, cinema, impacto): fonte e cor do cardápio (estudio_midia acao:fontes); sem visual, o PrimoCode sorteia sem repetir os últimos vídeos. '
-                + 'estilo (SEM IMAGEM é o padrão: escolha o motion que serve a ESTE roteiro, ou deixe vazio e ele gira entre gerativo, fluido e impacto): hibrido (SÓ quando a pessoa pediu imagem: foto e vídeo reais + o motion por cima; dê busca:"termo em inglês" só nas partes em que a imagem agrega) | gerativo (= motion: sem template — a tipografia anima nos eixos da fonte numa linha do tempo contínua, composição, fonte, cor e som sorteados do roteiro; modelo3d fone|celular|notebook|relogio|garrafa|lata|caixa: o objeto gira em 3D numa batida — ponha quando o vídeo é de um produto ou objeto físico; ideia abstrata, história ou explicação: deixe vazio; o vídeo tem UMA identidade (2 chãos, 1 acento, 2 fontes) e o fundo só troca na virada de seção — se o roteiro tem atos, dê secao:"nome curto" nas partes, senão o PrimoCode divide; moldura cantos|completa|false: o quadro fixo do reel (cantos, o assunto no alto, "01 · seção", o tempo) — ponha só se o vídeo pede cara de peça de design; vazio, o PrimoCode alterna com memória e às vezes não põe; heroi em cada parte: o desenho da batida além do texto, tirado do CONTEÚDO — um ícone do Iconify do objeto que a fala cita ("mdi:bread-slice", "mdi:qrcode"; procure com estudio_midia acao:icones), um 3D do kit (raio|relogio|check|balao|escudo|coracao|estrela|sol|play|engrenagem|cadeado|barras|fone|onda|celular|seta|bateria) ou "nenhum" quando a tipografia basta; forma abstrata (explosao|poligono|esfera|toro|truchet|aneis|grade|rastro) só em assunto abstrato ou de tecnologia — numa conversa de padaria, nunca; ambiente limpo|luz|bokeh e acento traco|viagem (o ponto que viaja entre as batidas): vazio, o PrimoCode escolhe com memória e o bokeh quase não sai fora de tecnologia) | classico (o motion 3D antigo) | vox (explainer editorial: tinta sobre papel, câmera que conta a frase) | '
+                + 'estilo (SEM IMAGEM é o padrão: escolha o motion que serve a ESTE roteiro, ou deixe vazio e ele gira entre gerativo, fluido e impacto): hibrido (SÓ quando a pessoa pediu imagem: foto e vídeo reais + o motion por cima; dê busca:"termo em inglês" só nas partes em que a imagem agrega) | gerativo (= motion: sem template — a tipografia anima nos eixos da fonte numa linha do tempo contínua, composição, fonte, cor e som sorteados do roteiro; modelo3d fone|celular|notebook|relogio|garrafa|lata|caixa: o objeto gira em 3D numa batida — ponha quando o vídeo é de um produto ou objeto físico; ideia abstrata, história ou explicação: deixe vazio; o vídeo tem UMA identidade (2 chãos, 1 acento, 2 fontes) e o fundo só troca na virada de seção — se o roteiro tem atos, dê secao:"nome curto" nas partes, senão o PrimoCode divide; moldura cantos|completa: o quadro fixo do reel (cantos, o assunto no alto, "01 · seção", o tempo) — SÓ quando a pessoa pedir; vazio = sem moldura (ela entrega que o vídeo foi gerado); heroi em cada parte: o desenho da batida além do texto, tirado do CONTEÚDO — um ícone do Iconify do objeto que a fala cita ("mdi:bread-slice", "mdi:qrcode"; procure com estudio_midia acao:icones), um 3D do kit (raio|relogio|check|balao|escudo|coracao|estrela|sol|play|engrenagem|cadeado|barras|fone|onda|celular|seta|bateria) ou "nenhum" quando a tipografia basta; forma abstrata (explosao|poligono|esfera|toro|truchet|aneis|grade|rastro) só em assunto abstrato ou de tecnologia — numa conversa de padaria, nunca; ambiente limpo|luz|bokeh e acento traco|viagem (o ponto que viaja entre as batidas): vazio, o PrimoCode escolhe com memória e o bokeh quase não sai fora de tecnologia) | classico (o motion 3D antigo) | vox (explainer editorial: tinta sobre papel, câmera que conta a frase) | '
                 + 'marca (brand reveal: brilho, letras em vetor, marca cromada, padrão) | lancamento (produto: cartões, painel, calendário) | fluido (minimalista: uma ideia por batida, a forma de uma vira a próxima, sem corte; paleta noite|breu|preto|cobalto (escuras) ou lavanda|creme|laranja|branco (claras) — escolha pelo assunto e NÃO repita a do vídeo anterior; vazio, o PrimoCode escolhe; fontesFluido aprovado|editorial|revista|carater|tecnico|classico, vazio gira) | impacto | cinema | personagem (o vídeo GRAVADO em 3D — cada parte é UMA fala {falante, texto, emocao?, destaque?}, sem tipo: personagens modelados — gente ou robô — conversando num set de podcast/estúdio/escritório, a boca segue a voz, gestos, e a câmera corta entre aberto, ombro e close; use quando o pedido fala em personagem, boneco, avatar, podcast, entrevista, ou alguém FALANDO em 3D. Com dois falantes (falante em cada parte) eles conversam; personagens:{"nome":{tipo:robo|pessoa, pele, cabelo:curto|cacheado|longo|topete|coque|careca, corCabelo, roupa, oculos, barba, rotulo}} — nome de IA vira robô sozinho; emocao feliz|serio|surpreso|pensativo|animado|curioso e destaque:"texto curto" (o cartão na tela) em cada parte; cenario podcast|estudio|escritorio|noite). '
                 + 'marca e lancamento aceitam visual:orbe|vetor|esfera|grade|site|padrao|cromo|cartoes|painel|cores numa parte. marca.nome dá o nome. '
                 + 'voz (thalita|antonio|francisca). DUAS VOZES (o pedido fala em dois narradores, diálogo, conversa, entrevista): roteiro.vozes {"nome":"antonio","outro":"thalita"} e falante:"nome" em cada parte — cada um sai na sua voz. Ajuste fino: plano: {formato:{largura,altura,fps}, cenas:[…], audio:{…}} — ou cenas direto. '

package/lib/claude-engine.js

@@ -668,6 +668,6 @@ module.exports = {
     MODELO_CLAUDE, argsDoModelo, argsDoMotor,
     SKILL_DIR, SKILL_PATH, garantirSkill,
     temClaudeCode, temOrca, orcaAlcancavel, escolherCaminho,
-    garantirEngine, requestAct, emitirDecisao,
+    garantirEngine, requestAct, emitirDecisao, rodarClaude,
     _emitirDecisao: emitirDecisao,
 };

package/lib/entrada.js

@@ -191,6 +191,10 @@ function montar(e) {
     if (st.linhas) {
         for (const linha of st.linhas) out.push(' ' + truncate(linha, largura - 2));
     } else {
+        /* Uma linha vazia entre o painel e o rodapé. Colado, o rodapé parecia
+           SOBREPOSTO ao painel em terminais de entrelinha apertada (o Orca):
+           o fundo do painel encostava nas letras da pasta. */
+        out.push('');
         const esq = st.esquerda || '';
         const dir = st.direita || '';
         const sobra = largura - 2 - visibleWidth(esq) - visibleWidth(dir);

package/lib/estudio/batida.js

@@ -141,7 +141,16 @@ const CONFIANCA_MINIMA = 0.7;   // abaixo disso a batida é chute: a faixa entra
 
 const TRANSICOES_FORTES = new Set(['soco', 'flash', 'chicote', 'zoom', 'giro']);
 
-/** Os cortes do plano no tempo do vídeo: [{t, peso}]. Corte de impacto pesa 3; o maior impacto vira `impacto`. */
+/**
+ * Os cortes do plano no tempo do vídeo: [{t, peso}]. Corte de impacto pesa 3; o maior impacto vira `impacto`.
+ *
+ * O GERATIVO É UMA CENA SÓ: as batidas dele moram dentro da partitura do kit
+ * (cena.elementos[].partitura.batidas). Contando só as cenas, o vídeo dele
+ * tinha 0 cortes, e o log dizia "0 de 0 cortes caem na batida" (10/10). Cada
+ * batida (menos a primeira) é um corte; a troca de campo (fundo de cor) e a
+ * tese gigante pesam 3. O corte leva a referência da batida para ser
+ * ENCOSTADO na batida da música depois (melhorInicio).
+ */
 function cortesDoPlano(plano) {
     const cortes = [];
     let t = 0;
@@ -150,35 +159,111 @@ function cortesDoPlano(plano) {
             const tr = cena.transicao && (cena.transicao.tipo || cena.transicao);
             cortes.push({ t: r3(t), peso: cena.impacto || TRANSICOES_FORTES.has(tr) ? 3 : 1 });
         }
+        for (const el of cena.elementos || []) {
+            const bs = el && el.partitura && Array.isArray(el.partitura.batidas) ? el.partitura.batidas : null;
+            if (!bs) continue;
+            bs.forEach((b, j) => {
+                if (j === 0) return;
+                const forte = b.troca || b.comp === 'gigante' || b.campoCor;
+                // A palavra que a batida mostra: a entrada da primeira linha (sem linha, a batida mesmo).
+                const ts = (b.linhas || []).map((l) => l.t).filter((x) => typeof x === 'number');
+                const palavra = ts.length ? Math.min(...ts) : b.de;
+                cortes.push({ t: r3(t + b.de), peso: forte ? 3 : 1, ref: { bs, j, base: t, palavra } });
+            });
+        }
         t += Number(cena.duracao) || 0;
     }
-    return cortes;
+    return cortes.sort((a, b) => a.t - b.t);
+}
+
+/** A batida mais perto de `t` numa lista ordenada: {bt, d}. */
+function maisPerto(lista, t) {
+    let lo = 0, hi = lista.length - 1;
+    while (lo < hi) { const m = (lo + hi) >> 1; if (lista[m] < t) lo = m + 1; else hi = m; }
+    const a = lista[lo], b = lo > 0 ? lista[lo - 1] : Infinity;
+    return Math.abs(a - t) <= Math.abs(b - t) ? { bt: a, d: Math.abs(a - t) } : { bt: b, d: Math.abs(b - t) };
+}
+
+/* Quanto a troca de tela pode se afastar da PALAVRA que ela mostra: a fala
+   continua onde estava, e a troca adianta ou atrasa a palavra em no máximo
+   150 ms — abaixo do que o olho percebe como fora de sincronia. A janela é
+   medida da palavra, não do corte de antes (que já vinha ~120 ms adiantado). */
+const EMPURRAO = 0.15;
+/** A janela [de, até] em que o corte pode cair, no tempo do vídeo. */
+const janelaDo = (c) => (c.ref ? [c.ref.base + c.ref.palavra - EMPURRAO, c.ref.base + c.ref.palavra + EMPURRAO] : [c.t, c.t]);
+/** A batida da música (no tempo do vídeo) dentro da janela, a mais perto do corte; ou null. */
+function batidaNaJanela(bats, c, o) {
+    const [a, z] = janelaDo(c);
+    let lo = 0, hi = bats.length;
+    while (lo < hi) { const m = (lo + hi) >> 1; if (bats[m] - o < a) lo = m + 1; else hi = m; }
+    let melhor = null;
+    for (let i = lo; i < bats.length && bats[i] - o <= z; i++) {
+        const v = bats[i] - o;
+        if (!melhor || Math.abs(v - c.t) < Math.abs(melhor - c.t)) melhor = v;
+    }
+    return melhor;
 }
+const MIN_BATIDA = 0.6;   // nenhuma batida fica mais curta que isto depois do empurrão
 
 /**
  * De onde a faixa começa (em s) para o máximo de cortes cair numa batida.
  * Procura em passos de 10 ms, de 0 a `maximo`; empate fica com o início mais
  * cedo. O corte mais pesado ganha bônus se cair num acento.
+ *
+ * Os cortes do gerativo (com `ref`) contam como "na batida" até EMPURRAO de
+ * distância, porque depois da escolha eles são ENCOSTADOS nela: a batida do
+ * vídeo anda (b.de e o ate da anterior), e o golpe da tese também. O plano é
+ * mudado no lugar — é ele que vai para o render.
  */
 function melhorInicio(cortes, analise, { maximo = 0, tolerancia = 0.05 } = {}) {
     const bats = (analise && analise.batidas) || [];
     if (!cortes.length || bats.length < 4 || (analise.confianca != null && analise.confianca < CONFIANCA_MINIMA)) return { inicio: 0, alinhados: 0, total: cortes.length };
-    const perto = (lista, t) => {
-        let lo = 0, hi = lista.length - 1;
-        while (lo < hi) { const m = (lo + hi) >> 1; if (lista[m] < t) lo = m + 1; else hi = m; }
-        return Math.min(Math.abs(lista[lo] - t), lo > 0 ? Math.abs(lista[lo - 1] - t) : Infinity);
-    };
+    const perto = (lista, t) => maisPerto(lista, t).d;
     const maior = cortes.reduce((a, b) => (b.peso > a.peso ? b : a), cortes[0]);
     const acentos = (analise.acentos || []);
     let melhor = { inicio: 0, pontos: -1 };
     for (let o = 0; o <= Math.max(0, maximo) + 1e-9; o += 0.01) {
         let pontos = 0;
-        for (const c of cortes) pontos += c.peso * Math.exp(-0.5 * Math.pow(perto(bats, c.t + o) / tolerancia, 2));
+        for (const c of cortes) {
+            if (c.ref) {
+                const v = batidaNaJanela(bats, c, o);
+                if (v != null) pontos += c.peso * (1 - 0.3 * Math.min(1, Math.abs(v - c.t) / (2 * EMPURRAO)));
+            } else pontos += c.peso * Math.exp(-0.5 * Math.pow(perto(bats, c.t + o) / tolerancia, 2));
+        }
         if (maior.peso > 1 && acentos.length && perto(acentos, maior.t + o) < 0.1) pontos += 2;
         if (pontos > melhor.pontos + 1e-6) melhor = { inicio: r3(o), pontos };
     }
-    const alinhados = cortes.filter((c) => perto(bats, c.t + melhor.inicio) <= tolerancia).length;
-    return { inicio: melhor.inicio, alinhados, total: cortes.length };
+    const o = melhor.inicio;
+    // O empurrão: cada corte do gerativo vai para a batida mais perto, se couber.
+    let empurrados = 0;
+    for (const c of cortes) {
+        if (!c.ref) continue;
+        const { bs, j, base } = c.ref;
+        const v = batidaNaJanela(bats, c, o);
+        if (v == null || Math.abs(v - c.t) <= 1e-3) continue;
+        const delta = v - c.t;
+        const b = bs[j], a = bs[j - 1];
+        const novo = b.de + delta;
+        if (novo - a.de < MIN_BATIDA || b.ate - novo < MIN_BATIDA) continue;
+        const colado = Math.abs(a.ate - b.de) < 0.02;
+        b.de = r3(novo);
+        if (colado) a.ate = b.de;
+        c.t = r3(base + b.de);
+        empurrados++;
+    }
+    // O golpe (a tese que bate) também cai na batida, sem sair da batida dele.
+    const vistos = new Set();
+    for (const c of cortes) {
+        if (!c.ref || vistos.has(c.ref.bs)) continue;
+        vistos.add(c.ref.bs);
+        for (const b of c.ref.bs) for (const g of b.golpes || []) {
+            const { bt, d } = maisPerto(bats, c.ref.base + g.t + o);
+            const alvo = bt - o - c.ref.base;
+            if (d <= EMPURRAO && alvo > b.de + 0.05 && alvo < b.ate - 0.1) g.t = r3(alvo);
+        }
+    }
+    const alinhados = cortes.filter((c) => perto(bats, c.t + o) <= tolerancia).length;
+    return { inicio: o, alinhados, total: cortes.length, empurrados };
 }
 
 module.exports = { analisarPCM, analisar, cortesDoPlano, melhorInicio, TAXA, CONFIANCA_MINIMA };

package/lib/estudio/gerativo.js

@@ -265,7 +265,7 @@ function escolherVisual(roteiro = {}, { aleatorio = Math.random } = {}) {
        roteiro É do assunto (uma palavra só não basta). UMA forma por vídeo —
        é identidade, não sorteio por batida — ou 'nenhum', que a memória também gira. */
     const forca = (ABSTRATO_DO_HUMOR[humor] || 0) * Math.min(1, n[humor] / 3);
-    const h1 = forca > 0 ? variedade.sortear([...HEROIS_OBJETO, ...HEROIS_CAMPO, 'nenhum'], 'heroi-gerativo', { aleatorio, adequacao: (h) => (h === 'nenhum' ? 1 - forca : forca * fitH(h)) }) : 'nenhum';
+    const h1 = forca > 0 ? variedade.sortear([...HEROIS_3D, ...HEROIS_OBJETO, ...HEROIS_CAMPO, 'nenhum'], 'heroi-gerativo', { aleatorio, adequacao: (h) => (h === 'nenhum' ? 1 - forca : HEROIS_3D.includes(h) ? forca * 1.3 : forca * fitH(h)) }) : 'nenhum';
     out.herois = { favoritos: h1 === 'nenhum' ? [] : [h1] };
     // 'produto' e 'marca' quem decide é o conteúdo (o 3D pedido, a marca), não o gosto do projeto.
     const favC = [];
@@ -274,7 +274,10 @@ function escolherVisual(roteiro = {}, { aleatorio = Math.random } = {}) {
     /* A MOLDURA (09/10): o quadro fixo do reel de referência — cantos, o assunto
        no alto, a seção, o tempo embaixo — é identidade, mas em todo vídeo vira
        vício. Sai do cardápio com memória: 'sem' pesa um pouco mais. */
-    out.moldura = variedade.sortear(MOLDURAS, 'moldura-gerativo', { aleatorio, adequacao: { sem: 1, cantos: 0.95, completa: 0.95 } });
+    /* (10/10) "Essa borda entrega que foi IA que fez" (Joel): os cantos, o
+       "01 · seção" e o tempo embaixo são a assinatura de vídeo gerado. Saiu
+       do sorteio: só entra quando o roteiro PEDE (moldura: cantos|completa). */
+    out.moldura = 'sem';
     // O bokeh combina com luz de tela (tecnologia, energia, natureza); numa padaria, quase nunca.
     const bokeh = ['tecnologia', 'energia', 'natureza'].includes(humor) ? 0.6 : 0.2;
     out.ambiente = variedade.sortear(AMBIENTES, 'ambiente-gerativo', { aleatorio, adequacao: { limpo: 1, luz: 0.85, bokeh } });
@@ -298,6 +301,18 @@ function escolherVisual(roteiro = {}, { aleatorio = Math.random } = {}) {
    O assunto decide quanto 3D: tecnologia e energia puxam os objetos (esfera,
    toro, polígono, explosão); editorial e luxo, os campos. */
 const HEROIS_OBJETO = ['explosao', 'poligono', 'esfera', 'toro'], HEROIS_CAMPO = ['truchet', 'aneis', 'grade', 'rastro'];
+/* O 3D DE VERDADE (10/10, "quero um 3d bem presente", com o reel de
+   referência): three.js, perspectiva, luz — grande na tela, não um enfeite.
+   globo3d: a esfera de pontos e malha girando em profundidade; fita3d: o nó
+   que se torce, com material e luz de recorte; colunas3d: o campo de colunas
+   que a câmera sobrevoa, atrás do texto. (kit/tres.jsx, Heroi3D) */
+const HEROIS_3D = ['globo3d', 'fita3d', 'colunas3d'];
+const CAMPOS_3D = ['colunas3d'];
+/* A FAMÍLIA de cada herói: dois heróis da mesma família seguidos são o
+   "mesmo desenho" para quem assiste (o anel de pontos com a forma no meio
+   saiu em 4 batidas seguidas no vídeo do Joel, 10/10). */
+const FAMILIA_HEROI = { explosao: 'raio', poligono: 'orbita', aneis: 'orbita', esfera: 'malha', toro: 'malha', globo3d: 'malha',
+    fita3d: 'fita', colunas3d: 'campo3d', truchet: 'azulejo', grade: 'grade', rastro: 'rastro' };
 const OBJETO3D_DO_HUMOR = { tecnologia: 1, energia: 1, natureza: 0.8, luxo: 0.6, editorial: 0.4 };
 /* Quanto o assunto aceita forma abstrata (o resto: a tipografia e o ícone do conteúdo). */
 const ABSTRATO_DO_HUMOR = { tecnologia: 1, energia: 0.7, natureza: 0.5, luxo: 0, editorial: 0 };
@@ -327,7 +342,7 @@ function escolhasValidas(e) {
         texto: todas('textos').includes(e.texto) ? e.texto : null,
         mono: todas('monos').includes(e.mono) ? e.mono : null,
         genero: todas('generos').includes(e.genero) ? e.genero : null,
-        herois: (e.herois && Array.isArray(e.herois.favoritos) ? e.herois.favoritos : []).filter((h) => HEROIS_OBJETO.includes(h) || HEROIS_CAMPO.includes(h)),
+        herois: (e.herois && Array.isArray(e.herois.favoritos) ? e.herois.favoritos : []).filter((h) => HEROIS_OBJETO.includes(h) || HEROIS_CAMPO.includes(h) || HEROIS_3D.includes(h)),
         composicoes: (e.composicoes && Array.isArray(e.composicoes.favoritas) ? e.composicoes.favoritas : []).filter((c) => COMPOSICOES.includes(c)),
         icones: e.icones && ARRANJOS_ICONE.includes(e.icones.arranjo) ? {
             arranjo: e.icones.arranjo,
@@ -570,6 +585,9 @@ function frasesDe(fala, palavras) {
 
 // ── as cores ────────────────────────────────────────────────────────────
 const luz = (h) => { const n = parseInt(String(h).slice(1), 16); return ((n >> 16 & 255) * 0.299 + (n >> 8 & 255) * 0.587 + (n & 255) * 0.114) / 255; };
+/** A luminância relativa do WCAG (com o gama) e o contraste por ela. */
+const lumWcag = (h) => { const n = parseInt(String(h).slice(1), 16); const c = [n >> 16 & 255, n >> 8 & 255, n & 255].map((v) => { v /= 255; return v <= 0.03928 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4); }); return 0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2]; };
+const contrasteWcag = (a, b) => { const la = lumWcag(a) + 0.05, lb = lumWcag(b) + 0.05; return la > lb ? la / lb : lb / la; };
 const contraste = (a, b) => { const la = luz(a) + 0.05, lb = luz(b) + 0.05; return la > lb ? la / lb : lb / la; };
 const PALETAS = HUMORES.tecnologia.paletas;
 
@@ -999,6 +1017,8 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [], icon
             const comp = nome === 'rajada' ? 'gigante' : nome === 'duelo' ? 'pilha' : nome;
             let q = p;
             if (comp === anterior || evita.includes(comp)) q = 0;
+            // No máximo 2 vezes no vídeo (10/10: "cascata" saiu 3 vezes no vídeo do Joel).
+            if ((usadas[comp] || 0) >= 2) q = 0;
             if (recentes.slice(-3).includes(comp)) q *= 0.35;
             q *= Math.pow(0.72, usadas[comp] || 0);
             if (comp === 'parede' && (usadas.parede || 0) >= 1) q *= 0.25;
@@ -1033,6 +1053,8 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [], icon
         if (bi === alvo3d && !usadas.produto) nome = 'produto';
         const ctx = { s, W, H, M, deitado, base, larguraUtil, tamRotulo, fontes, P, palavras: br.palavras || c.palavras || [], parte: br.parte, marca, roteiro, memoria };
         if (nome === 'rajada' && br.ate - br.de < 1.6 * c.itens.length) nome = 'cascata';
+        // A cascata que veio da rajada também respeita o teto de 2 (e nunca segue outra cascata).
+        if (nome === 'cascata' && ((usadas.cascata || 0) >= 2 || anterior === 'cascata')) nome = anterior === 'pilha' ? 'palavras' : 'pilha';
         if (nome === 'rajada') {
             // Cada item vira a sua batida; o título da lista fica como rótulo.
             const n = c.itens.length;
@@ -1075,6 +1097,45 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [], icon
     batidas.forEach((b) => { b.secao = secoes.idx[b.parte] || 0; b.campo = b.secao % 2 === 0 ? comeca : 2 - comeca; });
     for (const b of batidas) { b.fundo = 'campo' + b.campo; b.cores = coresDoCampo(campos, b.campo, s, ident); }
 
+    /* ── OS CAMPOS DE COR CHAPADA (10/10) ────────────────────────────────
+       "O vídeo fica bege e grafite do começo ao fim" — o reel de referência
+       troca o quadro INTEIRO para laranja, azul elétrico, lima. Os campos 3 e
+       4 tinham saído em 09/10 porque entravam a esmo ("cores nada a ver uma
+       com a outra"); voltam com regra: só DUAS cores fortes — o acento do
+       vídeo e a ousada do mesmo sistema (campos[3]) —, em ~1 de cada 3,5
+       batidas (pelo menos 2 num vídeo de 6+), nunca duas seguidas, nunca a
+       primeira nem a marca. Tinta de contraste alto; o corte é seco (o fundo
+       troca no quadro da batida, que o batida.js encosta na música). */
+    // A segunda cor é a ousada do sistema MAIS LONGE no matiz do acento: duas laranjas lado a lado
+    // (o terracota e o #FF4A1C, render real de 10/10) não fazem o contraste do reel (laranja × azul).
+    const matiz = (h) => { const n = parseInt(String(h).slice(1), 16); const r = (n >> 16 & 255) / 255, g = (n >> 8 & 255) / 255, bb = (n & 255) / 255;
+        const mx = Math.max(r, g, bb), mn = Math.min(r, g, bb), d = mx - mn; if (!d) return 0;
+        const hh = mx === r ? ((g - bb) / d) % 6 : mx === g ? (bb - r) / d + 2 : (r - g) / d + 4; return (hh * 60 + 360) % 360; };
+    const longe = (x) => { const d = Math.abs(matiz(x) - matiz(ident.acento)); return Math.min(d, 360 - d); };
+    const ousada = [campos[3], campos[4]].filter(ehCor).sort((x, y) => longe(y) - longe(x))[0];
+    const fortes = [ident.acento, ousada].filter((x, i, a) => ehCor(x) && a.indexOf(x) === i);
+    const nCor = batidas.length >= 6 ? Math.max(2, Math.round(batidas.length / 3.5)) : batidas.length >= 4 ? 1 : 0;
+    const candCor = batidas.map((b, i) => i).filter((i) => i > 0 && !['marca', 'produto'].includes(batidas[i].comp));
+    const pesoCor = { gigante: 3, palavras: 2.5, contador: 2.5, pilha: 2, parede: 1.5, divisao: 1, cascata: 0.8, citacao: 0.8 };
+    const comCor = [];
+    for (const i of candCor.sort((x, y) => (pesoCor[batidas[y].comp] || 1) - (pesoCor[batidas[x].comp] || 1) || x - y)) {
+        if (comCor.length >= nCor || !fortes.length) break;
+        if (comCor.some((j) => Math.abs(j - i) < 2)) continue;
+        comCor.push(i);
+    }
+    comCor.sort((x, y) => x - y).forEach((i, k) => {
+        const b = batidas[i];
+        const fundo = fortes[k % fortes.length], outra = fortes[(k + 1) % fortes.length];
+        /* A tinta pelo contraste WCAG (luminância relativa, com o gama): a `luz`
+           daqui acha o azul elétrico "médio" e punha texto PRETO nele — o olho
+           lê muito melhor o branco. */
+        const tinta = [...ident.chaos, '#0B0B0B', '#FAFAF7'].sort((x, y) => contrasteWcag(y, fundo) - contrasteWcag(x, fundo))[0];
+        const acento = outra && outra !== fundo && contrasteWcag(outra, fundo) >= 2.6 ? outra : tinta;
+        b.cores = { fundo, texto: tinta, fraco: misturarCor(tinta, fundo, 0.32), acento, contorno: misturarCor(tinta, fundo, 0.5) };
+        b.campoCor = true;
+        b.fundo = 'cor';
+    });
+
     /* ── O HERÓI DE CADA BATIDA VEM DO CONTEÚDO (09/10): "é uma conversa sobre
        pão e ele vai naquela bolinha" (Joel). Quem diz é o roteiro: parte.heroi
        (ou parte.icone) — um ícone do Iconify ("mdi:bread-slice", o desenho
@@ -1084,7 +1145,7 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [], icon
        e a forma abstrata só no assunto abstrato, a escolhida do projeto, em
        até 1 de cada 3 batidas. Nada serve: a tipografia carrega a batida. ── */
     const pedidoDe = partes.map((p) => { const h = p.heroi != null ? p.heroi : p.icone; return typeof h === 'string' && h.trim() ? h.trim() : null; });
-    const ABSTRATOS = [...HEROIS_OBJETO, ...HEROIS_CAMPO];
+    const ABSTRATOS = [...HEROIS_OBJETO, ...HEROIS_CAMPO, ...HEROIS_3D];
     const ICONES3D = new Set(Object.values(ICONE_DE));
     const materialSorteado = s.um(['argila', 'verniz', 'metal']);
     // O arranjo do projeto (escolherVisual); sem ele, o de antes: um lado só, ícones seguidos.
@@ -1135,24 +1196,100 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [], icon
         ultimoIcone = bi;
     }
 
-    // A forma abstrata: a que o modelo pediu, ou a do projeto no assunto que aceita.
+    /* ── A FORMA ABSTRATA, BATIDA A BATIDA (10/10) ───────────────────────
+       Era UMA forma por vídeo, repetida a cada duas batidas: o anel com a
+       forma no meio saiu em 4 batidas seguidas e "as animações são muito
+       iguais" (Joel). Agora cada batida que recebe forma tira a sua de um
+       cardápio, com três regras:
+         1. nunca a mesma FAMÍLIA (FAMILIA_HEROI) em duas batidas seguidas;
+         2. cada forma no máximo 2 vezes no vídeo (uma repetição);
+         3. no assunto que aceita (tecnologia, energia, natureza), pelo menos
+            1 de cada 3 batidas é 3D DE VERDADE (HEROIS_3D) — grande, com
+            perspectiva e luz, não o enfeite pequeno de antes.
+       A forma pedida pelo roteiro (parte.heroi) continua valendo onde pediu. */
     const OBJETOS = HEROIS_OBJETO;
-    const favorito = (ABSTRATO_DO_HUMOR[humor] || 0) > 0 ? E.herois[0] : null;
-    const tetoH = Math.ceil(batidas.length / 3);
-    let nH = 0, ultimoH = -9;
+    /* O assunto aceita forma abstrata quando o humor é de tecnologia, energia
+       ou natureza E o roteiro É do assunto (3 palavras do humor, como na
+       escolha do projeto) — a padaria que fala de Pix não vira reel de tech. */
+    const acertos = acertosDeHumor(roteiro)[humor] || 0;
+    // E o projeto escolheu ter forma (escolherVisual, E.herois): sem essa escolha, o herói vem só do conteúdo.
+    const aceita = (E.herois || []).length > 0 && (ABSTRATO_DO_HUMOR[humor] || 0) >= 0.5 && acertos >= 3;
+    const nB = batidas.length;
+    const usoH = {}, usoFam = {};
+    let famAnterior = null, ultimoH = -9;
+    // A parede de texto e a marca já cobrem o quadro: forma ali é ruído.
+    const livreParaHeroi = (b) => !b.icone3d && !b.produto3d && !pedidoDe[b.parte] && b.comp !== 'marca' && b.comp !== 'parede';
+    const elegiveis = aceita ? batidas.map((b, i) => (livreParaHeroi(b) ? i : -1)).filter((i) => i >= 0) : [];
+    // Quantas batidas ganham forma: metade do vídeo (as outras ficam com a tipografia e o ícone).
+    const quantas = Math.min(elegiveis.length, Math.ceil(nB / 2));
+    const escolhidas = new Set();
+    for (let k = 0; k < quantas; k++) escolhidas.add(elegiveis[Math.floor((k * elegiveis.length) / quantas)]);
+    const meta3d = aceita ? Math.min(quantas, Math.ceil(nB / 3)) : 0;
+    let n3d = 0, feitas = 0;
+    const favoritos = new Set(E.herois || []);
+    const sortearHeroi = (b, i, so3d) => {
+        const lista = so3d ? HEROIS_3D : [...HEROIS_3D, ...HEROIS_OBJETO, 'truchet', 'aneis', 'rastro'];
+        const w = {};
+        const pode = (h) => w[h] > 0;
+        for (const h of lista.concat([...favoritos].filter((f) => !lista.includes(f) && (!so3d || HEROIS_3D.includes(f))))) {
+            if ((usoH[h] || 0) >= 2) continue;
+            const fam = FAMILIA_HEROI[h];
+            if (fam === famAnterior && i - ultimoH <= 2) continue;
+            // Cada família uma vez no vídeo: a esfera plana depois do globo 3D lia como repetição.
+            if ((usoFam[fam] || 0) >= 1) continue;
+            // As formas planas que pedem o vazio ao lado não cabem na batida sem vazio.
+            if (OBJETOS.includes(h) && ['gigante', 'parede', 'divisao'].includes(b.comp)) continue;
+            // O campo 3D e a parede de texto brigam: as duas cobrem o quadro.
+            if ((CAMPOS_3D.includes(h) || HEROIS_CAMPO.includes(h)) && b.comp === 'parede') continue;
+            // O 3D que mora AO LADO do texto (globo, fita) precisa de um lado livre: a tese gigante,
+            // o contraste e a citação ocupam a largura — ali ele não teria onde ficar sem cruzar a letra.
+            if (HEROIS_3D.includes(h) && !CAMPOS_3D.includes(h) && ['gigante', 'divisao', 'citacao', 'contador'].includes(b.comp)) continue;
+            let p = HEROIS_3D.includes(h) ? 1.6 : 1;
+            if (favoritos.has(h)) p *= 2;
+            p *= Math.pow(0.4, usoH[h] || 0);
+            w[h] = p;
+        }
+        // A forma que o projeto escolheu é a identidade: entra na primeira batida em que cabe.
+        const fav = [...favoritos].find((f) => !usoH[f] && pode(f));
+        if (fav) return fav;
+        // A batida pede 3D e a escolhida é plana: vem a versão 3D da mesma família (o toro vira o globo).
+        if (so3d) {
+            const irma = [...favoritos].map((f) => HEROIS_3D.find((h) => FAMILIA_HEROI[h] === FAMILIA_HEROI[f])).find((h) => h && pode(h));
+            if (irma) return irma;
+        }
+        return s.pesado(w);
+    };
     batidas.forEach((b, i) => {
         let h = b.heroiPedido || null;
-        if (!h && favorito && !b.icone3d && !b.produto3d && !pedidoDe[b.parte] && nH < tetoH && i - ultimoH >= 2
-            && !(OBJETOS.includes(favorito) && ['gigante', 'parede', 'divisao'].includes(b.comp))) h = favorito;
         delete b.heroiPedido;
+        if (!h && escolhidas.has(i)) {
+            const faltam3d = meta3d - n3d, restam = quantas - feitas;
+            h = sortearHeroi(b, i, faltam3d > 0 && faltam3d >= restam) || sortearHeroi(b, i, false);
+            feitas++;
+        }
         if (!h) return;
-        nH++; ultimoH = i;
+        usoH[h] = (usoH[h] || 0) + 1;
+        usoFam[FAMILIA_HEROI[h] || h] = (usoFam[FAMILIA_HEROI[h] || h] || 0) + 1;
+        famAnterior = FAMILIA_HEROI[h] || h; ultimoH = i;
+        const tres = HEROIS_3D.includes(h);
+        if (tres) n3d++;
         const comCor = b.acentos < REGRAS.acentos;
         if (comCor) b.acentos += 1;
-        b.heroi = { tipo: h, modo: OBJETOS.includes(h) ? 'objeto' : 'campo', semente: hash(b.id + h) % 9973,
-            cor: comCor ? b.cores.acento : misturarCor(b.cores.texto, b.cores.fundo, 0.25), cor2: b.cores.texto };
+        b.heroi = { tipo: h, modo: CAMPOS_3D.includes(h) ? 'campo' : tres ? 'objeto3d' : OBJETOS.includes(h) ? 'objeto' : 'campo',
+            tres, semente: hash(b.id + h) % 9973,
+            cor: comCor ? b.cores.acento : misturarCor(b.cores.texto, b.cores.fundo, 0.25), cor2: b.cores.texto, fundo: b.cores.fundo };
     });
 
+    /* O 3D COMO ASSUNTO (10/10, "uma coisa gigante por tela"): na batida com
+       globo ou fita, o texto vai para a metade esquerda (no 9:16, para o alto)
+       e a outra metade fica inteira para o 3D — que o kit faz do tamanho do
+       vão (até ~60% da altura), sem nunca cruzar a letra. */
+    for (const b of batidas) {
+        if (!b.heroi || b.heroi.modo !== 'objeto3d' || !b.bloco || b.bloco.colunas || b.bloco.blocos) continue;
+        if (deitado) b.bloco = { ...b.bloco, x: M, alinha: 'esq', largura: Math.min(b.bloco.largura, W * 0.46) };
+        else b.bloco = { ...b.bloco, y: H * 0.3, largura: Math.min(b.bloco.largura, larguraUtil) };
+    }
+
     // ── as passagens: como uma batida vira a outra ──────────────────────
     let ultimaSaida = null, desdeCorte = 9;
     const saidasRecentes = [];
@@ -1361,9 +1498,12 @@ function compor(comp, br, ctx) {
             const fonte = s.chance(0.5) ? fontes.cinetica : fontes.display;
             const eixos = { wght: Math.min(VARIAVEIS[fonte].eixos.wght[1], wTese) };
             const op = { fonte, wght: eixos.wght, maiusc };
-            const nMax = deitado ? 2 : Math.min(4, txt.split(/\s+/).length);
+            // A frase de 3+ palavras pode ir em 3 linhas no 16:9: cresce na altura em vez de encolher na largura.
+            const nMax = deitado ? Math.min(3, Math.max(2, txt.split(/\s+/).length)) : Math.min(4, txt.split(/\s+/).length);
             const alvo = deitado ? larguraUtil * 0.96 : larguraUtil;
-            const fit = caberEmLinhas(txt, alvo, nMax, (deitado ? 0.3 : 0.2) * H, op);
+            /* UMA COISA GIGANTE POR TELA (10/10, comparado ao reel de referência: "o
+               texto pequeno no meio do bege"). A tese gigante enche a largura. */
+            const fit = caberEmLinhas(txt, alvo, nMax, (deitado ? 0.42 : 0.26) * H, op);
             const alinha = deitado && s.chance(0.35) ? 'esq' : 'centro';
             b.bloco = { x: alinha === 'esq' ? M : W / 2, y: H * vert(deitado ? [0.5, 0.52, 0.47] : [0.47, 0.5, 0.55]), alinha, vert: 'meio', largura: alvo, gap: 0.04 };
             if (c.selo) linha(c.selo, 'rotulo', { fonte: fontes.mono, tamanho: tamRotulo, tracking: 0.16, maiusc: true, eixos: { wght: 500 } });
@@ -1384,11 +1524,11 @@ function compor(comp, br, ctx) {
         }
         case 'pilha': case 'produto': {
             const noProduto = comp === 'produto';
-            const lg = noProduto ? (deitado ? W * 0.42 : larguraUtil) : (deitado ? W * s.entre(0.62, 0.74) : larguraUtil);
+            const lg = noProduto ? (deitado ? W * 0.42 : larguraUtil) : (deitado ? W * s.entre(0.74, 0.84) : larguraUtil);
             const principal = c.tipo === 'numero' ? c.valor : (c.titulo || c.nome || c.nao || c.sim || c.texto || '');
             const nL = 3;
             const op = { fonte: fontes.display, wght: wTese };
-            const fit = caberEmLinhas(principal, lg, nL, (deitado ? 0.15 : 0.085) * H * (noProduto ? 0.85 : 1), op);
+            const fit = caberEmLinhas(principal, lg, nL, (deitado ? 0.23 : 0.115) * H * (noProduto ? 0.85 : 1), op);
             const y = noProduto ? (deitado ? H * 0.52 : H * 0.72) : H * vert(deitado ? [0.42, 0.5, 0.58] : [0.44, 0.52, 0.6]);
             b.bloco = { x: M, y, alinha: 'esq', vert: 'meio', largura: lg, gap: 0.16 };
             const rot = c.selo || (c.tipo === 'cta' ? '' : '');
@@ -1426,9 +1566,9 @@ function compor(comp, br, ctx) {
         case 'palavras': {
             const txt = c.texto || c.titulo || '';
             const alinha = s.chance(0.55) ? 'esq' : 'centro';
-            const lg = deitado ? W * 0.8 : larguraUtil;
+            const lg = deitado ? W * 0.86 : larguraUtil;
             const op = { fonte: fontes.display, wght: 600 };
-            const fit = caberEmLinhas(txt, lg, deitado ? 3 : 4, (deitado ? 0.12 : 0.075) * H, op);
+            const fit = caberEmLinhas(txt, lg, deitado ? 3 : 4, (deitado ? 0.18 : 0.1) * H, op);
             b.bloco = { x: alinha === 'esq' ? M : W / 2, y: H * vert([0.48, 0.52]), alinha, vert: 'meio', largura: lg, gap: 0.1 };
             // Sem destaque, a tese é a palavra mais longa que não é função.
             if (!destaqueTk.length) {
@@ -1463,7 +1603,7 @@ function compor(comp, br, ctx) {
             // Fonte larga (Unbounded) aperta a lista: os itens vão na fonte de texto.
             const fonte = VARIAVEIS[fontes.display].largura > 1.1 ? fontes.texto : fontes.display;
             const op = { fonte, wght: 560 };
-            const maxT = (deitado ? 0.09 : 0.042) * H;
+            const maxT = (deitado ? 0.12 : 0.056) * H;
             const nL = itens.length <= 3 ? 2 : 1;
             const tam = Math.min(...itens.map((it) => caberEmLinhas((c.numerada ? '00  ' : '') + it, lg, nL, maxT, op).tamanho));
             b.bloco = { x: M + 30 * base, y: H * vert(deitado ? [0.5, 0.52] : [0.5, 0.54]), alinha: 'esq', vert: 'meio', largura: lg, gap: 0.42 };
@@ -1483,8 +1623,8 @@ function compor(comp, br, ctx) {
         case 'divisao': {
             const lado = deitado ? (larguraUtil - M * 0.6) / 2 : larguraUtil;
             const op = { fonte: fontes.display, wght: wTese };
-            const fN = caberEmLinhas(c.nao, lado, deitado ? 3 : 2, (deitado ? 0.1 : 0.065) * H, { ...op, wght: 400 });
-            const fS = caberEmLinhas(c.sim, lado, deitado ? 3 : 3, (deitado ? 0.12 : 0.08) * H, op);
+            const fN = caberEmLinhas(c.nao, lado, deitado ? 3 : 2, (deitado ? 0.13 : 0.08) * H, { ...op, wght: 400 });
+            const fS = caberEmLinhas(c.sim, lado, deitado ? 3 : 3, (deitado ? 0.17 : 0.1) * H, op);
             if (deitado) {
                 b.bloco = { x: M, y: H * 0.5, alinha: 'esq', vert: 'meio', largura: lado, gap: 0.1, colunas: [M, M + lado + M * 0.6] };
             } else {
@@ -1502,7 +1642,7 @@ function compor(comp, br, ctx) {
             const fonte = fontes.serifa;
             const lg = deitado ? W * 0.78 : larguraUtil;
             const q = String(c.texto || '').replace(/^["“]+|["”]+$/g, '');
-            const fit = caberEmLinhas(q, lg, deitado ? 4 : 5, (deitado ? 0.12 : 0.065) * H, { fonte, wght: 420 });
+            const fit = caberEmLinhas(q, lg, deitado ? 4 : 5, (deitado ? 0.15 : 0.08) * H, { fonte, wght: 420 });
             b.bloco = { x: M, y: H * vert([0.48, 0.52]), alinha: 'esq', vert: 'meio', largura: lg, gap: 0.16 };
             linha('“', 'aspas', { fonte, tamanho: fit.tamanho * 1.6, eixos: { wght: 800 }, cor: 'acento' });
             fit.linhas.forEach((t) => { const l = linha(t, 'apoio', { fonte, tamanho: fit.tamanho, eixos: { wght: 420, ...(VARIAVEIS[fonte].eixos.SOFT ? { SOFT: 100, WONK: 1 } : {}) } }); l.palavras.forEach((p) => { if (p.papel === 'tese') { p.wght = 700; } }); });
@@ -1516,7 +1656,7 @@ function compor(comp, br, ctx) {
             const nome = c.nome || c.titulo || (ctx.marca.nome || '');
             const fonte = fontes.display;
             const lg = deitado ? W * 0.7 : larguraUtil * 0.9;
-            const tam = tamanhoQueCabe(nome, lg, (deitado ? 0.22 : 0.13) * H, { fonte, wght: 800 });
+            const tam = tamanhoQueCabe(nome, lg, (deitado ? 0.3 : 0.16) * H, { fonte, wght: 800 });
             b.bloco = { x: W / 2 + tam * 0.3, y: H * 0.5, alinha: 'centro', vert: 'meio', largura: lg, gap: 0.2 };
             linha(nome, 'tese', { fonte, tamanho: tam, eixos: { wght: Math.min(800, VARIAVEIS[fonte].eixos.wght[1]) }, comportamento: 'contorno' }).marca = true;
             if (c.sub || c.link) linha(c.sub || c.link, 'rotulo', { fonte: fontes.mono, tamanho: tamRotulo, tracking: 0.2, maiusc: true, eixos: { wght: 400 } });
@@ -1527,7 +1667,7 @@ function compor(comp, br, ctx) {
             const txt = c.titulo || c.nome || '';
             const fonte = fontes.cinetica;
             const maiusc = true;
-            const tam = tamanhoQueCabe(txt, larguraUtil, (deitado ? 0.2 : 0.1) * H, { fonte, wght: 900, maiusc });
+            const tam = tamanhoQueCabe(txt, larguraUtil, (deitado ? 0.26 : 0.13) * H, { fonte, wght: 900, maiusc });
             b.bloco = { x: W / 2, y: H * 0.5, alinha: 'centro', vert: 'meio', largura: larguraUtil, gap: 0.1 };
             linha(txt, 'tese', { fonte, tamanho: tam, eixos: { wght: Math.min(900, VARIAVEIS[fonte].eixos.wght[1]) }, maiusc });
             b.textura = { texto: (maiusc ? txt.toUpperCase() : txt), tamanho: tam, fonte, linhas: Math.ceil(H / (tam * 1.02)) + 3, velocidade: Math.round(s.entre(40, 90) * base) };
@@ -1578,8 +1718,12 @@ function compor(comp, br, ctx) {
        componente mede e cresce o grupo principal até a largura do bloco,
        com o teto vertical daqui (o respiro de 30–40% continua garantido). */
     // A palavra-herói de ponta a ponta (o CLAUDE do reel): teto alto, a largura manda.
-    const tetoV = { gigante: deitado ? 0.44 : 0.24, marca: deitado ? 0.3 : 0.16, parede: deitado ? 0.26 : 0.13, contador: deitado ? 0.52 : 0.22,
-        pilha: deitado ? 0.22 : 0.12, produto: deitado ? 0.14 : 0.08, palavras: deitado ? 0.12 : 0.08, cascata: deitado ? 0.1 : 0.05, divisao: deitado ? 0.13 : 0.085, citacao: deitado ? 0.12 : 0.07 }[b.comp] || 0.1;
+    /* (10/10) "Uma coisa gigante por tela": os tetos subiram — a frase curta
+       chega a ~14–18% da altura em altura de maiúscula, a lista a ~9%. Era o
+       teto daqui (0,12 × 0,72 da altura) que deixava "Entregue a próxima
+       tarefa" pequena no meio do bege, não o tamanho que a composição pedia. */
+    const tetoV = { gigante: deitado ? 0.5 : 0.28, marca: deitado ? 0.34 : 0.18, parede: deitado ? 0.3 : 0.15, contador: deitado ? 0.55 : 0.25,
+        pilha: deitado ? 0.3 : 0.15, produto: deitado ? 0.16 : 0.09, palavras: deitado ? 0.22 : 0.12, cascata: deitado ? 0.14 : 0.07, divisao: deitado ? 0.18 : 0.1, citacao: deitado ? 0.16 : 0.09 }[b.comp] || 0.12;
     // A SANGRIA (a palavra de ponta a ponta) é um momento, não o padrão: até duas por vídeo, só em palavra curta.
     const memS = ctx.memoria || {};
     if (['gigante', 'parede'].includes(b.comp) && (memS.cheios || 0) < 2 && b.linhas.filter((l) => l.papel === 'tese').length <= 2
@@ -1591,7 +1735,7 @@ function compor(comp, br, ctx) {
         if (!enche(l)) continue;
         l.encher = l.papel === 'item' ? 'item' : 'principal';
         // O respiro do guia: fora dos (no máximo dois) momentos de sangria, o bloco usa ~55% da altura e a tese não encosta em nada.
-        l.max = Math.round(b.cheio ? Math.min(tetoV * H, (H * 0.66) / (nEnche * 1.05)) : Math.min(tetoV * H * 0.72, (H * 0.5) / (nEnche * 1.05)));
+        l.max = Math.round(b.cheio ? Math.min(tetoV * H, (H * 0.7) / (nEnche * 1.05)) : Math.min(tetoV * H * 0.9, (H * 0.62) / (nEnche * 1.05)));
     }
     // ── o tempo de cada linha e palavra: quando a voz diz ────────────────
     tempoDaBatida(b, palavras, ctx);
@@ -1709,5 +1853,5 @@ function contarAcentos(b) {
 
 module.exports = {
     montarGerativo, partituraDe, sonsDoVideo, musicaDe, desenharSom, humorDe, escolherVisual, MOLDURAS, AMBIENTES, ACENTOS_JEITO, ARRANJOS_ICONE, RITMOS_ICONE, MATERIAIS_ICONE, corGenerica, BANIDAS, HUMORES, REGRAS, VARIAVEIS, COMPOSICOES, COMPORTAMENTOS, SAIDAS, ACENTOS, FPS,
-    especEixos, sorteador, hash, larguraEm, conteudoDe, casar, HEROIS_OBJETO, HEROIS_CAMPO,
+    especEixos, sorteador, hash, larguraEm, conteudoDe, casar, HEROIS_OBJETO, HEROIS_CAMPO, HEROIS_3D, FAMILIA_HEROI,
 };