primocode 10.15.2 → 10.16.0

package/lib/estudio/gosto.js

@@ -0,0 +1,264 @@
+/**
+ * gosto.js — aprender o gosto da pessoa pro motion.
+ *
+ * No PRIMEIRO estudio_motion, antes de renderizar, abre uma tela local com 20 motions tocando em loop num carrossel:
+ * a pessoa escolhe os que curtiu e, numa pergunta só, marca "mais disso" e "menos disso". Fica em ~/.primocode/gosto-motion.json.
+ *
+ * Regra do dono: o gosto é CONTEXTO E PESO, não trilho. O diretor (maquina-diretor.js) continua sorteando com
+ * variedade e histórico; aqui só saem multiplicadores (pesos). Nunca vira "estilo fixo".
+ *
+ *   ler() / salvar() / tem()   o arquivo
+ *   pesos(gosto)               multiplicadores pro diretor (tudo 1 = neutro)
+ *   resumo(gosto)              1 a 3 frases pro modelo ler
+ *   abrirTela()                servidor local 127.0.0.1 + token; resolve {ok, gosto} | {ok:false, motivo}
+ */
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const http = require('http');
+const crypto = require('crypto');
+
+// Só nomes do vocabulário do diretor (maquina-diretor.js: CAMERAS, TRANSICOES, TIPOGRAFIAS).
+const ESTILOS = [
+    { id: 'brincalhao', nome: 'Brincalhão', frase: 'Quica, gira, pula. Leve e cheio de vida.', ritmo: 'rapido', cameras: ['pulso', 'orbita'], trocas: ['giro', 'encolhe', 'abre'], tipografias: ['arredondada', 'manuscrita'], overshoot: 0.18 },
+    { id: 'premium', nome: 'Premium', frase: 'Lento, liso, caro. Desfoque saindo e nada de susto.', ritmo: 'lento', cameras: ['cinema', 'deriva'], trocas: ['desfoque', 'dissolve', 'cortina'], tipografias: ['serifa_fina', 'editorial'], overshoot: 0 },
+    { id: 'corporativo', nome: 'Direto', frase: 'Entra empurrando, corte seco, tudo alinhado.', ritmo: 'medio', cameras: ['trilho', 'push'], trocas: ['empurra', 'persiana', 'corte'], tipografias: ['geometrica', 'tecnica'], overshoot: 0.04 },
+    { id: 'energico', nome: 'Enérgico', frase: 'Chicote, punch de câmera, letra entrando rápido.', ritmo: 'rapido', cameras: ['chicote', 'pulso'], trocas: ['chicote', 'tremor', 'zoom', 'corte'], tipografias: ['pesada', 'poster'], overshoot: 0.25 },
+    { id: 'cinema3d', nome: 'Cinema 3D', frase: 'Profundidade: tudo orbita e vem do fundo.', ritmo: 'medio', cameras: ['orbita', 'cinema', 'push'], trocas: ['giro', 'zoom', 'empurra'], tipografias: ['poster', 'editorial'], overshoot: 0.1 },
+    { id: 'cinetico', nome: 'Letra que dança', frase: 'Cada letra entra sozinha, girando e trocando de peso.', ritmo: 'rapido', cameras: ['pulso', 'push'], trocas: ['corte', 'chicote', 'encolhe'], tipografias: ['poster', 'pesada', 'tecnica'], overshoot: 0.15 },
+    { id: 'cubo', nome: 'Cubo', frase: 'Um cubo 3D gira de face em face e dá cambalhota.', ritmo: 'medio', cameras: ['orbita', 'push'], trocas: ['giro', 'zoom'], tipografias: ['pesada', 'poster'], overshoot: 0.2 },
+    { id: 'glitch', nome: 'Glitch', frase: 'A palavra treme e se parte em fatias coloridas.', ritmo: 'rapido', cameras: ['chicote', 'pulso'], trocas: ['tremor', 'corte'], tipografias: ['tecnica', 'pesada'], overshoot: 0.05 },
+    { id: 'espiral', nome: 'Espiral', frase: 'Pontos giram até o centro e explodem na palavra.', ritmo: 'rapido', cameras: ['orbita', 'pulso'], trocas: ['zoom', 'encolhe'], tipografias: ['pesada', 'arredondada'], overshoot: 0.2 },
+    { id: 'slot', nome: 'Caça-níquel', frase: 'Cada letra roda como num rolo e trava uma por vez.', ritmo: 'rapido', cameras: ['pulso', 'trilho'], trocas: ['corte', 'persiana'], tipografias: ['pesada', 'poster'], overshoot: 0.1 },
+    { id: 'tunel', nome: 'Túnel', frase: 'Quadros saem do centro girando, a palavra pulsa.', ritmo: 'rapido', cameras: ['push', 'pulso'], trocas: ['zoom', 'giro'], tipografias: ['geometrica', 'poster'], overshoot: 0.1 },
+    { id: 'mosaico', nome: 'Mosaico', frase: 'Azulejos viram em onda e mostram a palavra.', ritmo: 'medio', cameras: ['push', 'deriva'], trocas: ['persiana', 'abre'], tipografias: ['geometrica', 'pesada'], overshoot: 0.15 },
+    { id: 'estilhaco', nome: 'Estilhaço', frase: 'Um impacto quebra a palavra e ela se junta de volta.', ritmo: 'rapido', cameras: ['chicote', 'pulso'], trocas: ['zoom', 'tremor'], tipografias: ['pesada', 'poster'], overshoot: 0.22 },
+    { id: 'contador', nome: 'Contador', frase: 'Os números rolam até 100% com a barra enchendo.', ritmo: 'medio', cameras: ['push', 'trilho'], trocas: ['empurra', 'corte'], tipografias: ['tecnica', 'geometrica'], overshoot: 0.06 },
+    { id: 'orbita', nome: 'Órbita', frase: 'Anéis inclinados giram em volta da palavra.', ritmo: 'medio', cameras: ['orbita', 'cinema'], trocas: ['giro', 'dissolve'], tipografias: ['geometrica'], overshoot: 0.08 },
+    { id: 'equalizador', nome: 'Equalizador', frase: 'Barras dançam e a palavra quica na batida.', ritmo: 'rapido', cameras: ['pulso', 'chicote'], trocas: ['corte', 'tremor'], tipografias: ['pesada', 'poster'], overshoot: 0.12 },
+    { id: 'cartas', nome: 'Cartas', frase: 'Um baralho cai, abre em leque e junta de novo.', ritmo: 'medio', cameras: ['cinema', 'deriva'], trocas: ['abre', 'giro'], tipografias: ['editorial', 'arredondada'], overshoot: 0.18 },
+    { id: 'gota', nome: 'Gota', frase: 'Uma gota cai, abre ondas e a palavra sobe delas.', ritmo: 'lento', cameras: ['deriva', 'cinema'], trocas: ['desfoque', 'dissolve'], tipografias: ['serifa_fina', 'editorial'], overshoot: 0.12 },
+    { id: 'split', nome: 'Corte ao meio', frase: 'As metades da palavra entram por lados opostos.', ritmo: 'rapido', cameras: ['trilho', 'chicote'], trocas: ['persiana', 'empurra'], tipografias: ['pesada', 'tecnica'], overshoot: 0.04 },
+    { id: 'traco', nome: 'Traço', frase: 'Uma linha se desenha e revela a palavra atrás.', ritmo: 'medio', cameras: ['trilho', 'deriva'], tipografias: ['manuscrita', 'editorial'], trocas: ['abre', 'cortina'], overshoot: 0.08 },
+];
+
+/** O que a pessoa pode ter gostado (passo 2). */
+const GOSTEI = [
+    { id: 'rapido', nome: 'a velocidade' },
+    { id: 'quique', nome: 'o quique (passa do ponto e volta)' },
+    { id: 'tres_d', nome: 'o 3D' },
+    { id: 'camera', nome: 'a câmera mexendo' },
+    { id: 'letra', nome: 'a letra' },
+    { id: 'cortes', nome: 'os cortes' },
+    { id: 'cores', nome: 'as cores' },
+    { id: 'calmo', nome: 'ser calmo e liso' },
+];
+
+/** O que a pessoa NÃO quer (passo 3). */
+const NAO_QUERO = [
+    { id: 'lento', nome: 'devagar demais', curto: 'devagar demais' },
+    { id: 'liso', nome: 'liso, sem graça', curto: 'liso' },
+    { id: 'exagero', nome: 'exagerado, sujo', curto: 'exagero' },
+    { id: 'flash', nome: 'flash na tela', curto: 'flash' },
+    { id: 'tremido', nome: 'tremido demais', curto: 'tremido' },
+    { id: 'letra_pequena', nome: 'letra pequena', curto: 'letra pequena' },
+];
+
+const MAX_TEXTO = 280;
+const ID_ESTILO = new Set(ESTILOS.map((e) => e.id));
+const ID_GOSTEI = new Set(GOSTEI.map((e) => e.id));
+const ID_NAO = new Set(NAO_QUERO.map((e) => e.id));
+
+function arquivo(home = os.homedir()) { return path.join(home, '.primocode', 'gosto-motion.json'); }
+
+function texto(s) {
+    // tira caracteres de controle (menos nada: quebra de linha vira espaço) e corta
+    return String(s == null ? '' : s).replace(/[\u0000-\u001f\u007f]+/g, ' ').replace(/\s+/g, ' ').trim().slice(0, MAX_TEXTO);
+}
+
+function unicos(lista, valido) {
+    const out = [];
+    for (const x of Array.isArray(lista) ? lista : []) if (valido.has(x) && !out.includes(x)) out.push(x);
+    return out;
+}
+
+/** Aceita só ids conhecidos, corta texto, tira controle. */
+function normalizar(d) {
+    const o = d && typeof d === 'object' ? d : {};
+    const escolhidos = [];
+    for (const e of Array.isArray(o.escolhidos) ? o.escolhidos : []) {
+        if (!e || !ID_ESTILO.has(e.id) || escolhidos.some((x) => x.id === e.id)) continue;
+        escolhidos.push({ id: e.id, gostei: unicos(e.gostei, ID_GOSTEI), texto: texto(e.texto) });
+    }
+    return {
+        versao: 1,
+        quando: typeof o.quando === 'string' && !Number.isNaN(Date.parse(o.quando)) ? o.quando : new Date().toISOString(),
+        escolhidos,
+        nao_quero: unicos(o.nao_quero, ID_NAO),
+        nao_texto: texto(o.nao_texto),
+        pulou: !!o.pulou,
+    };
+}
+
+function ler(home) {
+    try { return normalizar(JSON.parse(fs.readFileSync(arquivo(home), 'utf8'))); } catch { return null; }
+}
+
+function salvar(dados, home) {
+    const n = normalizar(dados);
+    const f = arquivo(home);
+    fs.mkdirSync(path.dirname(f), { recursive: true });
+    fs.writeFileSync(f, JSON.stringify(n, null, 2));
+    return n;
+}
+
+function tem(home) { return fs.existsSync(arquivo(home)); }
+
+/** Multiplicadores pro diretor. Tudo em 1 = neutro. Nunca fixa nada: só inclina o sorteio. */
+function pesos(gosto) {
+    const p = { ritmo: { rapido: 1, medio: 1, lento: 1 }, cameras: {}, trocas: {}, tipografias: {}, overshoot: null };
+    const mult = (grupo, nome, k, teto = 5) => { p[grupo][nome] = Math.min(teto, (p[grupo][nome] != null ? p[grupo][nome] : 1) * k); };
+    const baixa = (grupo, nome, k) => { p[grupo][nome] = (p[grupo][nome] != null ? p[grupo][nome] : 1) * k; };
+    if (!gosto || gosto.pulou || !Array.isArray(gosto.escolhidos) || !gosto.escolhidos.length) {
+        if (gosto && Array.isArray(gosto.nao_quero) && !gosto.pulou) aplicarNao(p, gosto.nao_quero, baixa);
+        return p;
+    }
+    const chips = new Set();
+    let somaOver = 0, nOver = 0;
+    for (const esc of gosto.escolhidos) {
+        const e = ESTILOS.find((x) => x.id === esc.id);
+        if (!e) continue;
+        p.ritmo[e.ritmo] *= 1.8;
+        e.cameras.forEach((n) => mult('cameras', n, 2.2));
+        e.trocas.forEach((n) => mult('trocas', n, 2.2));
+        e.tipografias.forEach((n) => mult('tipografias', n, 2.2));
+        somaOver += e.overshoot; nOver++;
+        (esc.gostei || []).forEach((g) => chips.add(g));
+    }
+    if (chips.has('rapido')) p.ritmo.rapido *= 1.5;
+    if (chips.has('calmo')) { p.ritmo.lento *= 1.5; baixa('trocas', 'tremor', 0.4); baixa('trocas', 'chicote', 0.4); }
+    if (chips.has('quique')) { mult('trocas', 'giro', 1.4); mult('trocas', 'encolhe', 1.4); }
+    if (chips.has('tres_d')) { mult('cameras', 'orbita', 1.5); mult('cameras', 'cinema', 1.5); mult('trocas', 'giro', 1.4); }
+    if (chips.has('camera')) ['pulso', 'chicote', 'orbita'].forEach((n) => mult('cameras', n, 1.3));
+    if (chips.has('cortes')) { mult('trocas', 'corte', 1.4); mult('trocas', 'chicote', 1.4); }
+    aplicarNao(p, gosto.nao_quero || [], baixa);
+    let over = nOver ? somaOver / nOver : null;
+    if (over != null) {
+        if (chips.has('quique')) over += 0.05;
+        if ((gosto.nao_quero || []).includes('exagero')) over -= 0.05;
+        over = Math.round(Math.max(0, Math.min(0.3, over)) * 1000) / 1000;
+    }
+    p.overshoot = over;
+    return p;
+}
+
+function aplicarNao(p, nao, baixa) {
+    if (nao.includes('lento')) p.ritmo.lento *= 0.3;
+    if (nao.includes('liso')) { baixa('trocas', 'dissolve', 0.4); baixa('trocas', 'desfoque', 0.4); }
+    if (nao.includes('exagero')) { baixa('trocas', 'tremor', 0.4); baixa('trocas', 'chicote', 0.4); }
+    if (nao.includes('tremido')) baixa('trocas', 'tremor', 0.2);
+}
+
+const lista = (a) => (a.length <= 1 ? a.join('') : a.slice(0, -1).join(', ') + ' e ' + a[a.length - 1]);
+
+/** Frases em PT-BR pro modelo. Nulo → ''. */
+function resumo(gosto) {
+    if (!gosto) return '';
+    if (gosto.pulou && !(gosto.nao_quero || []).length) return 'A pessoa pulou a tela de gosto: sem preferência salva.';
+    const partes = [];
+    const esc = (gosto.escolhidos || []).map((x) => {
+        const e = ESTILOS.find((s) => s.id === x.id);
+        if (!e) return null;
+        const g = (x.gostei || []).map((i) => (GOSTEI.find((c) => c.id === i) || {}).nome).filter(Boolean);
+        return g.length ? `${e.nome} (${g.join(', ')})` : e.nome;
+    }).filter(Boolean);
+    if (esc.length) partes.push(`Gosto salvo da pessoa: gostou de ${lista(esc)}.`);
+    const nao = (gosto.nao_quero || []).map((i) => (NAO_QUERO.find((c) => c.id === i) || {}).curto).filter(Boolean);
+    if (nao.length) partes.push(`Não quer: ${nao.join(', ')}.`);
+    const txt = [(gosto.escolhidos || []).map((x) => x.texto).filter(Boolean).join(' / '), gosto.nao_texto ? 'não quer: ' + gosto.nao_texto : ''].filter(Boolean).join(' · ');
+    if (txt) partes.push(`Escreveu: "${txt}".`);
+    if (!partes.length) return '';
+    partes.push('Use como direção, não como molde.');
+    return partes.join(' ');
+}
+
+/** Só pergunta no primeiro pedido, com gente do outro lado: nunca em -p, CI ou teste. */
+function deveAbrir(args = {}, env = process.env, home) {
+    return !tem(home) && !(args && args.gosto === false) && !env.PRIMOCODE_SEM_TELA && !env.CI && !!process.stdout.isTTY;
+}
+
+function lerCorpo(req, limite = 20 * 1024) {
+    return new Promise((resolve, reject) => {
+        let tam = 0; const partes = [];
+        req.on('data', (c) => {
+            tam += c.length;
+            if (tam > limite) { reject(new Error('grande')); req.destroy(); return; }
+            partes.push(c);
+        });
+        req.on('end', () => resolve(Buffer.concat(partes).toString('utf8')));
+        req.on('error', reject);
+    });
+}
+
+/**
+ * Abre a tela no navegador. Resolve {ok:true, gosto} (salvou), {ok:false, motivo:'pulou'|'tempo'|'sem_tela'}.
+ * `abrir(url)` e `home` são injetáveis (testes).
+ */
+function abrirTela({ home, abrir, timeoutMs = 10 * 60 * 1000, porta = 0 } = {}) {
+    return new Promise((resolve) => {
+        const token = crypto.randomBytes(16).toString('hex');
+        let html;
+        try { html = fs.readFileSync(path.join(__dirname, 'gosto', 'tela.html'), 'utf8'); } catch { return resolve({ ok: false, motivo: 'sem_tela' }); }
+        const dados = JSON.stringify({ ESTILOS, GOSTEI, NAO_QUERO }).replace(/</g, '\\u003c');
+        let fim = false, timer = null;
+        const srv = http.createServer(async (req, res) => {
+            const u = new URL(req.url, 'http://127.0.0.1');
+            const dizer = (cod, corpo, tipo = 'application/json; charset=utf-8') => { res.writeHead(cod, { 'content-type': tipo, 'cache-control': 'no-store' }); res.end(typeof corpo === 'string' ? corpo : JSON.stringify(corpo)); };
+            try {
+                if (req.method === 'GET' && u.pathname === '/') {
+                    if (u.searchParams.get('t') !== token) return dizer(403, 'token inválido', 'text/plain; charset=utf-8');
+                    return dizer(200, html.split('__TOKEN__').join(token).split('__DADOS__').join(dados), 'text/html; charset=utf-8');
+                }
+                if (req.method === 'POST' && (u.pathname === '/salvar' || u.pathname === '/pular')) {
+                    if (req.headers['x-gosto-token'] !== token) return dizer(403, { ok: false, error: 'token inválido' });
+                    if (u.pathname === '/pular') {
+                        salvar({ pulou: true }, home);
+                        dizer(200, { ok: true });
+                        return terminar({ ok: false, motivo: 'pulou' });
+                    }
+                    let corpo;
+                    try { corpo = JSON.parse(await lerCorpo(req)); } catch { return dizer(400, { ok: false, error: 'corpo inválido (JSON até 20 KB)' }); }
+                    const g = salvar(corpo, home);
+                    dizer(200, { ok: true, resumo: resumo(g) });
+                    return terminar({ ok: true, gosto: g });
+                }
+                dizer(404, 'não achei', 'text/plain; charset=utf-8');
+            } catch (e) { try { dizer(500, { ok: false, error: String(e.message || e) }); } catch { /* já respondeu */ } }
+        });
+        function terminar(r) {
+            if (fim) return;
+            fim = true;
+            clearTimeout(timer);
+            try { srv.close(); } catch { /* já fechou */ }
+            // deixa a resposta sair e depois derruba o que sobrar de conexão aberta (keep-alive do navegador)
+            const t = setTimeout(() => { try { if (srv.closeAllConnections) srv.closeAllConnections(); } catch { /* ok */ } }, 300);
+            if (t.unref) t.unref();
+            resolve(r);
+        }
+        srv.on('error', () => terminar({ ok: false, motivo: 'sem_tela' }));
+        srv.listen(porta, '127.0.0.1', () => {
+            timer = setTimeout(() => terminar({ ok: false, motivo: 'tempo' }), timeoutMs);
+            const url = `http://127.0.0.1:${srv.address().port}/?t=${token}`;
+            try {
+                const r = (abrir || ((x) => require('../tools.js').openInBrowser(x)))(url);
+                if (r && typeof r.catch === 'function') r.catch(() => {});
+            } catch { /* sem navegador: a pessoa espera o tempo ou pula */ }
+        });
+    });
+}
+
+const _teste = { texto, MAX_TEXTO, aplicarNao };
+
+module.exports = { ESTILOS, GOSTEI, NAO_QUERO, arquivo, ler, salvar, tem, normalizar, pesos, resumo, abrirTela, deveAbrir, _teste };

package/lib/estudio/index.js

@@ -718,6 +718,12 @@ async function ferramentaMotion(args) {
         if (r.bloqueado) return { ok: false, error: r.aviso, projeto: r.projeto };
         receita = r.projeto;
     }
+    // primeiro motion: aprende o gosto antes de renderizar (a pessoa pode fechar ou pular; o render segue de qualquer jeito)
+    const gosto = require('./gosto.js');
+    if (gosto.deveAbrir(args)) {
+        try { console.error(require('../ui.js').c.warn('  ⎿ Antes do primeiro motion: abri uma tela pra aprender o seu gosto (até 10 min). Feche ou pule pra seguir.')); } catch { /* sem terminal */ }
+        try { await gosto.abrirTela(); } catch { /* sem tela, segue */ }
+    }
     return require('./cota.js').comCota(() => renderMotion(args, p, receita));
 }
 
@@ -734,7 +740,9 @@ async function renderMotion(args, p, receita) {
     const r = await require('./maquina.js').motion(args, { pasta: p.pasta, receita, deps: { narrar } });
     if (r.ok) projeto.anotar(p.id, 'motion', `${r.duracao}s, ${r.cenas.length} cenas, ${r.lufs} LUFS`);
     if (r.ok) entregar(args, p, r);
-    return r.ok ? { ...r, nota: 'Abra os quadros (png em ae/) para conferir. Se algo ficou torto, mude o JSON e rode de novo.' } : r;
+    if (!r.ok) return r;
+    const gostoResumo = (() => { try { const G = require('./gosto.js'); return G.resumo(G.ler()); } catch { return ''; } })();
+    return { ...r, ...(gostoResumo ? { gosto: gostoResumo } : {}), nota: 'Abra os quadros (png em ae/) para conferir. Se algo ficou torto, mude o JSON e rode de novo.' };
 }
 
 // ── estudio_editar ───────────────────────────────────────────────────────

package/lib/estudio/maquina-diretor.js

@@ -311,8 +311,11 @@ function dirigir(args = {}, { historico = lerHistorico(), semente = null, temEle
 function montarDirecao({ args, assunto, meta, duracao, hist, rnd, temElemento }) {
     const ultimo = hist[hist.length - 1];
     const ctx = { assunto, meta, hist, historico: hist, usados: new Set(), ultimaFam: null, temElemento };
+    // o gosto da pessoa (gosto.js: pesos) só MULTIPLICA o sorteio; histórico, "nao", metáfora e anti-repetição seguem valendo
+    const G = args.gosto && typeof args.gosto === 'object' ? args.gosto : null;
+    const gm = (grupo, nome) => { const v = G && G[grupo] && G[grupo][nome]; return Number.isFinite(v) && v >= 0 ? v : 1; };
     // ritmo: duração média por cena
-    const ritmo = args.ritmo || sortear(rnd, [['rapido', 1], ['medio', 1.4], ['lento', 0.8]].map(([r, p]) => [r, p * (ultimo && ultimo.ritmo === r ? 0.4 : 1)]));
+    const ritmo = args.ritmo || sortear(rnd, [['rapido', 1], ['medio', 1.4], ['lento', 0.8]].map(([r, p]) => [r, p * gm('ritmo', r) * (ultimo && ultimo.ritmo === r ? 0.4 : 1)]));
     const media = ritmo === 'rapido' ? 2.5 : ritmo === 'lento' ? 3.5 : 3.0;   // cena de 2,5 a 3,5 s: o corte seco da câmera dá o pulso a cada ~1 s
 
     // as cenas pedidas (ou os papéis sorteados)
@@ -360,20 +363,20 @@ function montarDirecao({ args, assunto, meta, duracao, hist, rnd, temElemento })
         let t = Array.isArray(pedidasT) && TRANSICOES.includes(pedidasT[i - 1]) ? pedidasT[i - 1] : null;
         if (!t) {
             if (out[i - 1].tipo === 'mergulho') t = rnd() < 0.5 ? 'corte' : 'dissolve';
-            else t = sortear(rnd, TRANSICOES.map((x) => [x, (['dissolve', 'desfoque', 'encolhe', 'mascara', 'abre', 'cortina'].includes(x) ? 0.4 : 1.4) * (meta.trocas.includes(x) ? 3 : 1) * Math.pow(0.6, recT.get(x) || 0) * (x === trocas[trocas.length - 1] ? 0 : 1) * (trocas.slice(-3).includes(x) ? 0.3 : 1)]));
+            else t = sortear(rnd, TRANSICOES.map((x) => [x, (['dissolve', 'desfoque', 'encolhe', 'mascara', 'abre', 'cortina'].includes(x) ? 0.4 : 1.4) * (meta.trocas.includes(x) ? 3 : 1) * Math.pow(0.6, recT.get(x) || 0) * (x === trocas[trocas.length - 1] ? 0 : 1) * (trocas.slice(-3).includes(x) ? 0.3 : 1) * gm('trocas', x)]));
         }
         trocas.push(t);
     }
 
     // câmera: um estilo principal + um secundário em algumas cenas
     const recC = new Map(); hist.slice(-3).forEach((h) => recC.set(h.camera, (recC.get(h.camera) || 0) + 1));
-    const camera = CAMERAS.includes(args.camera) ? args.camera : sortear(rnd, CAMERAS.map((x) => [x, (meta.cameras.includes(x) ? 3 : 1) * Math.pow(0.45, recC.get(x) || 0)]));
-    const camera2 = sortear(rnd, CAMERAS.filter((x) => x !== camera).map((x) => [x, meta.cameras.includes(x) ? 2 : 1]));
+    const camera = CAMERAS.includes(args.camera) ? args.camera : sortear(rnd, CAMERAS.map((x) => [x, (meta.cameras.includes(x) ? 3 : 1) * Math.pow(0.45, recC.get(x) || 0) * gm('cameras', x)]));
+    const camera2 = sortear(rnd, CAMERAS.filter((x) => x !== camera).map((x) => [x, (meta.cameras.includes(x) ? 2 : 1) * gm('cameras', x)]));
     out.forEach((c, i) => { c.camera = c.camera && CAMERAS.includes(c.camera) ? c.camera : (i % 3 === 2 ? camera2 : camera); });
 
     // tipografia
     const recTi = new Map(); hist.slice(-3).forEach((h) => recTi.set(h.tipografia, (recTi.get(h.tipografia) || 0) + 1));
-    const tipografia = TIPOGRAFIAS[args.tipografia] ? args.tipografia : sortear(rnd, Object.keys(TIPOGRAFIAS).map((x) => [x, (meta.tipografias.includes(x) ? 3 : 0.8) * Math.pow(0.4, recTi.get(x) || 0)]));
+    const tipografia = TIPOGRAFIAS[args.tipografia] ? args.tipografia : sortear(rnd, Object.keys(TIPOGRAFIAS).map((x) => [x, (meta.tipografias.includes(x) ? 3 : 0.8) * Math.pow(0.4, recTi.get(x) || 0) * gm('tipografias', x)]));
 
     // paleta
     const recP = new Map(); hist.slice(-3).forEach((h) => recP.set(h.paleta, (recP.get(h.paleta) || 0) + 1));
@@ -384,6 +387,7 @@ function montarDirecao({ args, assunto, meta, duracao, hist, rnd, temElemento })
         metafora: meta.nome, chave: meta.chave, assunto, primitivas: out.map((c) => c.tipo), trocas, camera, camera2, tipografia, ritmo, paleta,
         molde: papeisUsados.join(','), cenas: out.length, tipos_unicos: new Set(out.map((c) => c.tipo)).size,
     };
+    if (G) assinatura.gosto = true;
     return { metafora: meta, cenas: out, trocas, camera, tipografia, ritmo, paleta, ordemPal, assinatura };
 }
 

package/lib/estudio/maquina.js

@@ -375,7 +375,10 @@ async function motion(args = {}, { pasta, receita = null, deps = {} } = {}) {
     const elementos = (el && el.elementos) || [];
 
     // 2. a direção (primitivas, transições, câmera, tipografia, paleta) com semente e conferência de assinatura
-    let pl = plano({ ...args, assunto }, { receita, historico, elementos });
+    // o gosto salvo da pessoa entra como PESO no sorteio do diretor (não como molde)
+    const G = require('./gosto.js');
+    const gostoP = deps.gosto !== undefined ? deps.gosto : G.pesos(G.ler());
+    let pl = plano({ ...args, assunto, gosto: gostoP }, { receita, historico, elementos });
     const avisosDeMotor = [];
     if (elementos.length < 3) avisosDeMotor.push(`só ${elementos.length} elemento(s) real(is) do assunto (o pedido é ≥ 3)`);
 
@@ -508,6 +511,7 @@ async function motion(args = {}, { pasta, receita = null, deps = {} } = {}) {
         voz: !!voz, vozMotor: voz && voz.motor, vozMedida: voz && voz.medido, conferencia, receita: pl.receita, projeto: r.projeto, assinatura,
         elementos: elementos.map((e) => ({ nome: e.nome, tipo: e.tipo, licenca: e.licenca })), creditos: (el && el.creditos) || [],
         avisos: avisosDeMotor,
+        ...(gostoP && gostoP.overshoot != null ? { gosto: { overshoot: gostoP.overshoot } } : {}),
         _exportar: { palavras: voz ? voz.palavras : [], sfx: sons.filter((x) => x.arquivo).map((x) => x.arquivo), cenas: pl.cenas.map((c) => ({ papel: c.papel, titulo: c.titulo, texto: c.texto, fala: c.fala, botao: c.botao, dur: c.dur })), trilhaArquivo: trilha && trilha.arquivo },
         ...(mix.ok || args.previa ? {} : { aviso: 'o vídeo saiu sem a mixagem de áudio: ' + (mix.error || 'sem sons') }),
     };

package/lib/headless.js

@@ -64,8 +64,20 @@ async function capturar(fn, { calar = false } = {}) {
     return texto.replace(/\n{3,}/g, '\n\n').trim();
 }
 
-function resultadoJson({ texto, erro, inicio, permissao }) {
-    return JSON.stringify({ type: 'result', is_error: !!erro, result: erro ? String(erro) : texto, duration_ms: Date.now() - inicio, permission_mode: permissao || 'auto' });
+function resultadoJson({ texto, erro, inicio, permissao, conversa, markdown }) {
+    return JSON.stringify({ type: 'result', is_error: !!erro, result: erro ? String(erro) : texto, duration_ms: Date.now() - inicio, permission_mode: permissao || 'auto', conversa: conversa || null, markdown: erro ? null : (markdown || null) });
 }
 
-module.exports = { analisar, montarPedido, lerStdin, capturar, resultadoJson, FORMATOS };
+/* A última resposta do agente como ele escreveu (markdown cru), sem o que o terminal desenha em volta. */
+function ultimaResposta(historico, desde = 0) {
+    for (let i = (historico || []).length - 1; i >= desde; i--) {
+        const m = historico[i];
+        if (!m || m.role !== 'assistant') continue;
+        const t = typeof m.content === 'string' ? m.content
+            : Array.isArray(m.content) ? m.content.map((p) => (typeof p === 'string' ? p : (p && p.type === 'text' && p.text) || '')).join('\n') : '';
+        if (t.trim()) return t.trim();
+    }
+    return null;
+}
+
+module.exports = { analisar, montarPedido, lerStdin, capturar, resultadoJson, ultimaResposta, FORMATOS };

package/lib/local/cerebro.json

@@ -1390,6 +1390,52 @@
     }
    }
   },
+  {
+   "type": "function",
+   "function": {
+    "name": "lembrar",
+    "description": "Guarda ou apaga uma memoria que dura entre sessoes (arquivos em ~/.primocode/memoria/). acao \"salvar\": nome (kebab-case curto; o mesmo nome atualiza, sem duplicar), descricao (uma linha), tipo, texto. acao \"apagar\": so o nome. Nunca guarde chave, token ou senha.",
+    "parameters": {
+     "type": "object",
+     "properties": {
+      "acao": {
+       "type": "string",
+       "enum": [
+        "salvar",
+        "apagar"
+       ],
+       "description": "salvar ou apagar"
+      },
+      "nome": {
+       "type": "string",
+       "description": "Nome em kebab-case, ex: prefere-respostas-curtas"
+      },
+      "descricao": {
+       "type": "string",
+       "description": "Uma linha dizendo do que se trata (aparece no indice)"
+      },
+      "tipo": {
+       "type": "string",
+       "enum": [
+        "usuario",
+        "feedback",
+        "projeto",
+        "referencia"
+       ],
+       "description": "usuario: quem e; feedback: correcao ou preferencia; projeto: fato do projeto; referencia: onde achar algo"
+      },
+      "texto": {
+       "type": "string",
+       "description": "O fato, com o porque quando houver"
+      }
+     },
+     "required": [
+      "acao",
+      "nome"
+     ]
+    }
+   }
+  },
   {
    "type": "function",
    "function": {
@@ -2839,6 +2885,52 @@
     }
    }
   },
+  {
+   "type": "function",
+   "function": {
+    "name": "lembrar",
+    "description": "Guarda ou apaga uma memoria que dura entre sessoes (arquivos em ~/.primocode/memoria/). acao \"salvar\": nome (kebab-case curto; o mesmo nome atualiza, sem duplicar), descricao (uma linha), tipo, texto. acao \"apagar\": so o nome. Nunca guarde chave, token ou senha.",
+    "parameters": {
+     "type": "object",
+     "properties": {
+      "acao": {
+       "type": "string",
+       "enum": [
+        "salvar",
+        "apagar"
+       ],
+       "description": "salvar ou apagar"
+      },
+      "nome": {
+       "type": "string",
+       "description": "Nome em kebab-case, ex: prefere-respostas-curtas"
+      },
+      "descricao": {
+       "type": "string",
+       "description": "Uma linha dizendo do que se trata (aparece no indice)"
+      },
+      "tipo": {
+       "type": "string",
+       "enum": [
+        "usuario",
+        "feedback",
+        "projeto",
+        "referencia"
+       ],
+       "description": "usuario: quem e; feedback: correcao ou preferencia; projeto: fato do projeto; referencia: onde achar algo"
+      },
+      "texto": {
+       "type": "string",
+       "description": "O fato, com o porque quando houver"
+      }
+     },
+     "required": [
+      "acao",
+      "nome"
+     ]
+    }
+   }
+  },
   {
    "type": "function",
    "function": {
@@ -2857,4 +2949,4 @@
    }
   }
  ]
-}
+}