primocode 10.17.1 → 10.19.0

package/lib/estudio/gosto.js

@@ -10,6 +10,10 @@
  *   ler() / salvar() / tem()   o arquivo
  *   pesos(gosto)               multiplicadores pro diretor (tudo 1 = neutro)
  *   resumo(gosto)              1 a 3 frases pro modelo ler
+ *   adicionarReferencia()      soma um vídeo de referência já medido (gosto-medir.js): até 5, pesos suaves
+ *   fraseDeUmaReferencia()     a frase de um vídeo só (a tela mostra como "Entendi: …")
+ *                              cada referência pode trazer `descricao` (gosto-descrever.js: o modelo olhou o vídeo e
+ *                              escolheu câmeras, trocas e tipografias do diretor + frases; a pessoa conferiu na tela)
  *   abrirTela()                servidor local 127.0.0.1 + token; resolve {ok, gosto} | {ok:false, motivo}
  *   antesDoMotion()            no terminal abre o navegador; no app (-p com PRIMOCODE_APP=1) escreve
  *                              `primocode:abrir-gosto <url>` no stderr e o app (desktop ou Primo.app) abre a tela
@@ -69,6 +73,15 @@ const NAO_QUERO = [
 ];
 
 const MAX_TEXTO = 280;
+const MAX_REFERENCIAS = 5;
+const MAX_POR_TELA = MAX_REFERENCIAS * 3;
+const RITMOS = ['rapido', 'medio', 'lento'];
+const FORMATOS = ['9:16', '16:9', '1:1', 'outro'];
+const LUGARES = ['topo', 'meio', 'baixo'];
+/* movimento de gosto-medir.js (0 a 1): o testsrc do ffmpeg dá ~0,2, então 0,4 é o dobro dele (mexe de verdade) e 0,1 é quase parado */
+const FORCAS_VALIDAS = ['pouco', 'medio', 'muito'];
+const MOVIMENTO_ALTO = 0.4;
+const MOVIMENTO_BAIXO = 0.1;
 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));
@@ -86,6 +99,47 @@ function unicos(lista, valido) {
     return out;
 }
 
+const num = (v, min, max, casas = 2) => {
+    const n = Number(v);
+    return Number.isFinite(n) ? Math.round(Math.max(min, Math.min(max, n)) * 10 ** casas) / 10 ** casas : 0;
+};
+
+/** Da medida do vídeo (gosto-medir.js) guarda só os números, com o tipo conferido. */
+function normalizarMedida(m) {
+    const o = m && typeof m === 'object' ? m : {};
+    const t = o.texto && typeof o.texto === 'object' ? o.texto : null;
+    return {
+        segundos: num(o.segundos, 0, 86400),
+        formato: FORMATOS.includes(o.formato) ? o.formato : 'outro',
+        cortesPorSegundo: num(o.cortesPorSegundo, 0, 100),
+        ritmo: RITMOS.includes(o.ritmo) ? o.ritmo : 'medio',
+        movimento: num(o.movimento, 0, 1),
+        paleta: (Array.isArray(o.paleta) ? o.paleta : []).filter((c) => /^#[0-9a-f]{6}$/i.test(c)).map((c) => c.toLowerCase()).slice(0, 5),
+        texto: t ? { fracaoComTexto: num(t.fracaoComTexto, 0, 1), alturaMedia: num(t.alturaMedia, 0, 1, 3), lugar: LUGARES.includes(t.lugar) ? t.lugar : null } : null,
+    };
+}
+
+/** A descrição que o modelo deu (e a pessoa conferiu): só ids do diretor, frases cortadas. null se não sobrou nada. */
+function normalizarDescricao(d) {
+    if (!d || typeof d !== 'object') return null;
+    const f = require('./gosto-descrever.js').filtrarDescricao(d);
+    f.frases = f.frases.map((x) => texto(x)).filter(Boolean);
+    return f.cameras.length || f.trocas.length || f.tipografias.length || f.frases.length ? f : null;
+}
+
+function normalizarReferencias(lista) {
+    const out = [];
+    for (const r of Array.isArray(lista) ? lista : []) {
+        if (!r || typeof r !== 'object' || !r.medida || typeof r.medida !== 'object') continue;
+        const item = { nome: texto(r.nome).slice(0, 80), quando: typeof r.quando === 'string' && !Number.isNaN(Date.parse(r.quando)) ? r.quando : new Date().toISOString(), medida: normalizarMedida(r.medida) };
+        const descricao = normalizarDescricao(r.descricao);
+        if (descricao) item.descricao = descricao;   // sem descrição o item fica como na fatia 2
+        out.push(item);
+        if (out.length >= MAX_REFERENCIAS) break;
+    }
+    return out;
+}
+
 /** Aceita só ids conhecidos, corta texto, tira controle. */
 function normalizar(d) {
     const o = d && typeof d === 'object' ? d : {};
@@ -94,14 +148,18 @@ function normalizar(d) {
         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 {
+    const g = {
         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,
+        ...(FORCAS_VALIDAS.includes(o.forca) && o.forca !== 'medio' ? { forca: o.forca } : {}),   // médio é o padrão: não entra no arquivo
     };
+    const referencias = normalizarReferencias(o.referencias);
+    if (referencias.length) g.referencias = referencias;   // sem referência o arquivo fica igual ao de antes
+    return g;
 }
 
 function ler(home) {
@@ -116,6 +174,85 @@ function salvar(dados, home) {
     return n;
 }
 
+/** Soma um vídeo de referência (a medida de gosto-medir.js) ao gosto salvo: até 5, a mais antiga sai quando enche. Devolve o gosto. */
+function adicionarReferencia(medida, { nome, home } = {}) {
+    const g = ler(home) || normalizar({});
+    const lista = [...(g.referencias || []), { nome: nome || (medida && medida.arquivo ? path.basename(String(medida.arquivo)) : ''), quando: new Date().toISOString(), medida }];
+    return salvar({ ...g, referencias: lista.slice(-MAX_REFERENCIAS) }, home);
+}
+
+/* ESTILOS COM NOME (ideia do Jitter: o efeito salvo e reusado): um gosto por cliente ou por marca. O gosto em uso
+   continua sendo o gosto-motion.json; os nomeados moram em ~/.primocode/gosto-estilos/<nome>.json e só entram
+   em uso pelo /taste usar. */
+const pastaDosEstilos = (home = os.homedir()) => path.join(home, '.primocode', 'gosto-estilos');
+const nomeDoEstilo = (n) => String(n || '').normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 40);
+function salvarEstilo(nome, { home } = {}) {
+    const n = nomeDoEstilo(nome), g = ler(home);
+    if (!n) return { ok: false, error: 'dê um nome ao estilo: /taste salvar <nome>' };
+    if (!g) return { ok: false, error: 'ainda não tem gosto pra salvar: /taste referencias ou /taste refazer primeiro' };
+    fs.mkdirSync(pastaDosEstilos(home), { recursive: true });
+    fs.writeFileSync(path.join(pastaDosEstilos(home), n + '.json'), JSON.stringify(normalizar(g), null, 2));
+    return { ok: true, nome: n };
+}
+function usarEstilo(nome, { home } = {}) {
+    const n = nomeDoEstilo(nome);
+    let g;
+    try { g = JSON.parse(fs.readFileSync(path.join(pastaDosEstilos(home), n + '.json'), 'utf8')); } catch { return { ok: false, error: `não tem estilo "${n || nome}". /taste estilos lista os que existem` }; }
+    return { ok: true, nome: n, gosto: salvar(g, home) };
+}
+/** /gosto força pouco|médio|muito: quanto as referências pesam no próximo motion. */
+function definirForca(forca, { home } = {}) {
+    const f = String(forca || '').normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase().trim();
+    if (!FORCAS_VALIDAS.includes(f)) return { ok: false, error: 'a força é pouco, médio ou muito: /taste força muito' };
+    const g = ler(home) || normalizar({});
+    return { ok: true, forca: f, gosto: salvar({ ...g, forca: f }, home) };
+}
+
+function estilos({ home } = {}) {
+    try { return fs.readdirSync(pastaDosEstilos(home)).filter((f) => f.endsWith('.json')).map((f) => f.slice(0, -5)).sort(); } catch { return []; }
+}
+
+/** Tira a referência N (1 = a primeira da lista do /gosto). Devolve o gosto, ou null se não há a N. */
+function tirarReferencia(n, { home } = {}) {
+    const g = ler(home);
+    const i = Number(n) - 1;
+    if (!g || !Array.isArray(g.referencias) || !(i >= 0 && i < g.referencias.length)) return null;
+    return salvar({ ...g, referencias: g.referencias.filter((_, k) => k !== i) }, home);
+}
+
+/** O /gosto em linhas: os estilos do carrossel e cada vídeo de referência, numerado pro /gosto tirar N. Pura. */
+function listar(gosto) {
+    if (!gosto) return [];
+    const out = [];
+    const esc = (gosto.escolhidos || []).map((x) => (ESTILOS.find((s) => s.id === x.id) || {}).nome).filter(Boolean);
+    if (esc.length) out.push(`Estilos que você escolheu: ${lista(esc)}.`);
+    const nao = (gosto.nao_quero || []).map((i) => (NAO_QUERO.find((c) => c.id === i) || {}).curto).filter(Boolean);
+    if (nao.length) out.push(`Não quer: ${nao.join(', ')}.`);
+    (gosto.referencias || []).forEach((r, k) => {
+        out.push(`${k + 1}. ${r.nome || 'vídeo'} — ${fraseDeUmaReferencia(r.medida).replace(/^Trouxe 1 vídeo de referência: /, '')}`);
+        for (const f of ((r.descricao && r.descricao.frases) || [])) out.push(`   "${f}"`);
+    });
+    if (gosto.forca && gosto.forca !== 'medio' && (gosto.referencias || []).length) out.push(`Força das referências: ${gosto.forca === 'pouco' ? 'pouco (só sugerem)' : 'muito (puxam forte)'}.`);
+    const pra = inclinacao(pesos(gosto));
+    if (pra) out.push(`O próximo motion tende a: ${pra}.`);
+    return out;
+}
+
+/* Pra onde os pesos inclinam o diretor, em palavras: só o que ganhou de verdade (1,5× ou mais), no máximo dois por
+   grupo. É o que a pessoa quer saber quando abre o /taste: "o que muda no meu próximo vídeo?". Pura. */
+function inclinacao(p) {
+    if (!p) return '';
+    const fortes = (grupo, min = 1.5) => Object.entries(p[grupo] || {}).filter(([, v]) => v >= min).sort((a, b) => b[1] - a[1]).slice(0, 2).map(([n]) => n);
+    const partes = [];
+    const r = Object.entries(p.ritmo || {}).sort((a, b) => b[1] - a[1]);
+    if (r.length && r[0][1] >= 1.5 && r[0][1] >= 1.3 * (r[1] ? r[1][1] : 1)) partes.push(`ritmo ${{ rapido: 'rápido', medio: 'médio', lento: 'lento' }[r[0][0]]}`);
+    const cam = fortes('cameras'); if (cam.length) partes.push(`câmera ${lista(cam)}`);
+    const tr = fortes('trocas'); if (tr.length) partes.push(`troca ${lista(tr)}`);
+    const tp = fortes('tipografias'); if (tp.length) partes.push(`letra ${lista(tp)}`);
+    const pal = fortes('paletas', 1.8).slice(0, 1); if (pal.length) partes.push(`paleta ${pal[0]}`);
+    return partes.join(', ');
+}
+
 function tem(home) { return fs.existsSync(arquivo(home)); }
 
 /** Multiplicadores pro diretor. Tudo em 1 = neutro. Nunca fixa nada: só inclina o sorteio. */
@@ -124,6 +261,7 @@ function pesos(gosto) {
     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) {
+        aplicarReferencias(p, gosto && gosto.referencias, mult, gosto && gosto.forca);   // o vídeo que a pessoa trouxe vale mesmo sem o carrossel
         if (gosto && Array.isArray(gosto.nao_quero) && !gosto.pulou) aplicarNao(p, gosto.nao_quero, baixa);
         return p;
     }
@@ -139,6 +277,7 @@ function pesos(gosto) {
         somaOver += e.overshoot; nOver++;
         (esc.gostei || []).forEach((g) => chips.add(g));
     }
+    aplicarReferencias(p, gosto.referencias, mult, gosto.forca);
     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); }
@@ -156,19 +295,95 @@ function pesos(gosto) {
     return p;
 }
 
+/** Cada vídeo de referência inclina o ritmo dele (x1,6) e, se mexe muito, as câmeras de punch (x1,3).
+ *  O que o modelo viu nele (câmera, troca, tipografia) também sobe x1,6. Só inclina. */
+/* Quanto as referências pesam (/gosto força; ideia do Runway, "pouco / médio / igual"): o multiplicador de cada
+   referência elevado a este expoente. Médio é o de sempre; pouco quase só sugere; muito puxa forte, mas ainda é peso. */
+const FORCAS = { pouco: 0.5, medio: 1, muito: 2.2 };
+function aplicarReferencias(p, referencias, mult, forca = 'medio') {
+    const e = FORCAS[forca] || 1;
+    const k = (v) => Math.pow(v, e);
+    for (const r of Array.isArray(referencias) ? referencias : []) {
+        const m = r && r.medida;
+        if (!m) continue;
+        if (p.ritmo[m.ritmo] != null) p.ritmo[m.ritmo] *= k(1.6);
+        if (m.movimento >= MOVIMENTO_ALTO) ['pulso', 'chicote'].forEach((n) => mult('cameras', n, k(1.3)));
+        const d = r.descricao;
+        if (d) for (const grupo of ['cameras', 'trocas', 'tipografias']) (d[grupo] || []).forEach((n) => mult(grupo, n, k(1.6)));
+    }
+    const cores = (Array.isArray(referencias) ? referencias : []).flatMap((r) => ((r && r.medida && r.medida.paleta) || []).slice(0, 5));
+    if (cores.length) p.paletas = Object.fromEntries(Object.entries(pesoDasPaletas(cores)).map(([n, v]) => [n, Math.round(k(v) * 100) / 100]));
+}
+
+/* As cores dos vídeos que a pessoa trouxe inclinam a paleta do diretor (maquina-diretor.js PALETAS): cada paleta
+   ganha de 1× a 2,5× conforme o fundo e o destaque dela se parecem com alguma cor das referências. É peso: o diretor
+   só sorteia entre as paletas da metáfora, e a marca do pedido continua mandando. Puro. */
+function pesoDasPaletas(cores) {
+    const rgb = (h) => { const n = parseInt(String(h).replace('#', '').slice(0, 6), 16); return [n >> 16, (n >> 8) & 255, n & 255]; };
+    const dist = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);   // 0 a ~441
+    const viva = (c) => (Math.max(...c) - Math.min(...c)) / 255 > 0.35;           // saturação simples: o acento, não o branco nem o preto
+    const refs = cores.filter((c) => /^#[0-9a-f]{6}$/i.test(c)).map(rgb);
+    const acentos = refs.filter(viva);
+    const out = {};
+    if (!refs.length) return out;
+    const sim = (h, lista) => Math.max(0, 1 - Math.min(...lista.map((r) => dist(rgb(h), r))) / 160);   // 160: cores do mesmo grupo
+    const notas = Object.entries(require('./maquina-diretor.js').PALETAS).map(([nome, pal]) =>
+        // o destaque é o que dá a cara da paleta: pesa mais, e só contra as cores vivas da referência
+        [nome, acentos.length ? 0.35 * sim(pal.fundo, refs) + 0.65 * sim(pal.destaque, acentos) : sim(pal.fundo, refs)]);
+    /* RELATIVO, não absoluto: a referência creme e marrom da Padaria parecia com forno, limão E tijolo (1,7×, 1,7× e
+       2,15×), e em 30 vídeos o tijolo ia de 11 pra 12 — o gosto quase não aparecia. Agora a paleta mais parecida
+       ganha 2,5×, a menos parecida 1×, e as outras no meio, pela distância até elas. */
+    const vals = notas.map(([, v]) => v), min = Math.min(...vals), max = Math.max(...vals);
+    for (const [nome, v] of notas) {
+        const rel = max > min ? (v - min) / (max - min) : 0;
+        out[nome] = Math.round((1 + 1.5 * rel * rel) * 100) / 100;
+    }
+    return out;
+}
+
 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);
+    /* "letra pequena" só ia na frase pro modelo, e o sorteio da tipografia não sabia (medido em 24/10): agora puxa as de
+       letra grande e pesada e afasta as finas. O "flash" não tem troca na máquina (as de íris saíram: maquina-diretor.js);
+       ele só existe no estilo impacto, que não lê o gosto. */
+    if (nao.includes('letra_pequena')) {
+        ['poster', 'pesada'].forEach((n) => { p.tipografias[n] = (p.tipografias[n] != null ? p.tipografias[n] : 1) * 2; });
+        ['serifa_fina', 'manuscrita', 'tecnica'].forEach((n) => baixa('tipografias', n, 0.3));
+    }
 }
 
 const lista = (a) => (a.length <= 1 ? a.join('') : a.slice(0, -1).join(', ') + ' e ' + a[a.length - 1]);
 
+/** Uma frase só pros vídeos de referência: ritmo que mais aparece, média de cortes/s, quanto mexe e as cores. */
+function fraseReferencias(refs) {
+    const ms = refs.map((r) => r.medida);
+    const media = (f) => ms.reduce((s, m) => s + f(m), 0) / ms.length;
+    const ritmo = RITMOS.map((r) => [r, ms.filter((m) => m.ritmo === r).length]).sort((a, b) => b[1] - a[1])[0][0];
+    const cps = String(Math.round(media((m) => m.cortesPorSegundo) * 10) / 10).replace('.', ',');
+    const mov = media((m) => m.movimento);
+    const cores = [];
+    for (const m of ms) for (const c of m.paleta) if (!cores.includes(c) && cores.length < 3) cores.push(c);
+    // quase sem corte seco, o ritmo veio do movimento (chicote, zoom): "0 cortes/s" ao lado de "rápido" parecia erro
+    const comoCorta = media((m) => m.cortesPorSegundo) < 0.1 ? 'sem corte seco' : `${cps} cortes/s`;
+    const itens = [`ritmo ${ritmo === 'rapido' ? 'rápido' : ritmo === 'medio' ? 'médio' : 'lento'} (${comoCorta})`];
+    if (mov >= MOVIMENTO_ALTO) itens.push('muito movimento'); else if (mov < MOVIMENTO_BAIXO) itens.push('pouco movimento');
+    if (cores.length) itens.push(`cores ${lista(cores)}`);
+    return `Trouxe ${refs.length} ${refs.length === 1 ? 'vídeo' : 'vídeos'} de referência: ${itens.join(', ')}.`;
+}
+
+/** A mesma frase de fraseReferencias, pra um vídeo só: é o que a tela mostra como "Entendi: …". */
+function fraseDeUmaReferencia(medida) {
+    return fraseReferencias([{ medida: normalizarMedida(medida) }]);
+}
+
 /** 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 refs = gosto.referencias || [];
+    if (gosto.pulou && !(gosto.nao_quero || []).length && !refs.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);
@@ -181,6 +396,11 @@ function resumo(gosto) {
     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 (refs.length) partes.push(fraseReferencias(refs));
+    // o que o modelo viu, das referências mais novas: no máximo 3 frases no total
+    const vistas = [];
+    for (const r of [...refs].reverse()) for (const f of (r.descricao && r.descricao.frases) || []) if (vistas.length < 3 && !vistas.includes(f)) vistas.push(f);
+    if (vistas.length) partes.push(`O que se vê nelas: ${vistas.map((f) => `"${f}"`).join('; ')}.`);
     if (!partes.length) return '';
     partes.push('Use como direção, não como molde.');
     return partes.join(' ');
@@ -205,6 +425,13 @@ function deveAbrir(args = {}, env = process.env, home) {
     return modoTela(args, env, home) !== null;
 }
 
+/** A tela pedida pela pessoa (/referencias, /gosto refazer): no app (PRIMOCODE_APP=1) o navegador fica bloqueado,
+    então ela vai pela linha de protocolo e o app abre a janela; no terminal, pelo navegador. Resolve como abrirTela. */
+function abrirOndeDer(opcoes = {}, { env = process.env, stderr = process.stderr } = {}) {
+    if (env.PRIMOCODE_APP === '1') return abrirTela({ ...opcoes, abrir: (url) => stderr.write(linhaProtocolo(url)) });
+    return abrirTela(opcoes);
+}
+
 /** A linha que o app lê no stderr do motor. */
 const PROTOCOLO = 'primocode:abrir-gosto';
 const linhaProtocolo = (url) => `${PROTOCOLO} ${url}\n`;
@@ -239,17 +466,63 @@ function lerCorpo(req, limite = 20 * 1024) {
     });
 }
 
+const EXT_VIDEO = ['.mp4', '.mov', '.m4v', '.webm'];
+const LIMITE_VIDEO = 300 * 1024 * 1024;
+
+/** Grava o corpo cru num arquivo, em stream (sem juntar na memória), e dá o nome pelo sha1 do conteúdo. Passou do limite: apaga o parcial e lança 'grande'. */
+function gravarVideo(req, pasta, ext, limite) {
+    return new Promise((resolve, reject) => {
+        fs.mkdirSync(pasta, { recursive: true });
+        const tmp = path.join(pasta, `.parcial-${crypto.randomBytes(6).toString('hex')}`);
+        const out = fs.createWriteStream(tmp);
+        const sha = crypto.createHash('sha1');
+        let tam = 0, acabou = false;
+        const falhar = (e) => {
+            if (acabou) return;
+            acabou = true;
+            req.unpipe(out); req.resume();
+            out.destroy();
+            try { fs.unlinkSync(tmp); } catch { /* já não existe */ }
+            reject(e);
+        };
+        req.on('data', (c) => {
+            tam += c.length;
+            if (tam > limite) return falhar(new Error('grande'));
+            sha.update(c);
+        });
+        req.on('error', falhar);
+        req.on('aborted', () => falhar(new Error('cortado')));
+        out.on('error', falhar);
+        out.on('finish', () => {
+            if (acabou) return;
+            acabou = true;
+            if (!tam) { try { fs.unlinkSync(tmp); } catch { /* ok */ } return reject(new Error('vazio')); }
+            const destino = path.join(pasta, sha.digest('hex').slice(0, 12) + ext);
+            fs.renameSync(tmp, destino);
+            resolve(destino);
+        });
+        req.pipe(out);
+    });
+}
+
 /**
  * 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).
+ * `abrir(url)`, `home`, `visao` e `limiteVideo` são injetáveis (testes).
+ * `inicio`: 'carrossel' (padrão) ou 'referencias' (a página abre direto no passo de soltar vídeos).
+ * POST /referencia?nome=x.mp4 recebe o vídeo cru, mede (gosto-medir.js), pede ao modelo a descrição (gosto-descrever.js)
+ * e devolve {ok, id, nome, medida, frase, descricao?}. `descrever(arquivo, medida)` é injetável; null desliga.
+ * Se o modelo falhar, segue sem descrição: o cartão fica só com a medida.
  */
-function abrirTela({ home, abrir, timeoutMs = 10 * 60 * 1000, porta = 0 } = {}) {
+function abrirTela({ home, abrir, timeoutMs = 10 * 60 * 1000, porta = 0, inicio = 'carrossel', visao, limiteVideo = LIMITE_VIDEO, descrever } = {}) {
+    const descreverVideo = descrever === null ? null : (descrever || ((arq, medida) => require('./gosto-descrever.js').descrever(arq, medida)));
     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;
+        // os vídeos que já estão no gosto: quem abre o /referencias de novo vê o que já trouxe (só o nome)
+        const jaTem = ((ler(home) || {}).referencias || []).map((r) => String(r.nome || 'vídeo').slice(0, 80));
+        const dados = JSON.stringify({ ESTILOS, GOSTEI, NAO_QUERO, INICIO: inicio === 'referencias' ? 'referencias' : 'carrossel', JA_TEM: jaTem }).replace(/</g, '\\u003c');
+        let fim = false, timer = null, recebidos = 0;
         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)); };
@@ -258,6 +531,31 @@ function abrirTela({ home, abrir, timeoutMs = 10 * 60 * 1000, porta = 0 } = {})
                     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 === '/referencia') {
+                    if (req.headers['x-gosto-token'] !== token) return dizer(403, { ok: false, error: 'token inválido' });
+                    const nome = path.basename(String(u.searchParams.get('nome') || ''));
+                    const ext = path.extname(nome).toLowerCase();
+                    if (!EXT_VIDEO.includes(ext)) return dizer(400, { ok: false, error: `só aceito vídeo (${EXT_VIDEO.join(', ')}), e este é "${nome || 'sem nome'}"` });
+                    // a tela segura 5 de cada vez (tirar devolve a vaga lá); aqui é só o teto contra abuso: 3 trocas por vaga
+                    if (recebidos >= MAX_POR_TELA) return dizer(409, { ok: false, error: `já chegaram ${MAX_POR_TELA} vídeos nesta tela. Salve e abra /taste referencias de novo pra trazer mais` });
+                    let arq;
+                    try { arq = await gravarVideo(req, path.join(home || os.homedir(), '.primocode', 'gosto-referencias'), ext, limiteVideo); }
+                    catch (e) {
+                        if (e.message === 'grande') return dizer(413, { ok: false, error: `vídeo grande demais (o limite é ${Math.round(limiteVideo / 1048576)} MB)` });
+                        return dizer(400, { ok: false, error: e.message === 'vazio' ? 'o vídeo chegou vazio' : 'o envio foi cortado' });
+                    }
+                    recebidos++;
+                    const medida = await require('./gosto-medir.js').medir(arq, { visao });
+                    if (!medida.ok) return dizer(422, { ok: false, error: medida.error || 'não consegui ler este vídeo' });
+                    let descricao = null;
+                    if (descreverVideo) {
+                        try {
+                            const d = await Promise.race([descreverVideo(arq, medida), new Promise((r) => { const t = setTimeout(() => r(null), 90 * 1000); if (t.unref) t.unref(); })]);
+                            if (d && d.ok) descricao = normalizarDescricao(d.descricao);
+                        } catch { /* sem descrição: o cartão fica só com a medida */ }
+                    }
+                    return dizer(200, { ok: true, id: path.basename(arq, ext), nome: nome.slice(0, 80), medida, frase: fraseDeUmaReferencia(medida), ...(descricao ? { descricao } : {}) });
+                }
                 if (req.method === 'POST' && (u.pathname === '/salvar' || u.pathname === '/pular' || u.pathname === '/fechar')) {
                     if (req.headers['x-gosto-token'] !== token) return dizer(403, { ok: false, error: 'token inválido' });
                     if (u.pathname === '/fechar') {   // o app fechou a janela sem salvar: o motion segue, nada é gravado (o próximo pergunta de novo)
@@ -271,8 +569,13 @@ function abrirTela({ home, abrir, timeoutMs = 10 * 60 * 1000, porta = 0 } = {})
                     }
                     let corpo;
                     try { corpo = JSON.parse(await lerCorpo(req)); } catch { return dizer(400, { ok: false, error: 'corpo inválido (JSON até 20 KB)' }); }
+                    // modo 'referencias': junta com o gosto que já existe (o carrossel fica como estava) e guarda as 5 mais novas
+                    if (corpo && corpo.modo === 'referencias') {
+                        const antes = ler(home) || normalizar({});
+                        corpo = { ...antes, referencias: [...(antes.referencias || []), ...normalizarReferencias(corpo.referencias)].slice(-MAX_REFERENCIAS) };
+                    }
                     const g = salvar(corpo, home);
-                    dizer(200, { ok: true, resumo: resumo(g) });
+                    dizer(200, { ok: true, resumo: resumo(g), tende: inclinacao(pesos(g)) });
                     return terminar({ ok: true, gosto: g });
                 }
                 dizer(404, 'não achei', 'text/plain; charset=utf-8');
@@ -300,6 +603,6 @@ function abrirTela({ home, abrir, timeoutMs = 10 * 60 * 1000, porta = 0 } = {})
     });
 }
 
-const _teste = { texto, MAX_TEXTO, aplicarNao };
+const _teste = { texto, MAX_TEXTO, aplicarNao, pesoDasPaletas, inclinacao };
 
-module.exports = { ESTILOS, GOSTEI, NAO_QUERO, arquivo, ler, salvar, tem, normalizar, pesos, resumo, abrirTela, deveAbrir, modoTela, antesDoMotion, PROTOCOLO, linhaProtocolo, urlDaLinha, _teste };
+module.exports = { ESTILOS, GOSTEI, NAO_QUERO, arquivo, ler, salvar, tem, normalizar, pesos, resumo, adicionarReferencia, tirarReferencia, listar, abrirOndeDer, salvarEstilo, usarEstilo, estilos, nomeDoEstilo, definirForca, fraseDeUmaReferencia, abrirTela, deveAbrir, modoTela, antesDoMotion, PROTOCOLO, linhaProtocolo, urlDaLinha, _teste };

package/lib/estudio/index.js

@@ -2440,7 +2440,7 @@ async function renderHyperframes(p, args, ctx = {}) {
     if (conf.ok && conf.avisos.length) projeto.anotar(p.id, 'conferencia', conf.avisos.join('; '));
     if (ctx.abrir) { try { ctx.abrir(saida); } catch { /* o caminho está na resposta */ } }
     return { ok: true, motor: 'hyperframes', arquivo: saida, bytes, segundos: med.segundos,
-        conferencia: conf.ok ? { som: conf.som, parados: conf.parados, avisos: conf.avisos } : undefined,
+        conferencia: conf.ok ? { som: conf.som, parados: conf.parados, avisos: conf.avisos, olho: conf.olho } : undefined,
         aviso: 'ABERTO para o usuário assistir. Chame finish dizendo o que foi feito' + (conf.ok && conf.avisos.length ? ' — e cite os avisos da conferência.' : '.') };
 }
 
@@ -2564,7 +2564,7 @@ async function ferramentaRender(args, ctx = {}) {
         ok: true, arquivo: saida, bytes, segundos: conferida.duracao,
         faltaram: faltaram.length ? faltaram : undefined,
         revisao: revisao.consertos.length || revisao.avisos.length ? { consertado: revisao.consertos, avisos: revisao.avisos } : undefined,
-        conferencia: conf.ok ? { som: conf.som, parados: conf.parados, avisos: conf.avisos } : undefined,
+        conferencia: conf.ok ? { som: conf.som, parados: conf.parados, avisos: conf.avisos, olho: conf.olho } : undefined,
         aviso: 'ABERTO para o usuário assistir. Chame finish dizendo o que foi feito'
             + (revisao.avisos.length || avisosDoArquivo.length ? ' — e cite os avisos da revisão e da conferência que valem um novo plano.' : '.'),
     };