primocode 10.8.0 → 10.9.0

package/README.md

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

package/bin/primocode.js

@@ -253,16 +253,20 @@ async function comandoApi(rest) {
 
     const apelido = { claude: 'claude-code', gpt: 'chatgpt', openai: 'chatgpt' }[arg.toLowerCase()];
     let id = apelido || ids.find((k) => k === arg.toLowerCase() || P[k].nome.toLowerCase().startsWith(arg.toLowerCase()) && arg);
+    // A lista numerada, a pergunta e a resposta somem depois da escolha: fica só o resultado (lib/entrada.js, marcar).
+    let marca = null;
+    const tirarLista = () => { if (marca && rl && rl.voltarPara) rl.voltarPara(marca); marca = null; };
     if (!id) {
+        if (rl && rl.marcar) marca = rl.marcar();
         console.log('');
         console.log('  ' + c.bold('Com qual IA você quer rodar?') + c.muted('  a sua chave ou a sua assinatura, sem o limite do servidor'));
         if (atual) console.log('  ' + c.muted('agora: ') + c.white(atual.cli ? atual.nome : `${atual.nome} · ${atual.modelo} · chave ${provedorLocal.mascarar(atual.chave)}`));
         ids.forEach((k, i) => console.log(`  ${c.brand(String(i + 1))}  ${c.white(P[k].nome.padEnd(24))}${c.dim(P[k].dica)}`));
         console.log(`  ${c.brand('0')}  ${c.white('Servidor do PrimoCode'.padEnd(24))}${c.dim('sem chave, com o limite do plano')}`);
         const escolha = String(await ask(`  ${c.brand('?')} Número: `)).trim();
-        if (escolha === '0') return comandoApi('off');
+        if (escolha === '0') { tirarLista(); return comandoApi('off'); }
         id = ids[Number(escolha) - 1];
-        if (!id) { console.log(c.muted('  Nada mudou.')); return; }
+        if (!id) { tirarLista(); console.log(c.muted('  Nada mudou.')); return; }
     }
 
     const p = P[id];
@@ -270,22 +274,25 @@ async function comandoApi(rest) {
     // e logada. Quem pensa é ela; quem executa é o PrimoCode.
     if (p.cli) {
         if (!require('../lib/local/motor-cli').instalado(id)) {
+            tirarLista();
             console.log(c.warn(`  O ${p.nome} não está instalado nesta máquina.`) + c.muted(`  Veja ${p.onde}`));
             return;
         }
         const salvo = provedorLocal.salvar({ provedor: id, modelo: p.modelos[0] });
+        tirarLista();
         console.log(c.ok(`  Pronto: ${salvo.nome}`) + c.muted('  · usa a sua assinatura, sem chave'));
         console.log(c.dim(`  O ${p.nome} decide, o PrimoCode executa. /api off volta ao servidor`));
         return;
     }
     console.log(c.muted(`  Pegue a chave em `) + c.white(p.onde));
     const chave = String(await askSecret(`  ${c.brand('?')} Cole a chave do ${p.nome} (não aparece na tela): `)).trim();
-    if (!chave) { console.log(c.muted('  Nada mudou.')); return; }
+    if (!chave) { tirarLista(); console.log(c.muted('  Nada mudou.')); return; }
     const sp = new Spinner('conferindo a chave').start();
     const r = await provedorLocal.conferir(id, chave);
     sp.stop();
-    if (!r.ok) { console.log(c.warn(`  ${r.error}`)); return; }
+    if (!r.ok) { tirarLista(); console.log(c.warn(`  ${r.error}`)); return; }
     const salvo = provedorLocal.salvar({ provedor: id, chave, modelo: r.modelo });
+    tirarLista();
     console.log(c.ok(`  Pronto: ${salvo.nome} · ${salvo.modelo}`) + c.muted(`  · chave ${provedorLocal.mascarar(chave)}`));
     console.log(c.dim('  Agora os pedidos vão direto daqui, com a sua cota. /api modelo <nome> troca o modelo · /api off volta ao servidor'));
 }
@@ -1279,6 +1286,8 @@ async function enviarPedido(userText) {
                 // ferramentas desktop_* no servidor (ver DICA_COMPUTADOR).
                 instrucao: [i === 0 && querComputador(userText) ? vozModo.DICA_COMPUTADOR : '',
                     i === 0 ? require('../lib/estudio/referencias.js').instrucao() : '',
+                    // As imagens do pedido (arrastadas ou coladas): guardadas para o Estúdio importar, e ditas ao agente.
+                    i === 0 ? (() => { const R = require('../lib/estudio/referencias.js'); return R.instrucaoDasImagens(R.guardarImagens(R.imagensNoTexto(userText))); })() : '',
                     i === 0 ? plan.notaOutraPasta || '' : ''].filter(Boolean).join('\n\n'),
             });
 

package/lib/act.js

@@ -686,6 +686,13 @@ const RITMO_AGENTE = '[ritmo]\n'
    entrar já lido (ver lib/pre-leitura.js). */
 function buildMemoryContext(projectDir, projectName, pedido = '', { memoriaDaPasta = true } = {}) {
     const parts = [];
+    /* NO SERVIDOR O CONTEXTO É CURTO (13/10: "continua lendo e listando
+       coisas desnecessárias"). O plano grátis guarda ~1.900 tokens de
+       conversa; 3.400 de contexto fixo empurravam para fora o que o modelo
+       acabou de ler, e ele lia de novo. Com provedor próprio (/api) nada muda. */
+    let proprio = false;
+    try { proprio = !!require('./local/provedor.js').atual(); } catch { /* sem provedor próprio */ }
+    const curto = (t) => (proprio || t.length <= 1500 ? t : '…' + t.slice(-1500));
     // As instruções vêm primeiro: são regra de quem manda no projeto, e a
     // memória é o que o agente anotou. Entram aqui (e não no bin) para valer
     // igual no terminal, no modo voz e em cada passo de um plano.
@@ -697,14 +704,14 @@ function buildMemoryContext(projectDir, projectName, pedido = '', { memoriaDaPas
        bin), ela não vem de novo. */
     if (memoriaDaPasta) {
         const daPasta = require('./agents-md.js').ler(projectDir);
-        if (daPasta) parts.push(`[AGENTS.md — memória desta pasta: de onde a conversa parou]\n${daPasta}`);
+        if (daPasta) parts.push(`[AGENTS.md — memória desta pasta: de onde a conversa parou]\n${curto(daPasta)}`);
     }
     const geral = cfg.readGeneralMemory();
-    if (geral.trim()) parts.push(`[memory-geral.md]\n${geral}`);
+    if (geral.trim()) parts.push(`[memory-geral.md]\n${curto(geral)}`);
     const projeto = cfg.readProjectMemory(projectDir);
-    if (projeto.trim()) parts.push(`[${projectName || 'projeto'}/memory.md]\n${projeto}`);
+    if (projeto.trim()) parts.push(`[${projectName || 'projeto'}/memory.md]\n${curto(projeto)}`);
     const arquivos = arquivosDoProjeto(projectDir);
-    const mapa = mapaDoProjeto(projectDir, 80, arquivos);
+    const mapa = mapaDoProjeto(projectDir, proprio ? 80 : 30, arquivos);
     if (mapa) parts.push(`[${projectName || 'projeto'}/arquivos]\n${mapa}\n\n${preLeitura.JUNTAR_LEITURAS}`);
     const lidos = preLeitura.bloco(preLeitura.escolher(projectDir, arquivos, pedido));
     if (lidos) parts.push(lidos);

package/lib/entrada.js

@@ -37,6 +37,9 @@
 
 'use strict';
 
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
 const readline = require('readline');
 const { EventEmitter } = require('events');
 const { c, visibleWidth, truncate } = require('./ui.js');
@@ -46,7 +49,51 @@ const stripAnsiLocal = (s) => String(s).replace(/\x1b\[[0-9;]*m/g, '');
 // ── O desenho ────────────────────────────────────────────────────────────
 
 /** A etiqueta de colagem em destaque (fininha, na cor da marca), sem mudar a largura. */
-const RE_ETIQUETA = /\[Colado #\d+ · [^\]]+\]/g;
+const RE_ETIQUETA = /\[(?:Colado|Imagem) #\d+[^\]]*\]/g;
+
+/* A IMAGEM ARRASTADA (Joel, 13/10: "#imagem1 #imagem2, igual fica aqui").
+   Arrastar arquivo para o terminal é uma colagem do CAMINHO, e cada terminal
+   escreve de um jeito: o do macOS escapa o espaço e põe um no fim
+   ("Captura\ de\ Tela.png "), o iTerm põe entre aspas, outros mandam
+   file://. Devolve os caminhos quando TODOS são imagens que existem; senão
+   null, e a colagem segue como texto. */
+const RE_IMAGEM = /\.(png|jpe?g|gif|webp|heic|bmp|tiff?|svg)$/i;
+function imagensArrastadas(texto) {
+    const t = String(texto || '').trim();
+    if (!t || t.includes('\n')) return null;
+    const pedacos = [];
+    let cur = '', aspas = null;
+    for (let i = 0; i < t.length; i++) {
+        const ch = t[i];
+        if (aspas) { if (ch === aspas) aspas = null; else cur += ch; continue; }
+        if (ch === "'" || ch === '"') { aspas = ch; continue; }
+        if (ch === '\\' && i + 1 < t.length) { cur += t[++i]; continue; }
+        if (/\s/.test(ch)) { if (cur) pedacos.push(cur); cur = ''; continue; }
+        cur += ch;
+    }
+    if (aspas) return null;
+    if (cur) pedacos.push(cur);
+    const arquivos = pedacos.map((p) => (p.startsWith('file://') ? decodeURI(p.slice(7)) : p.replace(/^~(?=\/)/, os.homedir())));
+    const existe = (f) => { try { return fs.statSync(f).isFile(); } catch { return false; } };
+    if (!arquivos.length || !arquivos.every((f) => path.isAbsolute(f) && RE_IMAGEM.test(f) && existe(f))) return null;
+    return arquivos;
+}
+
+/* O QUE A ETIQUETA GUARDAVA, embaixo do pedido já enviado: o nome da imagem,
+   ou as primeiras linhas do texto colado e quanto falta. Na caixa a etiqueta
+   poupa espaço; depois de mandar, quem rola a conversa quer ver o que foi. */
+function guardadosNaTela(guardados, largura) {
+    const out = [];
+    for (const [et, conteudo] of guardados || []) {
+        if (et.startsWith('[Imagem')) { out.push(`⎿ ${et} ${path.basename(conteudo)}`); continue; }
+        const linhas = String(conteudo).split('\n');
+        const mostra = linhas.slice(0, 3).map((l) => truncate(l, Math.max(10, largura - et.length - 6)));
+        out.push(`⎿ ${et} ${mostra[0]}`);
+        for (const l of mostra.slice(1)) out.push(`  ${' '.repeat(et.length)} ${l}`);
+        if (linhas.length > 3) out.push(`  ${' '.repeat(et.length)} … +${linhas.length - 3} linhas`);
+    }
+    return out;
+}
 function pintarEtiquetas(s) { return String(s).replace(RE_ETIQUETA, (m) => c.brand(m) + '\x1b[38;5;254m'); }
 
 /* As cores do painel, no cubo de 256 cores. O fundo é um degrau acima do
@@ -248,12 +295,14 @@ function montar(e) {
 }
 
 /** O pedido que foi mandado, como fica no histórico da tela: um painel. */
-function pedidoNaTela(texto, colunas) {
+function pedidoNaTela(texto, colunas, guardados = []) {
     const largura = Math.max(24, Math.min(colunas || 80, 200)) - 1;
     const barra = `${COR.barra}┃${COR.reset}`;
     const linhas = quebrar(texto, Math.max(8, largura - PREFIXO))
         .map((l) => painel(barra + '   ' + pintarEtiquetas(c.white(l.texto)), largura));
-    return [painel(barra, largura), ...linhas, painel(barra, largura)].join('\n');
+    const extras = guardadosNaTela(guardados, largura - PREFIXO)
+        .map((l) => painel(barra + '   ' + c.dim(truncate(l, largura - PREFIXO)), largura));
+    return [painel(barra, largura), ...linhas, ...extras, painel(barra, largura)].join('\n');
 }
 
 // ── A caixa viva ─────────────────────────────────────────────────────────
@@ -403,6 +452,21 @@ class Entrada extends EventEmitter {
         if (this.ativo && !this.fechado) this._desenhar();
     }
 
+    /* UMA ESCOLHA QUE SOME depois de respondida (o /api, 13/10: "só apareça
+       pra qual modelo trocou, aquela lista enorme os números somem").
+       marcar() antes de listar, voltarPara(marca) depois: a lista, a pergunta
+       e a resposta saem da conversa, e fica só o que vier depois. Só na tela
+       cheia; no modo linha o terminal já rolou e o texto fica. */
+    marcar() { return this.cheia ? { n: this.conversa.length, ultima: this.conversa[this.conversa.length - 1] } : null; }
+    voltarPara(marca) {
+        if (!marca || !this.cheia || this.conversa.length < marca.n) return;
+        this.conversa.length = marca.n;
+        if (marca.n) this.conversa[marca.n - 1] = marca.ultima;
+        this.rolagem = 0;
+        this._quadroAnterior = null;
+        this._pintar();
+    }
+
     /** Um comando com tela própria desenha aqui (na tela cheia). null fecha. */
     painel(texto) {
         this.painelTexto = texto == null ? null : String(texto).replace(/\n+$/, '');
@@ -566,7 +630,7 @@ class Entrada extends EventEmitter {
         this._mudou();
     }
 
-    limpar() { this.line = ''; this.cursor = 0; this.menu = null; this.colados = new Map(); this._mudou(); }
+    limpar() { this.line = ''; this.cursor = 0; this.menu = null; this.colados = new Map(); this.nImagem = 0; this._mudou(); }
 
     /* COLAR VIRA ETIQUETA, como no Claude Code: texto grande colado (várias
        linhas, ou mais de 300 caracteres) entra na caixa como
@@ -576,10 +640,22 @@ class Entrada extends EventEmitter {
     colar(texto) {
         const t = String(texto || '');
         if (!t) return;
+        if (!this.colados) this.colados = new Map();
+        /* Imagem arrastada: uma etiqueta por arquivo, e no Enter volta o caminho.
+           O contador não reaproveita número: apagar a #1 não faz a próxima repetir a #2. */
+        const imagens = imagensArrastadas(t);
+        if (imagens) {
+            const ets = imagens.map((f) => {
+                this.nImagem = (this.nImagem || 0) + 1;
+                const et = `[Imagem #${this.nImagem}]`;
+                this.colados.set(et, f);
+                return et;
+            });
+            return this.write(ets.join(' ') + (/\s$/.test(t) ? ' ' : ''));
+        }
         const linhas = t.split('\n').length;
         if (linhas < 3 && t.length <= 300) return this.write(t);
-        if (!this.colados) this.colados = new Map();
-        const n = this.colados.size + 1;
+        const n = [...this.colados.keys()].filter((k) => k.startsWith('[Colado')).length + 1;
         const etiqueta = `[Colado #${n} · ${linhas > 1 ? `${linhas} linhas` : `${t.length} caracteres`}]`;
         this.colados.set(etiqueta, t);
         this.write(etiqueta);
@@ -890,7 +966,9 @@ class Entrada extends EventEmitter {
         if (this.menu) return this._escolherDoMenu();
         const visto = this.line;
         const texto = this.expandir(visto);
+        const guardados = [...(this.colados || [])].filter(([et]) => visto.includes(et));
         this.colados = new Map();
+        this.nImagem = 0;
         const oculto = this.oculto;
         this.oculto = false;
         this.line = '';
@@ -921,8 +999,8 @@ class Entrada extends EventEmitter {
                 const temAlgo = this.conversa.some((l) => /\S/.test(l));
                 const ultima = this.conversa[this.conversa.length - 1] || '';
                 const antes = !temAlgo ? '' : /\S/.test(ultima) ? '\n\n' : '\n';
-                tela.acrescentar(this.conversa, antes + pedidoNaTela(visto, mainW - 1) + '\n\n');
-            } else this.escreverCru(pedidoNaTela(visto, process.stdout.columns || 80) + '\n');
+                tela.acrescentar(this.conversa, antes + pedidoNaTela(visto, mainW - 1, guardados) + '\n\n');
+            } else this.escreverCru(pedidoNaTela(visto, process.stdout.columns || 80, guardados) + '\n');
             if (this.historico[this.historico.length - 1] !== texto) this.historico.push(texto);
         }
         this._desenhar();
@@ -932,4 +1010,4 @@ class Entrada extends EventEmitter {
 
 function criar(op) { return new Entrada(op).iniciar(); }
 
-module.exports = { criar, Entrada, montar, quebrar, encher, pintarEtiquetas, painel, pedidoNaTela, PREFIXO, COR };
+module.exports = { criar, Entrada, montar, quebrar, encher, pintarEtiquetas, painel, pedidoNaTela, imagensArrastadas, PREFIXO, COR };

package/lib/estudio/estilo.js

@@ -76,7 +76,29 @@ function estiloDaVez(aleatorio = Math.random, semImagem = false) {
     return variedade.sortear(lista, 'estilo', { aleatorio }) || lista[0];
 }
 
+/* O ESTILO DA CASA (13/10, sobre o primocode-ele-constroi.mp4: "esse vídeo tá
+   top! quero os vídeos nesse estilo, todos os vídeos que ele gerar"). Todo
+   vídeo é o GERATIVO — tipografia grande e reta, as cores da marca, Inter e
+   JetBrains Mono. O estilo que o agente ou o roteiro escolhem não vale mais:
+   o rodízio dava um vídeo de cada jeito. Muda só quando a PESSOA pede pelo
+   nome, ou pede a animação 3D com personagens (o personagem). */
+// Nome de estilo inequívoco, ou "estilo X". "Vídeo de lançamento" e "cinema" contam o assunto, não o estilo.
+const PEDE_PELO_NOME = /\b(fluid[oa]|vox|explainer|h[ií]brid[oa]|cl[aá]ssico|brand reveal|estilo (?:de )?(?:marca|impacto|cinema|lan[çc]amento|minimalista|fluido|vox))\b/i;
+const CASA = true;
+
 function escolherEstilo({ pedido = '', agente = null, roteiro = null, girar = false, semImagem = false, aleatorio } = {}) {
+    if (CASA) {
+        // O personagem 3D é outro produto (bonecos conversando), não um jeito do motion: esse o agente e o roteiro ainda pedem.
+        if (PEDE_PERSONAGEM.test(pedido) || normal(agente) === 'personagem' || normal(roteiro) === 'personagem') return 'personagem';
+        const nomeado = (String(pedido).match(PEDE_PELO_NOME) || [])[1];
+        if (nomeado) {
+            const x = nomeado.toLowerCase().replace(/^estilo (?:de )?/, '').replace(/^fluida$/, 'fluido').replace(/^h[ií]brid[oa]$/, 'hibrido')
+                .replace(/^brand reveal$/, 'marca').replace(/^minimalista$/, 'fluido').replace(/^explainer$/, 'vox').replace(/^cl[aá]ssico$/, 'classico').replace(/^lan[çc]amento$/, 'lancamento');
+            const n = normal(x);
+            if (n) return n;
+        }
+        return 'gerativo';
+    }
     const pedidoAgente = normal(agente);
     if (pedidoAgente) return pedidoAgente;
     const doRoteiro = normal(roteiro);
@@ -101,4 +123,4 @@ function escolherEstilo({ pedido = '', agente = null, roteiro = null, girar = fa
 /** Os estilos que usam os efeitos leves e a trilha do ende.app (os de motion, não os de corte). */
 const LEVES = new Set(['gerativo', 'motion', 'vox', 'marca', 'lancamento', 'fluido', 'personagem']);
 
-module.exports = { escolherEstilo, estiloDaVez, ESTILOS, LEVES, PEDE_MOTION, PEDE_FLUIDO, RODIZIO, RODIZIO_SEM_IMAGEM, PEDE_PERSONAGEM };
+module.exports = { escolherEstilo, estiloDaVez, ESTILOS, LEVES, PEDE_MOTION, PEDE_FLUIDO, RODIZIO, RODIZIO_SEM_IMAGEM, PEDE_PERSONAGEM, PEDE_PELO_NOME };

package/lib/estudio/gerativo.js

@@ -238,7 +238,7 @@ function acertosDeHumor(roteiro) {
    lê roteiro.escolhasGerativo, e a marca continua mandando por cima. */
 function escolherVisual(roteiro = {}, { aleatorio = Math.random } = {}) {
     const variedade = require('./variedade.js');
-    const marca = roteiro.marca || {};
+    const marca = require('./marca.js').marcaEmObjeto(roteiro.marca);
     const n = acertosDeHumor(roteiro);
     const max = Math.max(...Object.values(n));
     const humor = variedade.sortear(Object.keys(HUMORES), 'humor-gerativo', { aleatorio, adequacao: (h) => (n[h] + 1) / (max + 1) });
@@ -637,7 +637,11 @@ function camposDe(marca, humor, s, dita = null, fixa = null) {
     if (dita && !ehCor(c.destaque)) { const j = k.indexOf(dita); if (j > 0) k[j] = k[1]; k[1] = dita; }
     // A marca: o fundo dela, o destaque dela e a tinta dela tomam os lugares de mesmo papel.
     const escuro = (x) => luz(x) < 0.35, claro = (x) => luz(x) > 0.7;
-    for (const cor of [c.fundo, c.destaque, c.tinta].filter(ehCor)) {
+    /* Marca de fundo escuro sem tinta declarada: o claro é o branco frio, não
+       o creme do sorteio (o motion do PrimoCode, preto e ciano, ganhava fundo
+       #F1EADB na lista e no fim — 13/10). */
+    const tinta = ehCor(c.tinta) ? c.tinta : (ehCor(c.fundo) && luz(c.fundo) < 0.2 ? '#F5F5F7' : null);
+    for (const cor of [c.fundo, c.destaque, tinta].filter(ehCor)) {
         const lugar = escuro(cor) ? 0 : claro(cor) ? 2 : 1;
         if (!k.includes(cor)) k[lugar] = cor;
     }
@@ -941,7 +945,7 @@ function montarGerativo({ roteiro, largura = 1920, altura = 1080, tempos = [], n
 /** A partitura, sem áudio nem plano — é o que os testes olham. */
 function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [], icones = {} }) {
     const partes = roteiro.partes || [];
-    const marca = roteiro.marca || {};
+    const marca = require('./marca.js').marcaEmObjeto(roteiro.marca);
     const W = largura, H = altura, deitado = W >= H;
     const semente = roteiro.semente != null ? hash('semente:' + roteiro.semente)
         : hash(JSON.stringify([partes.map((p) => [p.tipo, p.titulo, p.texto, p.fala, p.valor, p.itens, p.nao, p.sim, p.destaque]), marca.nome || '']));
@@ -959,8 +963,14 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [], icon
        eixos para animar); a genérica da marca vira texto, e o título ganha
        uma face da biblioteca do humor. ─────────────────────────────────── */
     const pedida = (marca.fontes && marca.fontes.titulo) || '';
-    const pedidaTexto = (marca.fontes && marca.fontes.texto) || '';
-    const boa = (f) => f && VARIAVEIS[f] && !BANIDAS.includes(f) && VARIAVEIS[f].eixos.wght;
+    /* O texto da marca; sem ele, a mono da marca (o site do PrimoCode é a
+       Instrument Serif nos títulos e a JetBrains Mono no resto, 13/10). */
+    const monoMarca = (marca.fontes && marca.fontes.mono) || '';
+    const pedidaTexto = (marca.fontes && marca.fontes.texto) || (VARIAVEIS[monoMarca] ? monoMarca : '');
+    /* A da marca vale se a biblioteca carrega (e não é cara de IA), mesmo sem
+       eixo de peso: sem eixo ela só não anima o peso. Exigir o wght trocava a
+       Instrument Serif do site por uma Bodoni sorteada (13/10). */
+    const boa = (f) => f && VARIAVEIS[f] && !BANIDAS.includes(f);
     const ou = (salva, sorteada) => salva || sorteada;
     const display = boa(pedida) ? pedida : ou(E.display, s.um(H0.displays));
     const cinetica = eixoDe(display, 'wdth') && eixoDe(display, 'wdth')[0] <= 75 ? display : s.um(H0.cineticas);
@@ -1129,7 +1139,12 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [], icon
         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];
+    /* Com marca, a ousada é a de APOIO da marca, ou nenhuma: o amarelo do
+       sistema sorteado entrava de fundo no motion preto e ciano do PrimoCode (13/10). */
+    const mc = marca.cores || {};
+    const daMarca = ehCor(mc.fundo) || ehCor(mc.destaque);
+    const ousada = daMarca ? (ehCor(mc.apoio) && mc.apoio !== ident.acento ? mc.apoio : null)
+        : [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));
@@ -1453,6 +1468,36 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [], icon
     fundo.ambiente = AMBIENTES.includes(roteiro.ambiente) ? roteiro.ambiente : E.ambiente || 'limpo';
     fundo.acento = ACENTOS_JEITO.includes(roteiro.acento) ? roteiro.acento : E.acento || 'traco';
 
+    /* SEM LETRA TORTA (13/10: "os motions saem muito tortos"). A letra que
+       vira outra antes de assentar (decodifica, flap), a que chega voando e
+       girando (monta), a que entra inclinada (onda) e a palavra que explode em
+       letras rodando deixavam o "SGERE", o "a o" solto e o quadro vazio de
+       letras fantasmas. Os sorteios acontecem igual (a semente não muda o
+       resto); no fim, cada gesto vira o seu par limpo. */
+    /* O substituto é um limpo que não aparece nas 3 batidas de cada lado: a
+       passagem e o gesto da tese não voltam antes de 3 batidas. */
+    const TORTOS = ['decodifica', 'flap', 'onda', 'monta'];
+    const GESTOS_LIMPOS = ['mascara', 'desfoque', 'tracking', 'pontos', 'contorno', 'carimbo'];
+    const SAIDAS_LIMPAS = ['evapora', 'desliza', 'comprime', 'pontos', 'atravessa'];
+    const vizinhas = (i) => batidas.filter((_, j) => j !== i && Math.abs(j - i) <= 3);
+    const principal = (b) => (b.linhas || []).find((l) => (l.papel === 'tese' || l.papel === 'numero') && !l.marca);
+    const comGesto = batidas.filter(principal);
+    batidas.forEach((b, i) => {
+        if (b.saida === 'explode' || b.saida === 'chicote') {
+            const perto = vizinhas(i).map((x) => x.saida);
+            b.saida = SAIDAS_LIMPAS.find((x) => !perto.includes(x)) || 'corte';
+            if (batidas[i + 1]) batidas[i + 1].entrada = b.saida;
+        }
+        const tortas = (b.linhas || []).filter((l) => TORTOS.includes(l.comportamento));
+        if (tortas.length) {
+            // A janela conta só as batidas com linha principal (tese ou número, fora a marca), como quem assiste vê.
+            const k = comGesto.indexOf(b);
+            const perto = k < 0 ? [] : comGesto.filter((_, j) => j !== k && Math.abs(j - k) <= 3).map((x) => principal(x).comportamento);
+            const limpo = GESTOS_LIMPOS.find((x) => !perto.includes(x)) || 'mascara';
+            for (const l of tortas) l.comportamento = limpo;
+        }
+    });
+
     return {
         versao: 1, semente, fps: FPS, humor,
         musica: { genero: ou(E.genero, s.um(H0.generos)), generos: H0.generos }, largura: W, altura: H, duracao, regras: REGRAS,
@@ -1480,14 +1525,16 @@ function molduraDe(roteiro, E, { W, H, deitado, marca, secoes }) {
     };
 }
 
+/* O eixo de peso da fonte; a estática (a Instrument Serif da marca) é só 400. */
+const pesoDe = (fonte) => (VARIAVEIS[fonte] && VARIAVEIS[fonte].eixos.wght) || [400, 400];
+
 // ── as composições: de conteúdo + contexto, uma batida ─────────────────
 function compor(comp, br, ctx) {
     const { s, W, H, M, deitado, base, larguraUtil, tamRotulo, fontes } = ctx;
     const c = br.conteudo;
     const palavras = ctx.palavras || [];
     const b = { id: 'b' + Math.round(br.de * 1000), parte: br.parte, de: r3(br.de), ate: r3(br.ate), comp, origem: c.tipo === 'falado' ? 'falado' : 'conteudo', linhas: [], acento: [] };
-    const eixosDisplay = VARIAVEIS[fontes.display].eixos;
-    const wMax = eixosDisplay.wght[1];
+    const wMax = pesoDe(fontes.display)[1];
     const wTese = Math.min(wMax, s.um([800, 900, 900, 1000]));
     const destaqueTk = tokens(c.destaque || '');
     const ehTese = (w) => destaqueTk.length && tokens(w).some((k) => destaqueTk.includes(k));
@@ -1516,13 +1563,21 @@ function compor(comp, br, ctx) {
     };
     const vert = (opcoes) => s.um(opcoes);
     const tese = (l) => { l.papel = 'tese'; return l; };
+    /* O ponto do acento ENTRA NO LUGAR do ponto final: com os dois, saía
+       "Uma ideia.." (13/10). */
+    const pontoFinal = (l) => {
+        l.texto = l.texto.replace(/\.$/, '');
+        const u = l.palavras[l.palavras.length - 1];
+        if (u) u.texto = u.texto.replace(/\.$/, '');
+        b.acento.push({ forma: 'ponto', alvo: { linha: l.id, fim: true } });
+    };
 
     switch (comp) {
         case 'gigante': {
             const txt = c.titulo || c.nome || c.sim || c.valor || c.texto || '';
             const maiusc = txt.length <= 16 && s.chance(0.65);
             const fonte = s.chance(0.5) ? fontes.cinetica : fontes.display;
-            const eixos = { wght: Math.min(VARIAVEIS[fonte].eixos.wght[1], wTese) };
+            const eixos = { wght: Math.min(pesoDe(fonte)[1], wTese) };
             const op = { fonte, wght: eixos.wght, maiusc };
             // 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);
@@ -1543,7 +1598,7 @@ function compor(comp, br, ctx) {
                plano inteiro (12/10, o estilo padrão quebrava). Sem linha, sem acento. */
             if (!ultima) break;
             if (c.riscado) b.acento.push({ forma: 'risco', alvo: { linha: ultima.id } });
-            else if (/[.!]$/.test(txt) || s.chance(0.4)) b.acento.push({ forma: 'ponto', alvo: { linha: ultima.id, fim: true } });
+            else if (/[.!]$/.test(txt) || s.chance(0.4)) pontoFinal(ultima);
             else {
                 const lt = b.linhas.find((l) => l.papel === 'tese' && l.palavras.some((p) => p.papel === 'tese')) || ultima;
                 const pi = Math.max(0, lt.palavras.findIndex((p) => p.papel === 'tese'));
@@ -1608,13 +1663,13 @@ function compor(comp, br, ctx) {
             for (const t of fit.linhas) { const l = linha(t, 'apoio', { tamanho: fit.tamanho, eixos: { wght: 560 } }); misturarPesos(l, { maiorTese: 1.14 }); }
             const lt = b.linhas.find((l) => l.palavras.some((p) => p.papel === 'tese'));
             if (lt) { tese(lt); b.acento.push({ forma: s.chance(0.6) ? 'sublinha' : 'anel', alvo: { linha: lt.id, palavra: lt.palavras.findIndex((p) => p.papel === 'tese') } }); }
-            else b.acento.push({ forma: 'ponto', alvo: { linha: b.linhas[b.linhas.length - 1].id, fim: true } });
+            else pontoFinal(b.linhas[b.linhas.length - 1]);
             break;
         }
         case 'contador': {
             const n = numeroDe(c.valor);
             const fonte = s.chance(0.6) ? fontes.cinetica : fontes.display;
-            const eixos = { wght: Math.min(VARIAVEIS[fonte].eixos.wght[1], wTese) };
+            const eixos = { wght: Math.min(pesoDe(fonte)[1], wTese) };
             const alinha = 'centro';
             const lg = deitado ? W * 0.62 : larguraUtil;
             const tam = tamanhoQueCabe(c.valor, lg * 0.82, (deitado ? 0.36 : 0.17) * H, { fonte, wght: eixos.wght });
@@ -1653,8 +1708,11 @@ 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.13 : 0.08) * H, { ...op, wght: 400 });
-            const fS = caberEmLinhas(c.sim, lado, deitado ? 3 : 3, (deitado ? 0.17 : 0.1) * H, op);
+            /* Teto mais alto (13/10): com 13% e 17% da altura, "sugere / constrói"
+               ficava miúdo no canto, metade do tamanho do gigante ao lado. A
+               largura da metade é que segura a frase longa. */
+            const fN = caberEmLinhas(c.nao, lado, deitado ? 3 : 2, (deitado ? 0.2 : 0.11) * H, { ...op, wght: 400 });
+            const fS = caberEmLinhas(c.sim, lado, deitado ? 3 : 3, (deitado ? 0.26 : 0.14) * 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 {
@@ -1688,7 +1746,7 @@ function compor(comp, br, ctx) {
             const lg = deitado ? W * 0.7 : larguraUtil * 0.9;
             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;
+            linha(nome, 'tese', { fonte, tamanho: tam, eixos: { wght: Math.min(800, pesoDe(fonte)[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 } });
             b.acento.push({ forma: 'ponto', alvo: { linha: b.linhas[0].id, antes: true } });
             break;
@@ -1699,7 +1757,7 @@ function compor(comp, br, ctx) {
             const maiusc = true;
             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 });
+            linha(txt, 'tese', { fonte, tamanho: tam, eixos: { wght: Math.min(900, pesoDe(fonte)[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) };
             // Moldura em volta da palavra é vício de "cara de IA" (a caixa na palavra-chave); sai em 08/10.
             b.acento.push({ forma: s.chance(0.5) ? 'ponto' : 'sublinha', alvo: { linha: b.linhas[0].id } });

package/lib/estudio/index.js

@@ -47,6 +47,7 @@ const assets = require('./assets.js');
 const video = require('./video.js');
 const batida = require('./batida.js');
 const revisor = require('./revisor.js');
+const marcaLib = require('./marca.js');
 const conferencia = require('./conferencia.js');
 const margem = require('./margem.js');
 const assinatura = require('./assinatura.js');
@@ -510,6 +511,15 @@ async function ferramentaMidia(args) {
 
     /* O ELEMENTO do site, tirado pelo código (print-site.js): a lista das peças
        (logo, botão, cartão, título…) e uma peça sozinha, com o fundo transparente. */
+    /* A REFERÊNCIA VISUAL que a pessoa manda (13/10: "não usa as referências
+       que mandei" — era o print da landing, arrastado no pedido). O agente não
+       enxerga imagem; aqui ela entra no projeto, as cores saem pelo ffmpeg e,
+       se o projeto ainda não tem marca, viram a marca. Com site, o site manda. */
+    if (acao === 'referencia' || acao === 'referência') {
+        if (!p) return semProjeto(args.id);
+        return importarReferencia(p, String(args.arquivo || args.caminho || args.src || ''));
+    }
+
     if (acao === 'elementos') return printSite.elementosDoSite(args.url || args.site || args.termo, { celular: !!args.celular });
     if (acao === 'elemento') {
         if (!p) return { ok: false, error: 'para tirar o elemento é preciso dizer em qual projeto (id).' };
@@ -1248,6 +1258,32 @@ function conferirAssinatura(p, r, nome) {
     projeto.anotar(p.id, 'assinatura', fora.length ? `fora da assinatura ${nome}: ${fora.join('; ')}` : `seguiu a assinatura ${nome}`);
 }
 
+/* A REFERÊNCIA VISUAL que a pessoa manda (13/10: "não usa as referências
+   que mandei" — era o print da landing, arrastado no pedido). O agente não
+   enxerga imagem; aqui ela entra no projeto, as cores saem pelo ffmpeg e, se o
+   projeto ainda não tem marca, viram a marca. Com site, o site manda. */
+function importarReferencia(p, arquivo) {
+    const orig = String(arquivo || '').trim().replace(/^file:\/\//, '');
+    if (!orig || !fs.existsSync(orig)) return { ok: false, error: 'mande em "arquivo" o caminho da imagem de referência.' };
+    const nome = path.basename(orig).normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/[^\w.-]+/g, '-');
+    const destino = path.join(p.pasta, 'midia', 'referencias', nome);
+    fs.mkdirSync(path.dirname(destino), { recursive: true });
+    fs.copyFileSync(orig, destino);
+    const rel = path.relative(p.pasta, destino).replace(/\\/g, '/');
+    const cores = marcaLib.coresDaImagem(destino);
+    const temMarca = !!(p.marca && Object.keys(marcaLib.marcaEmObjeto(p.marca).cores || {}).length);
+    const salvar = { referencias: [...(p.referencias || []).filter((x) => x.src !== rel), { src: rel, cores, de: orig }] };
+    if (!temMarca && cores.length) salvar.marca = { ...(p.marca || {}), ...marcaLib.marcaEmObjeto({ cores }) };
+    projeto.salvar(p.id, salvar);
+    projeto.anotar(p.id, 'referencia', `imagem ${rel}: ${cores.join(' ') || 'sem cor'}${temMarca ? '' : ' (virou a marca)'}`);
+    return {
+        ok: true, src: rel, cores, viraMarca: !temMarca && cores.length > 0,
+        comoUsar: (temMarca ? 'O projeto já tem a marca do site: ela manda nas cores; a referência guia o JEITO (composição, peso, o que aparece). '
+            : 'Estas cores viraram a marca do projeto. ')
+            + 'Se a imagem é print do site ou do produto, o vídeo mostra a tela de verdade (estudio_midia acao:"print" e a peça printsite).',
+    };
+}
+
 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 } });
@@ -1258,8 +1294,16 @@ async function prepararRoteiro(p, args) {
     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; }
     }
+    // As imagens do pedido (o terminal guardou em referencias.imagens) entram sozinhas, uma vez por projeto.
+    const jaTem = new Set((p.referencias || []).map((x) => x.de));
+    const novas = referencias.imagens().filter((f) => !jaTem.has(f));
+    for (const f of novas) { try { importarReferencia(p, f); } catch (e) { projeto.anotar(p.id, 'referencia', `não importou ${path.basename(f)}: ${e.message}`); } }
+    if (novas.length) p = projeto.ler(p.id) || p;
     if (roteiro.marca) {
-        roteiro.marca = { ...(p.marca || {}), ...roteiro.marca };
+        /* A do roteiro por cima da do site, CAMPO A CAMPO: antes o "cores" em
+           lista do agente apagava o {fundo, destaque} lido do site (13/10). */
+        const site = marcaLib.marcaEmObjeto(p.marca), dele = marcaLib.marcaEmObjeto(roteiro.marca);
+        roteiro.marca = { ...site, ...dele, cores: { ...(site.cores || {}), ...(dele.cores || {}) }, fontes: { ...(site.fontes || {}), ...(dele.fontes || {}) } };
         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 || [];
@@ -1277,6 +1321,12 @@ async function prepararRoteiro(p, args) {
     const semImagem = referencias.semImagem(ref);
     let estilo = escolherEstilo({ pedido: pedidoTxt, agente: args.estilo, roteiro: roteiro.estilo, girar: true, semImagem });
     if (semImagem && (estilo === 'hibrido' || estilo === 'cinema')) estilo = 'gerativo';
+    /* AS FONTES DA CASA (13/10, o primocode-ele-constroi.mp4 que o Joel aprovou):
+       no gerativo, título em Inter e texto em JetBrains Mono, com as CORES da
+       marca. Só muda se o pedido falar de fonte. */
+    if (estilo === 'gerativo' && !/\bfontes?\b|tipografia|\bserifa/i.test(pedidoTxt)) {
+        roteiro.marca = { ...(roteiro.marca || {}), fontes: { titulo: 'Inter', texto: 'JetBrains Mono' } };
+    }
     /* "O vídeo deve ter um 3D do fone" (30/09): pedido de 3D vira o gerativo
        com o produto modelado girando numa batida (kit/tres.jsx) — a menos que
        o agente tenha escolhido outro estilo pelo nome. */
@@ -1848,6 +1898,9 @@ async function prepararRoteiro(p, args) {
                 } catch { /* fica sem */ }
                 continue;
             }
+            // O ícone do próprio site (estudio_site guardou os <svg> na marca).
+            const doSite = h.match(/^site:(\d+)$/i);
+            if (doSite) { const x = ((roteiro.marca || {}).iconesSite || [])[Number(doSite[1]) - 1]; if (x && x.svg) icones[h] = x.svg; continue; }
             if (!/^[a-z0-9-]+:[a-z0-9-]+$/i.test(h) || icones[h]) continue;
             try { const ic = await assets.icone(h, { pasta: p.pasta }); if (ic && ic.ok) icones[h] = ic.svg; else projeto.anotar(p.id, 'icones', `herói ${h} não baixou: ${(ic && ic.error) || '?'}`); } catch { /* fica sem */ }
         }
@@ -2235,6 +2288,9 @@ async function ferramentaSite(args) {
                         }
                     }
                 } catch { /* sem gradiente */ }
+                /* Os ícones do próprio site (os <svg> dos cartões): viram "site:N" no roteiro. */
+                const icSite = marcaLib.iconesDoSite(html);
+                if (icSite.length) { marca.iconesSite = icSite; r.icones = icSite.map((x, i) => `site:${i + 1}${x.nome ? ' (' + x.nome + ')' : ''}`); }
                 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;
@@ -2248,7 +2304,8 @@ async function ferramentaSite(args) {
                 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.';
+                    + 'a logo em roteiro.marca (objeto: {cores: {fundo, destaque, tinta}, fontes: {titulo, texto}}).'
+                    + (r.icones ? ' Os ícones do site estão em "icones": ponha icone:"site:N" na parte em que o assunto dele aparece.' : '');
             } catch (e) {
                 r.acervo = { erro: e.message };
             }

package/lib/estudio/kit/gerativo.jsx

@@ -430,8 +430,8 @@ function letra({ t, fps, l, p, j, ch, i, idx, n, b, cx, cores, eixosF, alvoSaida
   const centroLinha = cx ? cx.x + cx.w / 2 : 0;
   switch (c) {
     case 'carimbo': {
-      const r0 = (acaso(semente) - 0.5) * 8;
-      tr.push('rotate(' + (r0 * (1 - m)).toFixed(2) + 'deg)', 'scale(' + (1 + 0.32 * (1 - m)).toFixed(4) + ')');
+      // Sem inclinação: a letra carimbada torta lia como defeito (13/10). Fica o impacto da escala.
+      tr.push('scale(' + (1 + 0.32 * (1 - m)).toFixed(4) + ')');
       const f = tl * fps;
       blur = f < 2 ? 1.4 : Math.max(0, 0.7 * (1 - (f - 2) / 7));
       break;
@@ -917,7 +917,11 @@ export function Gerativo({ el, t, fps }) {
      leve a cada meio segundo, como um bumbo. */
   // A respiração lenta do mundo (sem bumbo: o pulso batendo lia como tranco).
   sz += 0.008 * Math.sin((t * Math.PI * 2) / 3.4);
-  const cam = { x: cam0.x + sx, y: cam0.y + sy, zoom: cam0.zoom * (1 + sz), rot: cam0.rot + sr };
+  /* A câmera NÃO GIRA (13/10, "os motions saem muito tortos"): o giro das
+     chaves (cam0.rot) e o da deriva (sr) inclinavam o mundo inteiro, e todo
+     texto saía com a linha de base caída. Ficam a deriva, o zoom e o tranco. */
+  void sr;
+  const cam = { x: cam0.x + sx, y: cam0.y + sy, zoom: cam0.zoom * (1 + sz), rot: 0 };
   const ac0 = acentoEm(t, estados);
   // O acento também vive: treme de leve e respira na espessura.
   const ac = { ...ac0, pts: ac0.pts.map((q, i) => [q[0] + Math.sin(t * 3.1 + i * 0.5) * 1.6 * base, q[1] + Math.cos(t * 2.7 + i * 0.37) * 1.6 * base]), larg: ac0.larg * (1 + 0.08 * Math.sin(t * 4.2)) };
@@ -929,7 +933,8 @@ export function Gerativo({ el, t, fps }) {
   const origem = tela(ac.cx, ac.cy);
   /* O ESPAÇO 3D: o mundo tem perspectiva, a câmera também inclina (rotateX/Y)
      e as camadas estão em profundidades diferentes — o texto não é adesivo. */
-  const rx = Math.cos(t * 0.27) * 1.4, ry = Math.sin(t * 0.31) * 2 + cam.rot * 0.6;
+  // A perspectiva fica, mas quase parada: 1,4° e 2° deixavam a frase em trapézio.
+  const rx = Math.cos(t * 0.27) * 0.35, ry = Math.sin(t * 0.31) * 0.5;
   const mundo = 'translate(' + W / 2 + 'px,' + H / 2 + 'px) rotate(' + cam.rot.toFixed(3) + 'deg) rotateX(' + rx.toFixed(3) + 'deg) rotateY(' + ry.toFixed(3) + 'deg) scale(' + cam.zoom.toFixed(4) + ') translate(' + (-W / 2 - cam.x).toFixed(1) + 'px,' + (-H / 2 - cam.y).toFixed(1) + 'px)';
   // No ar: a batida atual, a anterior enquanto sai.
   const noAr = bs.filter((x, i) => i === bi || (i === bi - 1 && t < x.ate + 0.14 && x.saida !== 'corte'));

package/lib/estudio/marca.js

@@ -280,4 +280,109 @@ async function marcaDaEmpresa(args, { projectDir, studio }) {
     };
 }
 
-module.exports = { marcaDaEmpresa, candidatasALogo, coresDe, fontesDe, metas, atributo };
+/* A MARCA EM LISTA VIRA OBJETO (13/10). O agente escreve a marca do jeito
+   que leu: "cores": ["#22d3ee", "#0a0b0b", …], "fontes": ["Instrument
+   Serif", "JetBrains Mono"]. O Estúdio lê {fundo, destaque, tinta} e
+   {titulo, texto, mono}. Sem a conversão, `cores.fundo` não existia, o
+   gerativo achava que não havia marca e sorteava o humor: o motion do
+   PrimoCode saiu vermelho e creme em Bodoni, com o site preto e ciano.
+     cores   a primeira escura é o fundo, a primeira viva o destaque (a
+             segunda, o apoio), a primeira clara a tinta;
+     fontes  a mono vai para mono; das outras, a 1ª é título e a 2ª texto.
+   O que já é objeto passa intacto. */
+function marcaEmObjeto(m) {
+    if (!m || typeof m !== 'object') return {};
+    const out = { ...m };
+    if (Array.isArray(m.cores)) {
+        const rgb = (h) => { const n = parseInt(h.slice(1), 16); return [n >> 16, (n >> 8) & 255, n & 255].map((v) => v / 255); };
+        const luz = (h) => { const [r, g, b] = rgb(h); return 0.2126 * r + 0.7152 * g + 0.0722 * b; };
+        const sat = (h) => { const v = rgb(h); return Math.max(...v) - Math.min(...v); };
+        const cs = m.cores.map((x) => String((x && x.cor) || x || '').trim()).filter((x) => /^#[0-9a-f]{6}$/i.test(x));
+        const vivas = cs.filter((x) => sat(x) > 0.25);
+        const fundo = cs.find((x) => luz(x) < 0.12 && sat(x) <= 0.25);
+        const tinta = cs.find((x) => luz(x) > 0.8 && sat(x) <= 0.25);
+        out.cores = { ...(fundo ? { fundo } : {}), ...(vivas[0] ? { destaque: vivas[0] } : {}), ...(vivas[1] ? { apoio: vivas[1] } : {}), ...(tinta ? { tinta } : {}) };
+    }
+    if (Array.isArray(m.fontes)) {
+        const fs = m.fontes.map((f) => String((f && f.nome) || f || '').trim()).filter(Boolean);
+        const mono = fs.find((f) => /mono|code|consol/i.test(f));
+        const resto = fs.filter((f) => f !== mono);
+        out.fontes = { ...(resto[0] ? { titulo: resto[0] } : {}), ...(resto[1] ? { texto: resto[1] } : {}), ...(mono ? { mono } : {}) };
+    }
+    return out;
+}
+
+/* OS ÍCONES DO SITE (13/10: "não usa os ícones do site"). Os ícones de uma
+   landing quase sempre são <svg> inline (o desenho de traço ao lado de cada
+   cartão), e não arquivos. Aqui saem os pequenos — com viewBox, sem imagem
+   nem script dentro, até 4 KB — com um nome: o aria-label, o <title>, ou o
+   título (h2/h3/h4) logo depois dele no HTML. No roteiro viram "site:N". */
+function iconesDoSite(html, max = 12) {
+    const out = [], vistos = new Set();
+    const re = /<svg\b[^>]*>[\s\S]*?<\/svg>/gi;
+    let m;
+    while ((m = re.exec(String(html || ''))) && out.length < max) {
+        const svg = m[0];
+        if (svg.length > 4000 || /<(image|script|foreignObject)\b/i.test(svg) || !/viewBox=/i.test(svg)) continue;
+        const abre = svg.slice(0, svg.indexOf('>') + 1);
+        const lado = Number((abre.match(/\b(?:width|height)=["']?(\d+)/i) || [])[1] || 0);
+        if (lado > 120) continue;
+        const corpo = svg.replace(/\s+/g, ' ');
+        if (vistos.has(corpo)) continue;
+        vistos.add(corpo);
+        const depois = String(html).slice(re.lastIndex, re.lastIndex + 500);
+        const nome = (abre.match(/aria-label=["']([^"']+)/i) || [])[1]
+            || (svg.match(/<title>([^<]+)<\/title>/i) || [])[1]
+            || ((depois.match(/<h[2-4][^>]*>([\s\S]*?)<\/h[2-4]>/i) || [])[1] || '').replace(/<[^>]+>/g, '').trim()
+            || '';
+        out.push({ nome: nome.slice(0, 40), svg });
+    }
+    return out;
+}
+
+/* AS CORES DE UMA IMAGEM (a referência que a pessoa manda: o print do site,
+   um frame, um anúncio de que gostou). O ffmpeg reduz a imagem a 160 px e
+   devolve os pixels; as cores parecidas viram uma, e saem as 6 que mais
+   aparecem, da mais comum à menos. Sem ffmpeg, lista vazia. */
+function coresDaImagem(arquivo, max = 6) {
+    const { spawnSync } = require('child_process');
+    const r = spawnSync('ffmpeg', ['-v', 'error', '-i', arquivo, '-vf', 'scale=160:-1', '-frames:v', '1', '-f', 'rawvideo', '-pix_fmt', 'rgb24', '-'], { maxBuffer: 1 << 22 });
+    if (r.status !== 0 || !r.stdout || !r.stdout.length) return [];
+    const conta = new Map();
+    for (let i = 0; i + 2 < r.stdout.length; i += 3) {
+        const k = ((r.stdout[i] >> 3) << 10) | ((r.stdout[i + 1] >> 3) << 5) | (r.stdout[i + 2] >> 3);
+        conta.set(k, (conta.get(k) || 0) + 1);
+    }
+    const hex = (k) => '#' + [(k >> 10) & 31, (k >> 5) & 31, k & 31].map((v) => (v * 8 + 4).toString(16).padStart(2, '0')).join('');
+    const rgb = (h) => [1, 3, 5].map((i) => parseInt(h.slice(i, i + 2), 16));
+    const longe = (a, b) => { const x = rgb(a), y = rgb(b); return Math.hypot(x[0] - y[0], x[1] - y[1], x[2] - y[2]); };
+    // As 4 mais comuns, e as 2 mais VIVAS que aparecem de verdade: a cor da
+    // marca costuma ocupar pouca área (o ciano de um título, o botão), e sem
+    // isto o print dava só fundo e cinza.
+    const total = r.stdout.length / 3;
+    const sat = (h) => { const v = rgb(h); return (Math.max(...v) - Math.min(...v)) / 255; };
+    const lista = [...conta].sort((a, b) => b[1] - a[1]).map(([k, n]) => ({ h: hex(k), n }));
+    const out = [];
+    const por = (x) => { if (out.length < max && out.every((o) => longe(o, x.h) > 48)) out.push(x.h); };
+    for (const x of lista) { if (out.length >= Math.max(1, max - 2)) break; por(x); }
+    /* As vivas se espalham em dezenas de tons de 1 ou 2 pixels (a borda da
+       letra mistura com o fundo): contam por MATIZ, em faixas de 30°, e de
+       cada faixa vale o pixel mais vivo — o miolo da letra, não a borda. */
+    const faixas = new Map();
+    for (let i = 0; i + 2 < r.stdout.length; i += 3) {
+        const v = [r.stdout[i], r.stdout[i + 1], r.stdout[i + 2]], mx = Math.max(...v), mn = Math.min(...v), d = mx - mn;
+        if (d / 255 < 0.35 || mx < 60) continue;
+        const hh = mx === v[0] ? ((v[1] - v[2]) / d) % 6 : mx === v[1] ? (v[2] - v[0]) / d + 2 : (v[0] - v[1]) / d + 4;
+        const f = Math.floor(((hh * 60 + 360) % 360) / 30);
+        const x = faixas.get(f) || { n: 0, melhor: null, nota: -1 };
+        x.n++;
+        const nota = d * mx;
+        if (nota > x.nota) { x.nota = nota; x.melhor = '#' + v.map((c) => c.toString(16).padStart(2, '0')).join(''); }
+        faixas.set(f, x);
+    }
+    [...faixas.values()].filter((x) => x.n >= Math.max(8, total * 0.0005)).sort((a, b) => b.n - a.n).slice(0, 2).forEach((x) => por({ h: x.melhor }));
+    void sat; void lista;
+    return out;
+}
+
+module.exports = { marcaDaEmpresa, candidatasALogo, coresDe, fontesDe, metas, atributo, marcaEmObjeto, iconesDoSite, coresDaImagem };

package/lib/estudio/referencias.js

@@ -80,8 +80,12 @@ function notasDaAssinatura() {
 function instrucao(atual = ATUAL) { const i = instrucaoDoModo(atual); return i ? i + notasDaAssinatura() : ''; }
 function instrucaoDoModo({ modo, escopo, explicito } = ATUAL) {
     // O vídeo sem imagem é motion: o agente escolhe o estilo de motion que serve ao roteiro, não um fixo.
-    const motion = 'O vídeo é MOTION: tipografia, formas, ícones, animação e som. Escolha em roteiro.estilo o motion que serve a este '
-        + 'roteiro (gerativo, fluido, impacto, vox, marca, lancamento) ou deixe vazio para o rodízio — não repita sempre o mesmo.';
+    const motion = 'O vídeo é MOTION: tipografia, formas, ícones, animação e som, no ESTILO DA CASA (o gerativo, com as cores da '
+        + 'marca): não ponha roteiro.estilo, a menos que a pessoa tenha pedido outro estilo pelo nome. '
+        /* O ROTEIRO (13/10: "o roteiro que monta é horrível" — eram os títulos da landing em fila). */
+        + 'O ROTEIRO é uma história de 15 a 25 s: gancho (a situação de quem assiste) → o que o produto FAZ → UMA prova concreta '
+        + 'dos fatos do site → a ação (nome, comando, link). Nunca os títulos das seções do site em sequência. Cada fala tem de 5 a '
+        + '12 palavras e puxa a próxima; o titulo da parte é a palavra-chave (1 a 4 palavras), não a fala repetida.';
     if (modo === 'sem' && explicito) {
         return '[REFERÊNCIAS: NENHUMA] A pessoa quer SÓ MOTION: não pesquise (nada de pesquisar_referencia nem estudio_site), '
             + 'não busque foto nem vídeo, não use estudio_midia de banco. Escreva o roteiro com o que o pedido já diz. ' + motion;
@@ -124,4 +128,42 @@ function filtrar(r, { modo, escopo } = ATUAL) {
     return { ...r, fontes: refs.length, referencias: refs, ...(fora ? { foraDoEscopo: fora } : {}) };
 }
 
-module.exports = { definir, atual, limpar, semImagem, termos, entender, inferir, instrucao, dominios, filtrar };
+/* AS IMAGENS DO PEDIDO (13/10: "não usa as referências que mandei" — era o
+   print da landing, arrastado no pedido). O modelo do servidor não enxerga
+   imagem e nem pode chamar a importação (a lista de ações dele é fechada),
+   então o terminal guarda aqui os caminhos de imagem que EXISTEM no texto do
+   pedido, e o Estúdio importa sozinho no próximo roteiro (index.js). */
+let IMAGENS = [];
+const RE_EXT_IMG = /\.(png|jpe?g|gif|webp|heic|bmp)\b/gi;
+function imagensNoTexto(texto) {
+    const fs = require('fs'), os = require('os');
+    const t = String(texto || '');
+    const achadas = [];
+    let m;
+    while ((m = RE_EXT_IMG.exec(t))) {
+        const fim = m.index + m[0].length;
+        // Do fim da extensão para trás: o começo é uma "/" (ou "~/", "file://") no início ou depois de espaço/aspas.
+        let melhor = null;
+        for (let i = m.index; i >= 0; i--) {
+            if (t[i] !== '/' && !(t[i] === '~' && t[i + 1] === '/')) continue;
+            const antes = i === 0 ? ' ' : t[i - 1];
+            if (!/[\s'"(:]/.test(antes) && !(t.slice(Math.max(0, i - 7), i) === 'file://')) continue;
+            const bruto = t.slice(i, fim).replace(/\\(.)/g, '$1').replace(/^~(?=\/)/, os.homedir());
+            try { if (fs.statSync(bruto).isFile()) melhor = bruto; } catch { /* não é este começo */ }
+        }
+        if (melhor && !achadas.includes(melhor)) achadas.push(melhor);
+    }
+    return achadas.slice(0, 6);
+}
+function guardarImagens(lista) { IMAGENS = Array.isArray(lista) ? lista.slice(0, 6) : []; return IMAGENS; }
+function imagens() { return IMAGENS; }
+function instrucaoDasImagens(lista = IMAGENS) {
+    if (!lista.length) return '';
+    return `[REFERÊNCIA VISUAL] A pessoa mandou ${lista.length} imagem(ns): ${lista.map((f) => require('path').basename(f)).join(', ')}. `
+        + 'Elas SÃO a referência do pedido, mesmo em "só motion". Se o pedido é vídeo, o Estúdio já guarda cada uma no projeto e tira as '
+        + 'cores dela (com site, as cores do site mandam). Escreva o roteiro seguindo o que a referência mostra e diga no fim, '
+        + 'em uma linha, o que dela o vídeo usou.';
+}
+
+module.exports = { definir, atual, limpar, semImagem, termos, entender, inferir, instrucao, dominios, filtrar,
+    imagensNoTexto, guardarImagens, imagens, instrucaoDasImagens };

package/lib/pre-leitura.js

@@ -32,7 +32,8 @@
 const fs = require('fs');
 const path = require('path');
 
-const ORCAMENTO_SERVIDOR = 6 * 1024;
+// 2,5 KB no servidor (13/10): 6 KB de arquivo pré-lido não cabiam no orçamento do plano grátis e empurravam a conversa para fora.
+const ORCAMENTO_SERVIDOR = 2.5 * 1024;
 const ORCAMENTO_LOCAL = 40 * 1024;
 const MAIOR_ARQUIVO = 20 * 1024;
 

package/lib/tools.js

@@ -630,8 +630,15 @@ async function despachar(name, args, ctx) {
                 return editFile(args, projectDir);
             case 'read_file':
                 return readFile(args, projectDir);
-            case 'list_dir':
-                return { ok: true, tree: treeDir(resolverParaLer(args.path, projectDir), args.depth || 2) };
+            case 'list_dir': {
+                /* No máximo 60 linhas (13/10: "continua listando coisas desnecessárias").
+                   Pasta grande listada inteira enche a conversa e não diz onde está o que importa. */
+                const arvore = String(treeDir(resolverParaLer(args.path, projectDir), args.depth || 2));
+                const ls = arvore.split('\n');
+                if (ls.length <= 60) return { ok: true, tree: arvore };
+                return { ok: true, tree: ls.slice(0, 60).join('\n'), cortado: ls.length - 60,
+                    dica: 'Lista grande, cortei. Não liste de novo: use glob com o padrão do que procura (ex.: "src/**/*.css") ou grep pelo nome.' };
+            }
             /* `pasta` (opcional): procurar numa pasta que o usuário citou, sem
                trocar a de trabalho. Os caminhos voltam relativos a ELA, e a
                resposta diz qual é. */

package/lib/travado.js

@@ -15,6 +15,10 @@
  *      vezes sem escrita no meio?                              → travado
  *   3. VOLTAS_SEM_NOVIDADE voltas seguidas sem escrever nada e sem nenhuma
  *      chamada que ainda não tinha sido feita?                 → travado
+ *   4. LIMITE_OLHAR leituras, listagens e buscas DIFERENTES seguidas, sem
+ *      nenhuma ação no meio (escrever, rodar, usar o Estúdio)? → travado
+ *      (13/10: "continua lendo e listando coisas desnecessárias". As regras
+ *      1 a 3 só pegam repetição: ler 20 arquivos diferentes nunca travava.)
  * Na primeira vez, um empurrão curto (o que está repetindo, o que fazer). Se
  * travar de novo depois do empurrão, PARA e diz por quê.
  *
@@ -28,10 +32,14 @@ const path = require('path');
 const LIMITE_RELEITURA = 3;
 const LIMITE_MESMA_CHAMADA = 4;
 const VOLTAS_SEM_NOVIDADE = 6;
+const LIMITE_OLHAR = 8;
+const OLHAR = new Set(['read_file', 'list_dir', 'glob', 'grep']);
+// O shell que só olha: listar, achar, procurar, mostrar arquivo.
+const RE_SHELL_OLHA = /^(?:cd\s+\S+\s*&&\s*)?(?:ls|find|grep|rg|cat|head|tail|sed\s+-n|tree|wc|nl|less|more|stat|file|du)\b/;
 const ESCRITAS = new Set(['write_file', 'edit_file', 'multi_edit']);
 
 function novo() {
-    return { leituras: new Map(), chamadas: new Map(), vistas: new Set(), novidade: false, voltasSemNovidade: 0, avisos: 0 };
+    return { leituras: new Map(), chamadas: new Map(), vistas: new Set(), novidade: false, voltasSemNovidade: 0, avisos: 0, olhou: [], limiteOlhar: LIMITE_OLHAR };
 }
 
 /* A faixa que a leitura cobre. Sem offset nem limit, o read_file devolve o
@@ -89,6 +97,19 @@ function observar(estado, nome, args, pasta) {
         estado.novidade = true;
     }
     if (!estado.vistas.has(chave)) { estado.vistas.add(chave); estado.novidade = true; }
+    // Regra 4: o que só olha soma; qualquer ação zera.
+    const soOlha = OLHAR.has(nome) || (nome === 'run_shell' && RE_SHELL_OLHA.test(String(a.command || '').trim()));
+    if (!soOlha) { estado.olhou = []; estado.limiteOlhar = LIMITE_OLHAR; }
+    else {
+        const alvo = a.path || a.pattern || a.query || a.command || '.';
+        const curto = pasta && a.path ? path.relative(pasta, caminhoDe(a.path, pasta)) || '.' : String(alvo).slice(0, 40);
+        estado.olhou.push(`${nome === 'run_shell' ? '$ ' : ''}${curto}`);
+        if (estado.olhou.length >= estado.limiteOlhar) {
+            // A segunda vez vem 4 olhadas depois: o empurrão dá espaço para o último passo, não para mais um passeio.
+            estado.limiteOlhar = estado.olhou.length + 4;
+            return `olhou ${estado.olhou.length} coisas seguidas sem fazer nada (${estado.olhou.slice(-6).join(', ')})`;
+        }
+    }
     const leitura = nome === 'read_file' ? a : nome === 'run_shell' ? leituraDoShell(a.command) : null;
     if (leitura && leitura.path) {
         const caminho = caminhoDe(leitura.path, pasta);
@@ -138,4 +159,4 @@ function decidir(estado, motivo) {
     };
 }
 
-module.exports = { LIMITE_RELEITURA, LIMITE_MESMA_CHAMADA, VOLTAS_SEM_NOVIDADE, LEITURA_PADRAO, novo, faixa, leituraDoShell, observar, fimDaVolta, decidir };
+module.exports = { LIMITE_RELEITURA, LIMITE_MESMA_CHAMADA, VOLTAS_SEM_NOVIDADE, LIMITE_OLHAR, LEITURA_PADRAO, novo, faixa, leituraDoShell, observar, fimDaVolta, decidir };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "10.8.0",
+  "version": "10.9.0",
   "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": {