primocode 10.0.0 → 10.1.0

package/lib/claude-engine.js

@@ -575,6 +575,40 @@ function promptDoProtocolo(payload) {
         + '\n\nResponda com exatamente UM bloco marcado.';
 }
 
+/* O `claude -p` ASSÍNCRONO. Era execFileSync: enquanto o Claude pensava (um
+   minuto, dois), o PrimoCode inteiro parava — sem spinner, sem recado, sem
+   Esc Esc. E o teto de 180 s estourava justo quando ele escrevia um arquivo
+   grande, e o erro saía cru na tela ("Command failed: claude -p …"). Agora
+   roda em paralelo, com 10 min de teto, uma segunda tentativa, e o erro
+   diz o que o Claude disse. */
+function rodarClaude(args, input, { timeout = 600000, tentativas = 2 } = {}) {
+    const { spawn } = require('child_process');
+    const umaVez = () => new Promise((resolve, reject) => {
+        const p = spawn('claude', args, { env: process.env, stdio: ['pipe', 'pipe', 'pipe'], ...(SEM_APARECER.windowsHide ? { windowsHide: true } : {}) });
+        let out = '', err = '';
+        const relogio = setTimeout(() => { try { p.kill(); } catch {} reject(new Error(`o Claude Code não respondeu em ${Math.round(timeout / 60000)} min`)); }, timeout);
+        p.stdout.on('data', (d) => { out += d; });
+        p.stderr.on('data', (d) => { err += d; });
+        p.on('error', (e) => { clearTimeout(relogio); reject(e); });
+        p.on('close', (code) => {
+            clearTimeout(relogio);
+            if (code === 0) return resolve(out);
+            // O JSON às vezes vem com is_error e o motivo, mesmo com código != 0.
+            let motivo = '';
+            try { const j = JSON.parse(out); motivo = j.result || j.error || ''; } catch { /* sem json */ }
+            reject(new Error(`o Claude Code saiu com ${code}: ${String(motivo || err || out).replace(/\s+/g, ' ').trim().slice(0, 300)}`));
+        });
+        p.stdin.end(input);
+    });
+    return (async () => {
+        let ultimo;
+        for (let i = 0; i < tentativas; i++) {
+            try { return await umaVez(); } catch (e) { ultimo = e; }
+        }
+        throw ultimo;
+    })();
+}
+
 async function requestActViaHeadless(payload, onEvent) {
     const corpoBootstrap = corpoDoProtocolo();
     const prompt = promptDoProtocolo(payload);
@@ -585,27 +619,14 @@ async function requestActViaHeadless(payload, onEvent) {
     // O prompt vai por STDIN, nunca por argumento: argumento tem limite de
     // tamanho (a conversa cresce) e qualquer conteúdo começando com traço
     // seria lido como opção. stdin não tem nenhum dos dois problemas.
-    const saida = execFileSync('claude', [
-        '-p',
-        '--output-format', 'json',
-        '--dangerously-skip-permissions',
-        ...argsDoMotor(),
-    ], { encoding: 'utf-8', timeout: 180000, input: prompt, maxBuffer: 32 * 1024 * 1024,
-        env: process.env, ...SEM_APARECER });
+    const saida = await rodarClaude(['-p', '--output-format', 'json', '--dangerously-skip-permissions', ...argsDoMotor()], prompt);
     const r = JSON.parse(saida);
     // A correção é uma segunda ida ao motor, com o mesmo protocolo e o
     // diagnóstico do que saiu errado. Barata: o prompt é curto, e evita que
     // um erro de sintaxe do motor vire erro na cara do usuário.
-    const pedirCorrecao = (aviso) => {
-        const s = execFileSync('claude', [
-            '-p', '--output-format', 'json', '--dangerously-skip-permissions',
-            ...argsDoMotor(),
-        ], {
-            encoding: 'utf-8', timeout: 120000, maxBuffer: 32 * 1024 * 1024,
-            env: process.env,
-            input: promptDeCorrecao(aviso),
-            ...SEM_APARECER,
-        });
+    const pedirCorrecao = async (aviso) => {
+        const s = await rodarClaude(['-p', '--output-format', 'json', '--dangerously-skip-permissions', ...argsDoMotor()],
+            promptDeCorrecao(aviso), { timeout: 300000, tentativas: 1 });
         return JSON.parse(s).result || '';
     };
     await emitirDecisao(r.result || '', onEvent, pedirCorrecao, 0, nomesDasTools(payload));

package/lib/codex-engine.js

@@ -131,22 +131,40 @@ function recusouOModelo(texto) {
  * `--model` e avisa — cair para o padrão da conta é melhor que a tarefa
  * morrer por causa de um nome que mudou de catálogo.
  */
-function chamarCodex(prompt, { executor, avisar = () => {} } = {}) {
+/* O Codex ASSÍNCRONO, pelo mesmo motivo do claude -p (lib/claude-engine.js):
+   o execFileSync congelava o PrimoCode inteiro — spinner, recado, Esc Esc —
+   enquanto o Codex pensava. O erro mantém stdout/stderr para o diagnóstico. */
+function rodarAssincrono(args, entrada) {
+    const { spawn } = require('child_process');
+    return new Promise((resolve, reject) => {
+        const p = spawn(CODEX, args, { env: process.env, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
+        let out = '', err = '';
+        const relogio = setTimeout(() => { try { p.kill(); } catch {} const e = new Error(`o Codex não respondeu em ${Math.round(TEMPO / 60000)} min`); e.stderr = err; e.stdout = out; reject(e); }, TEMPO);
+        p.stdout.on('data', (d) => { out += d; if (out.length > BUFFER) { try { p.kill(); } catch {} } });
+        p.stderr.on('data', (d) => { err += d; });
+        p.on('error', (e) => { clearTimeout(relogio); reject(e); });
+        p.on('close', (code) => {
+            clearTimeout(relogio);
+            if (code === 0) return resolve(out);
+            const e = new Error(`Command failed: codex (saiu com ${code})`); e.stderr = err; e.stdout = out; reject(e);
+        });
+        p.stdin.end(entrada);
+    });
+}
+
+async function chamarCodex(prompt, { executor, avisar = () => {} } = {}) {
     // A chave própria da pessoa, quando ela configurou uma. Sem configuração
     // o ambiente vai INTACTO — passar a variável vazia apagaria a chave que
     // ela já tem exportada no shell, e o Codex pararia de funcionar por ter
     // sido "configurado".
-    const rodar = executor || ((args, entrada) => execFileSync(CODEX, args, {
-        encoding: 'utf-8', timeout: TEMPO, input: entrada, maxBuffer: BUFFER,
-        env: process.env, ...SEM_APARECER,
-    }));
+    const rodar = executor || rodarAssincrono;
     try {
-        return rodar(argsDoExec(), prompt);
+        return await rodar(argsDoExec(), prompt);
     } catch (e) {
         const detalhe = `${e.message || ''}\n${(e.stderr || '')}\n${(e.stdout || '')}`;
         if (MODELO_CODEX && recusouOModelo(detalhe)) {
             avisar(`o Codex não aceitou o modelo ${MODELO_CODEX} — indo com o padrão da sua conta`);
-            return rodar(argsDoExec({ comModelo: false }), prompt);
+            return await rodar(argsDoExec({ comModelo: false }), prompt);
         }
         throw new Error(primeiraLinhaUtil(detalhe) || e.message);
     }
@@ -185,12 +203,12 @@ async function requestAct(server, payload, onEvent) {
             return;
         }
         const prompt = claude.promptDoProtocolo(payload);
-        const saida = chamarCodex(prompt, { avisar: (m) => onEvent({ aviso: m }) });
+        const saida = await chamarCodex(prompt, { avisar: (m) => onEvent({ aviso: m }) });
 
         // A correção é uma segunda ida ao motor, com o mesmo protocolo e o
         // diagnóstico do que saiu errado. Barata, e evita que um erro de forma
         // do motor vire erro na cara de quem pediu a tarefa.
-        const pedirCorrecao = (aviso) => chamarCodex(claude.promptDeCorrecao(aviso));
+        const pedirCorrecao = (aviso) => chamarCodex(claude.promptDeCorrecao(aviso));   // devolve promessa: quem chama dá await
 
         await claude.emitirDecisao(saida, onEvent, pedirCorrecao, 0,
             claude.nomesDasTools(payload));

package/lib/config.js

@@ -273,6 +273,14 @@ function podarMemoriaGeral() {
     } catch {}
 }
 
+/* O servidor saiu do Render pro Railway da Paris Group (05/10). Quem gravou o
+   endereço antigo no config.json vai pro novo: o Render vai ser desligado. */
+const SERVIDOR = 'https://primocode-server-production.up.railway.app';
+const SERVIDOR_ANTIGO = /^https?:\/\/primocode-server\.onrender\.com\/?$/;
+function servidor(escolhido) {
+    return !escolhido || SERVIDOR_ANTIGO.test(String(escolhido).trim()) ? SERVIDOR : escolhido;
+}
+
 function loadConfig() {
     ensureStructure();
     let file = {};
@@ -280,7 +288,7 @@ function loadConfig() {
         if (fs.existsSync(CONFIG_FILE)) file = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
     } catch { file = {}; }
     return {
-        server: process.env.PRIMOCODE_SERVER || file.server || 'https://primocode-server.onrender.com',
+        server: servidor(process.env.PRIMOCODE_SERVER || file.server),
         model: process.env.PRIMOCODE_MODEL || file.model || 'main',
         // Esforço, estilo Claude Code (/effort). É o que o usuário escolhe; o
         // modelo é derivado dele. Guardado para durar entre sessões.
@@ -363,7 +371,7 @@ function esquecerProjeto() {
 module.exports = {
     tokensDoAssunto, GENERICAS,
     lembrarProjeto, projetoLembrado, esquecerProjeto, PROJETO_ATIVO_FILE,
-    loadConfig, saveConfig, appendHistory,
+    loadConfig, saveConfig, appendHistory, servidor, SERVIDOR,
     CONFIG_DIR, CONFIG_FILE, HISTORY_FILE, ROOT_DIR, GENERAL_MEMORY,
     ensureStructure, slugify, stripAccents,
     createProjectDir, getProjectDir, listProjects, findSimilarProject,

package/lib/entrada.js

@@ -43,6 +43,10 @@ const { c, visibleWidth, truncate } = require('./ui.js');
 
 // ── O desenho ────────────────────────────────────────────────────────────
 
+/** A etiqueta de colagem em destaque (fininha, na cor da marca), sem mudar a largura. */
+const RE_ETIQUETA = /\[Colado #\d+ · [^\]]+\]/g;
+function pintarEtiquetas(s) { return String(s).replace(RE_ETIQUETA, (m) => c.brand(m) + '\x1b[38;5;254m'); }
+
 const BORDA = { ne: '╭', no: '╮', se: '╰', so: '╯', h: '─', v: '│' };
 
 /** Preenche até `w` colunas VISÍVEIS (códigos de cor não ocupam coluna). */
@@ -128,6 +132,12 @@ function montar(e) {
 
     const out = [];
     const regua = (bash ? c.warn : c.dim)(BORDA.h.repeat(largura));
+    /* O SPINNER MORA AQUI, na linha logo acima da caixa. Ele escrevia direto
+       no terminal com "\r" a cada 80 ms, sem quebra de linha — e a caixa,
+       que espera a linha fechar para se redesenhar, ficava apagada enquanto
+       ele girasse: o que se digitava não aparecia, e a barra de status
+       sumia ("não consigo digitar enquanto ele trabalha"). */
+    if (e.spinner) out.push(' ' + truncate(e.spinner, largura - 2));
     out.push(regua);
 
     const vazio = !String(e.texto).length;
@@ -137,7 +147,7 @@ function montar(e) {
             : c.dim('┆ ');
         // O "!" some do texto desenhado: quem vê "$ " já sabe que é shell, e
         // mostrar os dois é mostrar a mesma informação duas vezes.
-        let conteudo = c.white(i === 0 && bash ? l.texto.replace(/^\s*!/, '') : l.texto);
+        let conteudo = pintarEtiquetas(c.white(i === 0 && bash ? l.texto.replace(/^\s*!/, '') : l.texto));
         // O fantasma só existe na última linha e só com o cursor no fim dela:
         // desenhado no meio do texto, ele empurraria o que vem depois.
         if (i === linhas.length - 1 && e.fantasma && cursor === String(e.texto).length) {
@@ -326,6 +336,15 @@ class Entrada extends EventEmitter {
 
     prompt() { if (!this.suspenso && this.tty && !this.fechado) this._desenhar(); }
 
+    /** O spinner (lib/ui.js) desenha por aqui quando há caixa: uma linha
+     *  acima dela, redesenhada junto — nunca um "\r" solto por cima. */
+    mostrarSpinner(texto) {
+        const novo = texto || '';
+        if (novo === (this.spinnerTexto || '')) return;
+        this.spinnerTexto = novo;
+        if (this.desenhado && !this._meiaLinha) this._redesenhar();
+    }
+
     /** Escreve texto ACIMA da caixa — é por onde todo o resto do programa fala. */
     escreverAcima(texto) {
         if (!this.desenhado) { this.escreverCru(texto); return; }
@@ -342,7 +361,40 @@ class Entrada extends EventEmitter {
         this._mudou();
     }
 
-    limpar() { this.line = ''; this.cursor = 0; this.menu = null; this._mudou(); }
+    limpar() { this.line = ''; this.cursor = 0; this.menu = null; this.colados = new Map(); this._mudou(); }
+
+    /* COLAR VIRA ETIQUETA, como no Claude Code: texto grande colado (várias
+       linhas, ou mais de 300 caracteres) entra na caixa como
+       "[Colado #1 · 42 linhas]" — a caixa não vira um paredão, dá para
+       escrever o pedido em volta, e no Enter a etiqueta volta a ser o texto
+       inteiro. O que é curto entra como texto mesmo. */
+    colar(texto) {
+        const t = String(texto || '');
+        if (!t) return;
+        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 etiqueta = `[Colado #${n} · ${linhas > 1 ? `${linhas} linhas` : `${t.length} caracteres`}]`;
+        this.colados.set(etiqueta, t);
+        this.write(etiqueta);
+    }
+
+    /** A linha com cada etiqueta trocada pelo texto que ela guarda. */
+    expandir(linha) {
+        if (!this.colados || !this.colados.size) return linha;
+        let out = linha;
+        for (const [et, t] of this.colados) out = out.split(et).join(t);
+        return out;
+    }
+
+    /** A etiqueta que termina exatamente no cursor (o backspace apaga ela inteira). */
+    _etiquetaAntes() {
+        if (!this.colados) return null;
+        const antes = this.line.slice(0, this.cursor);
+        for (const et of this.colados.keys()) if (antes.endsWith(et)) return et;
+        return null;
+    }
 
     /**
      * A PRÓXIMA linha é senha: a caixa desenha `•` no lugar das letras, não
@@ -363,6 +415,7 @@ class Entrada extends EventEmitter {
             status: this.op.status ? this.op.status() : [],
             menu: this.menu,
             ocupado: this.ocupado,
+            spinner: this.spinnerTexto || '',
         });
     }
 
@@ -436,11 +489,11 @@ class Entrada extends EventEmitter {
         const seq = (key && key.sequence) || ch || '';
 
         // Colagem entre marcas: tudo que vier até a marca de fim é texto.
-        if (seq.includes('\x1b[200~')) { this.colando = true; }
+        if (seq.includes('\x1b[200~')) { this.colando = true; this.bufColagem = ''; }
         if (this.colando) {
             const limpo = seq.replace('\x1b[200~', '').replace('\x1b[201~', '');
-            if (limpo) this.write(limpo.replace(/\r/g, '\n'));
-            if (seq.includes('\x1b[201~')) this.colando = false;
+            if (limpo) this.bufColagem += limpo.replace(/\r\n?/g, '\n');
+            if (seq.includes('\x1b[201~')) { this.colando = false; this.colar(this.bufColagem); this.bufColagem = ''; }
             return;
         }
 
@@ -478,7 +531,15 @@ class Entrada extends EventEmitter {
                 return;
             }
 
-            case 'backspace':
+            case 'backspace': {
+                const et = this._etiquetaAntes();
+                if (et) {
+                    this.line = this.line.slice(0, this.cursor - et.length) + this.line.slice(this.cursor);
+                    this.cursor -= et.length;
+                    this.colados.delete(et);
+                    return this._mudou();
+                }
+            }
                 if (this.cursor > 0) {
                     this.line = this.line.slice(0, this.cursor - 1) + this.line.slice(this.cursor);
                     this.cursor--;
@@ -585,7 +646,9 @@ class Entrada extends EventEmitter {
 
     _enviar() {
         if (this.menu) return this._escolherDoMenu();
-        const texto = this.line;
+        const visto = this.line;
+        const texto = this.expandir(visto);
+        this.colados = new Map();
         const oculto = this.oculto;
         this.oculto = false;
         this.line = '';
@@ -599,7 +662,8 @@ class Entrada extends EventEmitter {
         this._apagar();
         if (texto.trim() && !oculto) {
             const marca = c.brand('❯ ');
-            this.escreverCru(texto.split('\n').map((l, i) => (i ? '  ' : marca) + c.white(l)).join('\n') + '\n');
+            // Na tela fica a etiqueta (o que se viu ao mandar); quem vai ao agente é o texto inteiro.
+            this.escreverCru(visto.split('\n').map((l, i) => (i ? '  ' : marca) + pintarEtiquetas(c.white(l))).join('\n') + '\n');
             if (this.historico[this.historico.length - 1] !== texto) this.historico.push(texto);
         }
         this._desenhar();
@@ -609,4 +673,4 @@ class Entrada extends EventEmitter {
 
 function criar(op) { return new Entrada(op).iniciar(); }
 
-module.exports = { criar, Entrada, montar, quebrar, encher };
+module.exports = { criar, Entrada, montar, quebrar, encher, pintarEtiquetas };

package/lib/estudio/assets.js

@@ -329,12 +329,18 @@ async function procurarMusica(termo, { quantas = 8, duracaoMin = 45 } = {}) {
     return procurarSom(termo, { quantas, duracaoMin });
 }
 
-async function procurarSom(termo, { quantas = 8, duracaoMin = 0, duracaoMax = 0 } = {}) {
+/* `livre`: só domínio público (CC0 e PDM). O efeito sonoro entra no vídeo sem
+   crédito, então não pode ser CC-BY, que o "commercial" deixa passar. */
+function urlSom(termo, { quantas = 8, duracaoMin = 0, livre = false } = {}) {
+    let url = `https://api.openverse.org/v1/audio/?q=${encodeURIComponent(termo)}`
+        + `&page_size=${quantas}` + (livre ? '&license=cc0,pdm' : '&license_type=commercial');
+    if (duracaoMin && duracaoMin < 30) url += '&length=short';
+    return url;
+}
+
+async function procurarSom(termo, { quantas = 8, duracaoMin = 0, duracaoMax = 0, livre = false } = {}) {
     try {
-        let url = `https://api.openverse.org/v1/audio/?q=${encodeURIComponent(termo)}`
-            + `&page_size=${quantas}&license_type=commercial`;
-        if (duracaoMin && duracaoMin < 30) url += '&length=short';
-        const r = await pegar(url, { json: true });
+        const r = await pegar(urlSom(termo, { quantas, duracaoMin, livre }), { json: true });
         const sons = (r.results || [])
             .filter((x) => !duracaoMax || !x.duration || x.duration / 1000 <= duracaoMax)
             .filter((x) => !duracaoMin || !x.duration || x.duration / 1000 >= duracaoMin)
@@ -412,6 +418,6 @@ module.exports = {
     extensaoPorConteudo,
     pegar, guardar,
     icone, procurarIcones, iconesDoPlano, COLECOES, procurarVideos, procurarMusica,
-    procurarImagens, procurarSom, baixar,
+    procurarImagens, procurarSom, urlSom, baixar,
     FONTES, conferirFonte,
 };

package/lib/estudio/biblioteca.js

@@ -0,0 +1,174 @@
+/**
+ * biblioteca.js — o cardápio de fonte e cor dos estilos de corte (híbrido,
+ * cinema, impacto), com memória do que os últimos vídeos usaram.
+ *
+ *   "por falta de variedade a gente tá fazendo os vídeos todos iguais" (Joel, 02/10)
+ *
+ * Sem fonte e cor da marca, o cinema caía sempre no Inter e no gradiente
+ * azul e roxo (#2E81ED → #9567DB), e o híbrido é o padrão: todo vídeo saía
+ * com a mesma cara. Aqui a escolha segue esta ordem:
+ *   1. a marca (fontes e cores dela) — nunca é trocada;
+ *   2. o que a IA escolheu do cardápio (roteiro.visual);
+ *   3. um sorteio que pula o que os últimos vídeos já usaram.
+ *
+ * As 128 famílias foram conferidas no Google Fonts em 02/10, com o peso mais
+ * grosso de cada uma (o título do cinema é caixa alta em 800).
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+// ── as fontes: "Nome:peso máximo", por tipo ──────────────────────────────
+const TIPOS = {
+    condensada: 'Anton:400, Antonio:700, Archivo Narrow:700, Barlow Condensed:900, Bebas Neue:400, Big Shoulders Display:900, '
+        + 'Encode Sans Condensed:900, Fjalla One:400, Khand:700, League Gothic:400, Mohave:700, Oswald:700, Pathway Gothic One:400, '
+        + 'Saira Condensed:900, Six Caps:400, Smooch Sans:900, Sofia Sans Condensed:900, Staatliches:400, Teko:700',
+    display: 'Alfa Slab One:400, Anybody:900, Archivo Black:400, Archivo:900, Black Ops One:400, Bricolage Grotesque:800, '
+        + 'Chakra Petch:700, Chivo:900, Darker Grotesque:900, Epilogue:900, Exo 2:900, Familjen Grotesk:700, Funnel Display:800, '
+        + 'Gabarito:900, Lexend:900, Mona Sans:900, Passion One:900, Red Hat Display:900, Righteous:400, Rubik:900, Russo One:400, '
+        + 'Schibsted Grotesk:900, Shrikhand:400, Urbanist:900, Wix Madefor Display:800',
+    larga: 'Audiowide:400, Bagel Fat One:400, Bowlby One:400, Bungee Shade:400, Bungee:400, Dela Gothic One:400, Krona One:400, '
+        + 'Lexend Zetta:900, Michroma:400, Monoton:400, Orbitron:900, Press Start 2P:400, Rubik Mono One:400, Silkscreen:700, Syne:800, Ultra:400',
+    texto: 'Afacad:700, Albert Sans:900, Barlow:900, Be Vietnam Pro:900, Figtree:900, Funnel Sans:800, Golos Text:900, '
+        + 'Hanken Grotesk:900, Host Grotesk:800, Instrument Sans:700, Karla:800, Onest:900, Public Sans:900, Reddit Sans:900, '
+        + 'Rethink Sans:800, Sofia Sans:900, Work Sans:900',
+    serifa: 'Abril Fatface:400, Arvo:700, Bitter:900, Bodoni Moda:900, Caprasimo:400, Cormorant Garamond:700, Crimson Pro:900, '
+        + 'DM Serif Display:400, EB Garamond:800, Fraunces:900, Gloock:400, Instrument Serif:400, Libre Baskerville:700, '
+        + 'Libre Bodoni:700, Libre Caslon Display:400, Literata:900, Lora:700, Merriweather:900, Newsreader:800, Playfair Display:900, '
+        + 'Prata:400, Roboto Slab:900, Rozha One:400, Source Serif 4:900, Spectral:800, Yeseva One:400, Young Serif:400, Zilla Slab:700',
+    manuscrita: 'Caveat:700, Gloria Hallelujah:400, Kalam:700, Lobster:400, Marck Script:400, Nanum Pen Script:400, Pacifico:400, '
+        + 'Permanent Marker:400, Rock Salt:400, Satisfy:400, Shadows Into Light:400, Yellowtail:400',
+    mono: 'Azeret Mono:900, DM Mono:400, Fragment Mono:400, Geist Mono:900, IBM Plex Mono:700, JetBrains Mono:800, '
+        + 'Major Mono Display:400, Martian Mono:800, Red Hat Mono:700, Space Mono:700, VT323:400',
+};
+const FONTES = Object.entries(TIPOS).flatMap(([tipo, lista]) => lista.split(', ').map((x) => {
+    const [nome, peso] = x.split(':');
+    return { nome, tipo, peso: Number(peso) };
+}));
+
+/* A largura média do caractere, em "em", por tipo — o caber() de
+   composicao.js usa para escolher o tamanho. A larga é a que estoura a borda. */
+const LARGURA = { condensada: 0.46, display: 0.6, larga: 0.74, texto: 0.58, serifa: 0.55, manuscrita: 0.52, mono: 0.62 };
+const larguraDe = (fonte) => { const f = acharFonte(fonte); return f ? LARGURA[f.tipo] : null; };
+
+/* O título é caixa alta grossa: fonte de texto fina demais não serve. O
+   texto (etiquetas, nomes) é qualquer uma que se lê pequena. */
+const TITULO = FONTES.filter((f) => ['condensada', 'display', 'larga'].includes(f.tipo) || (f.tipo === 'serifa' && f.peso >= 800)
+    || (f.tipo === 'texto' && f.peso >= 900));
+const TEXTO = FONTES.filter((f) => ['texto', 'mono'].includes(f.tipo) || (f.tipo === 'serifa' && f.peso >= 700) || (f.tipo === 'display' && f.peso >= 800));
+
+// ── as paletas: fundo escuro e as duas cores do gradiente ────────────────
+/* O cinema é escuro (o texto é branco), então todo fundo é escuro. Nada do
+   violeta de SaaS nem do neon: é o que denuncia vídeo feito por IA. */
+const BASES = [
+    ['brasa', '#120B08', '#FF5A1F', '#FFB23F'], ['ferrugem', '#15100D', '#C8553D', '#F2A65A'], ['mata', '#0B1410', '#2BB673', '#D8F05A'],
+    ['oceano', '#071219', '#1E88E5', '#4FD1C5'], ['tijolo', '#170C0B', '#E2583E', '#F6D6AD'], ['limao', '#0E100A', '#C6F432', '#F4F1E8'],
+    ['cobre', '#120E0C', '#D9822B', '#F3C98B'], ['sangue', '#100607', '#E5383B', '#FF9F1C'], ['musgo', '#0F120C', '#8DB255', '#E9C46A'],
+    ['gelo', '#0A0F14', '#8EC5FF', '#F1F7FF'], ['sol-de-inverno', '#0D0D10', '#FFC93C', '#FF6B35'], ['cereja', '#14080B', '#FF4D6D', '#FFC2D1'],
+    ['jade', '#06120F', '#00A878', '#9BE564'], ['areia', '#13110D', '#E9C46A', '#F4A261'], ['safira', '#070B16', '#2F6BFF', '#7FB2FF'],
+    ['tangerina', '#110A06', '#FF7A00', '#FFD166'], ['pistache', '#0C110D', '#93C572', '#F0EAD6'], ['vinho', '#13070C', '#D1495B', '#FCB9B2'],
+    ['petroleo', '#061214', '#0F9D9A', '#F2C14E'], ['ouro-velho', '#0F0D08', '#C9A227', '#F5E6B3'], ['coral', '#120A0A', '#FF6F59', '#FFD6A5'],
+    ['asfalto', '#0E0F10', '#FF3B30', '#FFFFFF'], ['menta', '#08110E', '#3DDC97', '#E8FFF4'], ['lava', '#0F0705', '#FF3D00', '#FFB300'],
+    ['ceu', '#08101A', '#56C3E8', '#F7F7F7'], ['terracota', '#140D0A', '#CB6843', '#EBD4B4'], ['abacate', '#0D100A', '#A3B18A', '#DAD7CD'],
+    ['neve-e-fogo', '#0B0B0E', '#FFFFFF', '#FF4F00'], ['framboesa', '#12070D', '#E0245E', '#FFB3C6'], ['cacau', '#120D0A', '#A47148', '#F2D0A9'],
+    ['esmeralda', '#04110B', '#10B981', '#FDE68A'], ['aco', '#0C0E11', '#9DB4C0', '#E0E1DD'], ['acafrao', '#110D05', '#F4B400', '#FF6D00'],
+    ['lagoa', '#051214', '#48CAE4', '#CAF0F8'], ['papoula', '#110808', '#F94144', '#F9C74F'], ['oliva', '#0F0F09', '#B5A642', '#F1E9C9'],
+    ['ardosia', '#0D1014', '#FF8C42', '#E8EEF2'], ['tinta-e-rosa', '#0E0B0C', '#FF8FAB', '#FFE5EC'], ['hortela-e-ouro', '#08120F', '#52B788', '#F6C453'],
+    ['noite-azul', '#060A12', '#3A86FF', '#FFBE0B'], ['cinzas', '#101010', '#D9D9D9', '#FF5F1F'], ['pessego', '#120C0A', '#FFAD87', '#FFE3D3'],
+    ['floresta', '#07100A', '#40916C', '#B7E4C7'], ['rubi', '#10060A', '#EF233C', '#EDF2F4'], ['mostarda', '#100E06', '#E1AD01', '#F6F1D1'],
+    ['turquesa', '#061111', '#2EC4B6', '#FFBF69'], ['caramelo', '#120C07', '#DDA15E', '#FEFAE0'], ['grafite-limao', '#0F1011', '#D4FF3A', '#F2F2F2'],
+    ['alvorada', '#0D0A0C', '#FF9E00', '#FF4D6D'], ['tempestade', '#0A0D10', '#6C9BD2', '#F2E8CF'],
+];
+
+function rgb(hex) { const n = parseInt(String(hex).slice(1), 16); return [n >> 16 & 255, n >> 8 & 255, n & 255]; }
+const hex = (c) => '#' + c.map((v) => Math.max(0, Math.min(255, Math.round(v))).toString(16).padStart(2, '0')).join('').toUpperCase();
+const misturar = (a, b, k) => hex(rgb(a).map((v, i) => v + (rgb(b)[i] - v) * k));
+const luz = (c) => { const [r, g, b] = rgb(c); return (0.299 * r + 0.587 * g + 0.114 * b) / 255; };
+
+/* Cada base vira quatro: como veio, o gradiente invertido, o fundo tingido
+   da cor principal e a monocromática (a cor e ela mais clara). */
+const PALETAS = BASES.flatMap(([nome, fundo, a, b]) => [
+    { nome, base: nome, fundo, grad: [a, b] },
+    { nome: `${nome}-invertida`, base: nome, fundo, grad: [b, a] },
+    { nome: `${nome}-tingida`, base: nome, fundo: misturar(fundo, a, 0.1), grad: [a, b] },
+    { nome: `${nome}-mono`, base: nome, fundo, grad: [a, misturar(a, '#FFFFFF', 0.45)] },
+]);
+
+// ── a memória: o que os últimos vídeos já usaram ─────────────────────────
+const ARQ = path.join(os.homedir(), '.primocode', 'studio', 'biblioteca-usada.json');
+const LEMBRA = { titulo: 15, texto: 8, paleta: 20 };   // paleta conta pela base: "brasa-mono" depois de "brasa" é repetir
+
+function lerMemoria(arq = ARQ) {
+    try { const m = JSON.parse(fs.readFileSync(arq, 'utf8')); return { titulo: [], texto: [], paleta: [], ...m }; }
+    catch { return { titulo: [], texto: [], paleta: [] }; }
+}
+function gravarMemoria(m, arq = ARQ) {
+    try { fs.mkdirSync(path.dirname(arq), { recursive: true }); fs.writeFileSync(arq, JSON.stringify(m)); } catch { /* sem memória, só sorteio */ }
+}
+
+const norm = (s) => String(s || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase().trim();
+function acharFonte(nome) { const n = norm(nome); return FONTES.find((f) => norm(f.nome) === n) || null; }
+function acharPaleta(nome) { const n = norm(nome).replace(/\s+/g, '-'); return PALETAS.find((p) => p.nome === n) || null; }
+
+/* O sorteio que pula os recentes. Se a lista inteira já foi usada, vale
+   qualquer uma — nunca fica sem. */
+function sortear(lista, recentes, chave, sorte) {
+    const livres = lista.filter((x) => !recentes.includes(chave(x)));
+    const de = livres.length ? livres : lista;
+    return de[Math.floor(sorte() * de.length) % de.length];
+}
+
+/**
+ * Escolhe fonte e paleta para o roteiro e as põe em roteiro.marca, sem
+ * trocar nada que a marca já tem. Devolve o que escolheu e de onde veio.
+ * memoria: null não lê nem grava o disco (os testes); sorte: () => [0,1).
+ */
+function vestir(roteiro, { memoria = ARQ, sorte = Math.random } = {}) {
+    if (!roteiro || typeof roteiro !== 'object') return { mudou: false };
+    const marca = roteiro.marca || {};
+    const cores = marca.cores || {};
+    const visual = roteiro.visual || {};
+    const mem = memoria ? lerMemoria(memoria) : { titulo: [], texto: [], paleta: [] };
+    const escolha = { mudou: false };
+
+    if (!(marca.fontes && marca.fontes.titulo)) {
+        // A IA escolheu pelo nome: vale qualquer família do Google Fonts, mesmo fora do cardápio.
+        const titulo = visual.titulo ? String(visual.titulo) : sortear(TITULO, mem.titulo, (f) => f.nome, sorte).nome;
+        const textoLista = TEXTO.filter((f) => f.nome !== titulo);
+        const texto = visual.texto ? String(visual.texto) : sortear(textoLista, mem.texto, (f) => f.nome, sorte).nome;
+        marca.fontes = { ...(marca.fontes || {}), titulo, texto };
+        mem.titulo = [titulo, ...mem.titulo.filter((x) => x !== titulo)].slice(0, LEMBRA.titulo);
+        mem.texto = [texto, ...mem.texto.filter((x) => x !== texto)].slice(0, LEMBRA.texto);
+        Object.assign(escolha, { mudou: true, titulo, texto, fonteDaIA: !!visual.titulo });
+    }
+    // A cor da marca manda: com destaque ou gradiente declarado, a paleta não entra.
+    if (!(marca.gradiente && marca.gradiente.length >= 2) && !cores.destaque) {
+        const p = acharPaleta(visual.paleta) || sortear(PALETAS, mem.paleta, (x) => x.base, sorte);
+        marca.gradiente = [...p.grad];
+        marca.cores = { ...cores, fundo: cores.fundo || p.fundo, destaque: p.grad[1], apoio: p.grad[0] };
+        mem.paleta = [p.base, ...mem.paleta.filter((x) => x !== p.base)].slice(0, LEMBRA.paleta);
+        Object.assign(escolha, { mudou: true, paleta: p.nome, paletaDaIA: !!acharPaleta(visual.paleta) });
+    }
+    if (escolha.mudou) {
+        roteiro.marca = marca;
+        if (memoria) gravarMemoria(mem, memoria);
+    }
+    return escolha;
+}
+
+/** O cardápio para a IA: nomes por tipo, e as paletas pela base. */
+function cardapio() {
+    const porTipo = {};
+    for (const f of FONTES) (porTipo[f.tipo] = porTipo[f.tipo] || []).push(f.nome);
+    return {
+        fontes: porTipo,
+        paletas: BASES.map(([nome, fundo, a, b]) => `${nome} ${fundo} ${a} ${b}`),
+        variacoes: 'cada paleta também vem -invertida, -tingida e -mono (ex.: "brasa-mono")',
+        uso: 'roteiro.visual = {titulo, texto, paleta}. Sem visual, o PrimoCode sorteia e não repete os últimos vídeos.',
+    };
+}
+
+module.exports = { vestir, cardapio, larguraDe, acharFonte, acharPaleta, FONTES, PALETAS, BASES, TITULO, TEXTO, luz, ARQ };