primocode 11.3.3 → 11.5.0

package/lib/plugin/estudio/motion-plano/estrutura.js

@@ -0,0 +1,111 @@
+/**
+ * estrutura.js — etapa 2 do motion: ESTRUTURAR.
+ *
+ * O briefing vira batidas na ordem gancho → virada → prova → fecho. Uma ideia por quadro; cada batida traz
+ * a frase (até 8 palavras) com a palavra-chave marcada entre *asteriscos*. A virada do briefing é obrigatória
+ * numa batida de virada. O que o modelo errar de forma mecânica (ordem, palavra-chave faltando) o código conserta.
+ */
+'use strict';
+
+const { pedirJson } = require('./llm.js');
+const Fatos = require('./fatos.js');
+
+const PAPEIS = ['gancho', 'virada', 'prova', 'fecho'];
+const MAX_PALAVRAS = 8;      // ≤ 7 por linha na régua (style.json maxWordsPerLine); a frase de um quadro cabe em 1 a 2 linhas
+const MIN_BATIDAS = 5, MAX_BATIDAS = 9;
+
+const SISTEMA = `Você estrutura o roteiro de um vídeo de motion graphics curto (vertical, 15 a 30 s) em PT-BR.
+Responda SÓ JSON: {"batidas":[{"papel":"gancho|virada|prova|fecho","ideia":"a única ideia do quadro, em 1 frase interna","frase":"o texto que aparece na tela, até ${MAX_PALAVRAS} palavras, com a palavra-chave entre *asteriscos*","palavra_chave":"a mesma palavra marcada"}]}
+Regras:
+- Ordem: começa em gancho, depois virada, depois prova (1 a 4 batidas), termina em fecho. De ${MIN_BATIDAS} a ${MAX_BATIDAS} batidas no total.
+- Uma ideia por quadro. Nunca duas ideias na mesma frase.
+- O gancho abre com a pergunta que o público faria (ou o clichê do assunto). A virada é a resposta que quebra essa expectativa, específica do assunto: use a virada do briefing, sem copiar nenhum exemplo de outro assunto. Frase de virada pode ter 1 a 3 palavras.
+- Prova: só repete o que está em "fatos" ou no pedido (data, local, o que é o negócio). NUNCA invente data, preço, endereço, nome, número, depoimento, lotação, fila, qualidade ou diferencial ("ambiente moderno", "já está cheia", "o melhor"). Se os fatos são poucos, a prova é curta e literal, só com palavras do pedido, e o resto do vídeo é gancho, virada e convite.
+- Fecho: marca/nome e chamada. Só use a marca se estiver em "fatos"; sem marca, feche com a ação do pedido, em 1 a 3 palavras.
+- Nada de frase de catálogo ("qualidade e excelência", "soluções completas", "o melhor do mercado").
+- Exatamente UMA palavra-chave por frase, entre *asteriscos*, a que carrega a ideia.`;
+
+const txt = (v, n) => String(v || '').replace(/\s+/g, ' ').trim().slice(0, n);
+const contar = (s) => String(s || '').replace(/\*/g, '').split(/\s+/).filter(Boolean).length;
+
+/** Garante 1 palavra-chave marcada na frase. Puro. */
+function marcar(frase, chave) {
+    let f = txt(frase, 120);       // mantém os asteriscos que o modelo pôs
+    const marcadas = f.match(/\*[^*]+\*/g) || [];
+    if (marcadas.length === 1) return { frase: f, chave: marcadas[0].slice(1, -1) };
+    f = f.replace(/\*/g, '');
+    const ps = f.split(' ');
+    let i = chave ? ps.findIndex((p) => p.replace(/[^\p{L}\p{N}]/gu, '').toLowerCase() === String(chave).replace(/[^\p{L}\p{N}]/gu, '').toLowerCase()) : -1;
+    if (i < 0) { let tam = 0; ps.forEach((p, k) => { const l = p.replace(/[^\p{L}\p{N}]/gu, '').length; if (l > tam) { tam = l; i = k; } }); }
+    if (i < 0) return { frase: f, chave: '' };
+    const limpo = ps[i].replace(/[.,!?;:]+$/, ''), sufixo = ps[i].slice(limpo.length);
+    ps[i] = `*${limpo}*${sufixo}`;
+    return { frase: ps.join(' '), chave: limpo };
+}
+
+/** Confere e conserta a resposta do modelo. Devolve { batidas, avisos }. Puro. */
+function normalizar(j) {
+    const avisos = [];
+    let bs = (Array.isArray(j && j.batidas) ? j.batidas : []).map((b) => {
+        const papel = PAPEIS.includes(String(b && b.papel).toLowerCase()) ? String(b.papel).toLowerCase() : null;
+        const m = marcar(b && b.frase, b && b.palavra_chave);
+        return { papel, ideia: txt(b && b.ideia, 140), frase: m.frase, palavra_chave: m.chave };
+    }).filter((b) => b.papel && b.frase);
+    // ordem: o papel nunca volta atrás (gancho, virada, prova, fecho)
+    let nivel = 0;
+    bs = bs.filter((b) => { const k = PAPEIS.indexOf(b.papel); if (k < nivel) { avisos.push(`batida "${b.frase}" fora de ordem, descartada`); return false; } nivel = k; return true; });
+    for (const b of bs) if (contar(b.frase) > MAX_PALAVRAS) { avisos.push(`frase longa (${contar(b.frase)} palavras): "${b.frase}"`); b.longa = true; }
+    return { batidas: bs, avisos };
+}
+
+/** Filtro de fatos: tira da frase o que o usuário não disse; frase que perde o sentido cai. Puro. */
+function filtrarFatos(bs, f) {
+    const barrados = [];
+    const saida = [];
+    for (const b of bs) {
+        const r = Fatos.limpar(b.frase, f);
+        r.removidos.forEach((x) => barrados.push(x));
+        if (!r.removidos.length) {
+            if (r.frase && Fatos.norm(r.frase) !== Fatos.norm(b.frase)) { const m = marcar(r.frase, b.palavra_chave); saida.push({ ...b, frase: m.frase, palavra_chave: m.chave }); }   // o fato do usuário volta inteiro, como ele disse
+            else saida.push(b);
+            continue;
+        }
+        if (!r.frase) continue;                                   // sobrou nada: a batida cai
+        const m = marcar(r.frase, b.palavra_chave);
+        saida.push({ ...b, frase: m.frase, palavra_chave: m.chave, longa: undefined });
+    }
+    return { batidas: saida, barrados };
+}
+
+/** O que impede de seguir. Puro. */
+function validar(bs, briefing) {
+    const erros = [];
+    if (bs.length < 4) erros.push(`poucas batidas (${bs.length})`);
+    if (bs.length && bs[0].papel !== 'gancho') erros.push('não abre em gancho');
+    if (bs.length && bs[bs.length - 1].papel !== 'fecho') erros.push('não fecha em fecho');
+    if (!bs.some((b) => b.papel === 'virada')) erros.push('sem virada');
+    if (!bs.some((b) => b.papel === 'prova')) erros.push('sem prova');
+    if (bs.some((b) => b.longa)) erros.push('frase com mais de ' + MAX_PALAVRAS + ' palavras');
+    void briefing;
+    return erros;
+}
+
+async function estruturar(briefing, deps = {}) {
+    const llm = deps.llm;
+    if (!llm) return { ok: false, error: 'sem modelo para estruturar.' };
+    const corpo = JSON.stringify({ objetivo: briefing.objetivo, publico: briefing.publico, tom: briefing.tom, virada: briefing.virada, fatos: briefing.fatos, pedido: briefing.pedido });
+    let msgs = [{ role: 'system', content: SISTEMA }, { role: 'user', content: `Briefing:\n${corpo}` }];
+    let r = null, erros = [];
+    const barrados = [];
+    for (let t = 0; t < 2; t++) {
+        r = normalizar(await pedirJson(llm, msgs, { temperatura: 0.7 }));
+        if (deps.fonte) { const fl = filtrarFatos(r.batidas, deps.fonte); r = { ...r, batidas: fl.batidas }; barrados.push(...fl.barrados); }
+        erros = validar(r.batidas, briefing);
+        if (!erros.length) break;
+        msgs = [...msgs, { role: 'assistant', content: JSON.stringify({ batidas: r.batidas }) }, { role: 'user', content: `Conserte: ${erros.join('; ')}.${barrados.length ? ` O código tirou fatos que o usuário não disse (${barrados.join(', ')}): não os use.` : ''} Responda o JSON inteiro de novo.` }];
+    }
+    if (erros.length) return { ok: false, error: `estrutura inválida: ${erros.join('; ')}`, batidas: r.batidas };
+    return { ok: true, batidas: r.batidas, avisos: r.avisos, barrados };
+}
+
+module.exports = { estruturar, normalizar, validar, filtrarFatos, marcar, contar, PAPEIS, MAX_PALAVRAS, SISTEMA };

package/lib/plugin/estudio/motion-plano/fatos.js

@@ -0,0 +1,137 @@
+/**
+ * fatos.js — o filtro de fatos, NO CÓDIGO (regra no prompt o modelo esquece).
+ *
+ * Número, data, mês, dia da semana, horário, preço, nome próprio, lugar, superlativo e promessa SÓ passam se
+ * estiverem no pedido do usuário ou nas respostas das perguntas. Senão a palavra cai da frase; se a frase
+ * perde o sentido, a frase inteira cai. Puro, sem rede.
+ */
+'use strict';
+
+const norm = (s) => String(s || '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[^a-z0-9]/g, '');
+const MESES = ['janeiro', 'fevereiro', 'marco', 'abril', 'maio', 'junho', 'julho', 'agosto', 'setembro', 'outubro', 'novembro', 'dezembro'];
+const SEMANA = ['segunda', 'terca', 'quarta', 'quinta', 'sexta', 'sabado', 'domingo', 'hoje', 'amanha', 'ontem'];
+const LUGAR = ['regiao', 'bairro', 'cidade', 'estado', 'pais', 'brasil', 'mundo', 'centro', 'oeste', 'sul', 'norte', 'leste', 'vizinhanca'];
+const PROMESSA = ['gratis', 'gratuito', 'gratuita', 'desconto', 'promocao', 'brinde', 'garantia', 'garantido', 'garantida', 'garantidos', 'garantidas', 'certificado', 'bonus', 'cashback', 'reais', 'vagas', 'limitadas', 'esgotando', 'ultimas'];
+const ADJETIVO = /^(modern[oa]s?|premium|sofisticad[oa]s?|elegantes?|luxo|luxuos[oa]s?|excelentes?|excelencia|qualidade|autentic[oa]s?|tradicion(?:al|ais)|ideal|ideais|diferenciad[oa]s?|inovador[a]?s?|impecavel|impecaveis|refinad[oa]s?|especial|especiais|irresistivel|irresistiveis|estilos[oa]s?|profissionais|profissional|completo|completa|completos|completas)$/;
+const SUPERLATIVO = /^(melhor|melhores|pior|maior|maiores|menor|unico|unica|unicos|lider|lideres|premiad[oa]s?|exclusiv[oa]s?|inedit[oa]s?|perfeit[oa]s?|incrivel|imbativel|referencia|top|numero1|[a-z]+issim[oa]s?)$/;
+const POSSESSIVO = new Set(['sua', 'suas', 'seu', 'seus', 'minha', 'minhas', 'meu', 'meus', 'nossa', 'nossas', 'nosso', 'nossos']);   // sobra pendurada quando o substantivo cai ("Na sua" depois de cortar "vizinhança")
+const LIGACAO = new Set(['sem', 'sobre', 'entre', 'de', 'da', 'do', 'das', 'dos', 'na', 'no', 'nas', 'nos', 'em', 'a', 'o', 'as', 'os', 'e', 'com', 'para', 'pra', 'por', 'as', 'ate', 'que', 'um', 'uma']);
+
+/** O texto que vale como fonte: pedido + respostas das perguntas. Nada que o modelo escreveu. */
+function fonte(pedido, respostas = []) {
+    const texto = [pedido, ...respostas.map((r) => (r && r.resposta) || r)].filter(Boolean).join(' ');
+    const palavras = new Set((texto.match(/[\p{L}\p{N}$%]+/gu) || []).map(norm).filter(Boolean));
+    const numeros = new Set((texto.match(/\d+/g) || []).map(String));
+    return { texto, palavras, numeros };
+}
+
+/** Quase a mesma palavra: edição de 1 letra (até 6 letras) ou 2 (7 ou mais), com a mesma primeira letra. */
+function perto(a, b) {
+    if (a[0] !== b[0] || Math.abs(a.length - b.length) > 2) return false;
+    const m = Math.min(a.length, b.length) >= 7 ? 2 : 1;
+    let d = Array.from({ length: b.length + 1 }, (_, j) => j);
+    for (let i = 1; i <= a.length; i++) { const n = [i]; for (let j = 1; j <= b.length; j++) n[j] = Math.min(d[j] + 1, n[j - 1] + 1, d[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1)); d = n; }
+    return d[b.length] <= m;
+}
+
+/** Por que a palavra não pode entrar (ou null). `inicio` = abre a frase (maiúscula ali não prova nome próprio). */
+function motivo(palavra, f, inicio) {
+    const limpa = palavra.replace(/\*/g, '');
+    const n = norm(limpa);
+    if (!n || f.palavras.has(n)) return null;
+    const dig = limpa.match(/\d+/g);
+    if (dig) return dig.every((d) => f.numeros.has(d)) ? null : 'número/horário';
+    if (MESES.includes(n)) return 'mês';
+    if (SEMANA.includes(n)) return 'data';
+    if (LUGAR.includes(n)) return 'lugar';
+    if (PROMESSA.includes(n)) return 'promessa';
+    if (SUPERLATIVO.test(n)) return 'superlativo';
+    if (ADJETIVO.test(n)) return 'adjetivo de diferencial';
+    if (!inicio && /^\p{Lu}/u.test(limpa.replace(/^[^\p{L}]+/u, '')) && n.length > 2) return 'nome próprio';
+    return null;
+}
+
+/** Palavra que carrega fato do usuário: número ou nome próprio (fora do começo do pedido). */
+const ehFato = (p) => /\d/.test(p) || /^\p{Lu}/u.test(p.replace(/^[^\p{L}\p{N}]+/u, ''));
+const PREFIXO = new Set(['dia', 'em', 'no', 'na', 'as', 'a', 'de', 'do', 'da']);
+
+/**
+ * O trecho de fato que o usuário disse vale INTEIRO e na ordem dele ("dia 30 em Chapecó"). Se a frase carrega dois ou mais
+ * fatos do usuário (30 e Chapecó) mas o trecho saiu reescrito ("30 de Chapecó"), volta o trecho exato do pedido.
+ * Só repõe o que o usuário escreveu; nunca inventa. Puro.
+ */
+function restaurar(frase, f) {
+    const ps = f.texto.split(/\s+/).filter(Boolean);
+    const fs = String(frase).split(/\s+/).filter(Boolean);
+    const nf = (p) => norm(p.replace(/\*/g, ''));
+    const pos = [];                                              // posição de cada palavra-fato da frase dentro do pedido
+    fs.forEach((p, k) => { if (ehFato(p.replace(/\*/g, '')) && !(k === 0 && !/\d/.test(p))) { const j = ps.findIndex((q) => nf(q) === nf(p)); if (j >= 0) pos.push({ k, j }); } });
+    if (pos.length < 2) return frase;
+    const a = pos[0], b = pos[pos.length - 1];
+    if (b.j <= a.j) return frase;
+    let j0 = a.j; while (j0 > 0 && a.j - j0 < 1 && PREFIXO.has(nf(ps[j0 - 1])) && !/[.!?]$/.test(ps[j0 - 1])) j0--;
+    let k0 = a.k; while (k0 > 0 && a.k - k0 < 1 && PREFIXO.has(nf(fs[k0 - 1]))) k0--;
+    const trecho = ps.slice(j0, b.j + 1).map((p) => p.replace(/[.!?,;:]+$/, ''));
+    if (trecho.length > 6 || trecho.length < 2) return frase;
+    const atual = fs.slice(k0, b.k + 1).map(nf).join('');
+    if (atual === trecho.map(nf).join('')) return frase;
+    const kwEm = fs.slice(k0, b.k + 1).some((p) => /\*/.test(p));
+    const fim = (fs[b.k].match(/[.!?,;:]+$/) || [''])[0];
+    let novo = trecho.join(' ');
+    if (kwEm) { const kw = fs.slice(k0, b.k + 1).find((p) => /\*/.test(p)).replace(/[^\p{L}\p{N}*]/gu, ''); const w = kw.replace(/\*/g, ''); novo = novo.replace(new RegExp(`(^|\\s)${w.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?=\\s|$)`), `$1*${w}*`); }
+    return [...fs.slice(0, k0), novo + fim, ...fs.slice(b.k + 1)].join(' ');
+}
+
+/**
+ * Tira da frase o que não é fato do usuário. Devolve { frase, removidos[] } ou { frase: null } se nada sobra.
+ * Os asteriscos da palavra-chave são preservados nas palavras que ficam.
+ */
+function limpar(frase, f) {
+    // erro de digitação de palavra do usuário ("Destrua" por "Destrava"): volta a palavra exata que ele escreveu
+    const doUsuario = [...new Set((f.texto || '').split(/\s+/).map((w) => w.replace(/^[^\p{L}\p{N}]+|[^\p{L}\p{N}]+$/gu, '')).filter((w) => norm(w).length >= 5))];
+    const ps = String(frase || '').split(/\s+/).filter(Boolean).map((p) => {
+        const nu = p.replace(/\*/g, ''), nn = norm(nu);
+        if (nn.length < 5 || f.palavras.has(nn) || /\d/.test(nu)) return p;
+        const u = doUsuario.find((w) => norm(w) !== nn && perto(norm(w), nn));
+        return u ? p.replace(nu.replace(/[.!?,;:]+$/, '').replace(/^[^\p{L}\p{N}]+/u, ''), u) : p;
+    });
+    const removidos = [];
+    let inicio = true;
+    const ficam = [];
+    let quebrou = false;                                           // número no meio da frase ("10 minutos por dia"): o resto perde o sentido
+    ps.forEach((p, k) => {
+        const m = motivo(p, f, inicio);
+        inicio = /[.!?]["')]*$/.test(p);
+        if (m) { removidos.push(`${p.replace(/\*/g, '')} (${m})`); if (m === 'número/horário' && k < ps.length - 1) quebrou = true; return; }
+        ficam.push(p);
+    });
+    if (quebrou) return { frase: null, removidos };
+    // duas ligações coladas depois de um corte ("dia 30 de em Chapecó"): fica a que o usuário disse, nunca uma inventada
+    if (removidos.length) {
+        const lig = (p) => LIGACAO.has(norm(p.replace(/[.!?,;:]+$/, '')));
+        for (let k = ficam.length - 2; k >= 0; k--) {
+            if (lig(ficam[k]) && lig(ficam[k + 1])) {
+                const dito = (p) => f.palavras.has(norm(p));
+                if (dito(ficam[k + 1]) || !dito(ficam[k])) ficam.splice(k, 1); else ficam.splice(k + 1, 1);
+            }
+        }
+    }
+    // sobras de ligação ("Nova na" depois de cortar "região"; "dia 30 de" depois de cortar "novembro")
+    const solta = (p) => { const n = norm(p.replace(/[.!?,;:]+$/, '')); return LIGACAO.has(n) || (removidos.length > 0 && POSSESSIVO.has(n)); };
+    while (ficam.length && solta(ficam[ficam.length - 1])) ficam.pop();
+    if (removidos.length && ficam.length) { const u = ficam.length - 1; if (!/[.!?]$/.test(ficam[u]) && /[.!?]$/.test(ps[ps.length - 1])) ficam[u] += ps[ps.length - 1].match(/[.!?]+$/)[0]; }
+    const texto = restaurar(ficam.join(' ').replace(/\*\s*\*/g, '').trim(), f);
+    if (!/\p{L}|\d/u.test(texto)) return { frase: null, removidos };
+    return { frase: texto, removidos };
+}
+
+/** Os fatos do briefing que o modelo extraiu só valem se o usuário disse. Puro. */
+function fatosDoUsuario(fatos, f) {
+    const SOLTAS = new Set(['dia', 'dias', 'hora', 'horas', 'h']);   // "dia 30" == "30": a palavra de moldura não faz o fato ser inventado
+    const ok = (v) => { const t = String(v || '').trim(); return t && (String(t).match(/[\p{L}\p{N}]+/gu) || []).map(norm).every((w) => f.palavras.has(w) || LIGACAO.has(w) || SOLTAS.has(w)); };
+    const lista = (l) => (l || []).filter(ok);
+    const o = fatos || {};
+    return { ...o, datas: lista(o.datas), nomes: lista(o.nomes), marca: ok(o.marca) ? o.marca : '', local: ok(o.local) ? o.local : '', oferta: ok(o.oferta) ? o.oferta : '', outros: lista(o.outros) };
+}
+
+module.exports = { fonte, limpar, restaurar, motivo, fatosDoUsuario, norm };

package/lib/plugin/estudio/motion-plano/index.js

@@ -0,0 +1,75 @@
+/**
+ * motion-plano/index.js — as 3 etapas na FRENTE do motor de motion (maquina.js), sem reescrevê-lo.
+ *
+ *   pedido → 1 ajustar (briefing + perguntas) → 2 estruturar (batidas) → 3 plano (cena por cena) → 4 motor (args.cenas)
+ *
+ * Desligar (caminho antigo): `etapas:false` nos argumentos do estudio_motion, ou PRIMOCODE_MOTION_ETAPAS=0.
+ * Sem modelo (sem GROQ_API_KEY) ou se uma etapa falhar, o motion segue pelo caminho antigo com um aviso,
+ * a não ser que `estrito` esteja ligado (a prova usa estrito: falhou, para e diz).
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const ligado = (args = {}) => args.etapas !== false && String(process.env.PRIMOCODE_MOTION_ETAPAS || '') !== '0' && !(Array.isArray(args.cenas) && args.cenas.length);
+
+/**
+ * @param {object} args  os argumentos do estudio_motion (assunto|pedido, formato, duracao, fotos, ...)
+ * @param {object} ctx   { escolher, linha, projectDir }
+ * @param {object} deps  { llm, pasta, estrito, fotos }
+ * @returns {Promise<{ok, args?, etapas?, passos?, error?, etapa?}>}
+ */
+async function preparar(args, ctx = {}, deps = {}) {
+    const L = require('./llm.js');
+    const llm = deps.llm || (L.disponivel() ? L.chamar : null);
+    if (!llm) return { ok: false, etapa: 0, error: 'sem modelo para as etapas (falta GROQ_API_KEY).' };
+    const pedido = String(args.pedido || args.assunto || '').trim();
+    if (pedido.length < 3) return { ok: false, etapa: 0, error: 'sem pedido.' };
+    const fotos = (Array.isArray(deps.fotos) ? deps.fotos : (Array.isArray(args.fotos) ? args.fotos : args.fotos ? [args.fotos] : [])).map(String);
+    const passos = require('./passos.js').acompanhar(ctx);
+    const falhou = (etapa, error, extra) => ({ ok: false, etapa, error, passos: passos.registro, ...extra });
+
+    passos.feito(0);
+    const a = await require('./ajustar.js').ajustarPedido(pedido, { llm, escolher: ctx.escolher, fotos }).catch((e) => ({ ok: false, error: e.message }));
+    if (!a.ok) return falhou(1, `ajustar o pedido: ${a.error}`);
+    passos.detalhe(0, `virada: ${a.briefing.virada}${a.puladas ? ` (${a.puladas} pergunta(s) puladas)` : ''}`);
+    passos.feito(1);
+
+    const Fatos = require('./fatos.js');
+    const fonte = Fatos.fonte(pedido, a.respostas || []);
+    a.briefing.fatos = Fatos.fatosDoUsuario(a.briefing.fatos, fonte);       // o que o modelo "extraiu" só vale se o usuário disse
+    const e = await require('./estrutura.js').estruturar(a.briefing, { llm, fonte }).catch((x) => ({ ok: false, error: x.message }));
+    if (!e.ok) return falhou(2, `estruturar: ${e.error}`, { briefing: a.briefing });
+    passos.detalhe(1, `${e.batidas.length} batidas (${e.batidas.map((b) => b.papel[0]).join('')})`);
+    if (e.barrados && e.barrados.length) passos.detalhe(1, `${e.batidas.length} batidas; fatos barrados: ${e.barrados.join(', ')}`);
+    passos.feito(2);
+
+    const alvo = Number(args.duracao) > 0 ? [Math.max(15, Number(args.duracao) - 3), Math.min(30, Number(args.duracao) + 3)] : [15, 30];
+    const p = await require('./plano.js').montarPlano(a.briefing, e.batidas, { llm, alvoS: alvo, fonte }).catch((x) => ({ ok: false, error: x.message }));
+    if (!p.ok) return falhou(3, `plano: ${p.error}`, { briefing: a.briefing, batidas: e.batidas, plano: p.plano });
+    const linhas = require('./passos.js').linhasDoPlano(p.plano);
+    passos.detalhe(2, `${p.plano.cenas.length} cenas, ${p.plano.total_s} s`, linhas);
+    passos.feito(3);
+
+    const motorArgs = require('./motor.js').argumentosDoMotor(p.plano, args, { fotos });
+    if (deps.pasta) {
+        try {
+            fs.mkdirSync(path.join(deps.pasta, 'motion'), { recursive: true });
+            fs.writeFileSync(path.join(deps.pasta, 'motion', 'plano.json'), JSON.stringify({ briefing: a.briefing, batidas: e.batidas, plano: p.plano, barrados: e.barrados || [], perguntas: a.perguntas, respostas: a.respostas }, null, 2));
+        } catch { /* o plano na pasta é só rastro */ }
+    }
+    return { ok: true, args: motorArgs, etapas: { briefing: a.briefing, batidas: e.batidas, plano: p.plano, barrados: e.barrados || [], perguntas: a.perguntas, respostas: a.respostas }, passos: passos.registro };
+}
+
+/** Depois do render: folha de contato + as contas mecânicas (flash branco, imagem parada). Nunca derruba o vídeo. */
+function critico(video, pasta) {
+    try {
+        const C = require('./critico.js');
+        const folha = C.folha(video, path.join(pasta, 'folha-contato.png'), { n: 8 });
+        const m = C.mecanico(video);
+        return { ok: m.ok, motivos: m.motivos, folha: folha.ok ? folha.arquivo : null };
+    } catch (e) { return { ok: null, motivos: [], erro: e.message }; }
+}
+
+module.exports = { preparar, critico, ligado };

package/lib/plugin/estudio/motion-plano/llm.js

@@ -0,0 +1,59 @@
+/**
+ * llm.js — o modelo que as etapas do motion chamam: o provedor grátis do PrimoCode (Groq, GROQ_API_KEY).
+ * A corrente segue server/lib/modelos.js (gpt-oss-120b, depois gpt-oss-20b); erro de limite/modelo troca de elo.
+ * Tudo injetável: o resto do motion-plano só recebe `llm(mensagens, opcoes) => texto`.
+ */
+'use strict';
+
+const BASE = process.env.GROQ_BASE_URL || 'https://api.groq.com/openai/v1';
+const CORRENTE = (process.env.MOTION_PLANO_MODELOS || 'openai/gpt-oss-120b,openai/gpt-oss-20b').split(',').map((s) => s.trim()).filter(Boolean);
+
+const disponivel = () => !!process.env.GROQ_API_KEY;
+
+/** Devolve o texto da resposta. Troca de modelo em 429/5xx/404; qualquer outro erro sobe. */
+async function chamar(mensagens, { json = true, temperatura = 0.6, maxTokens = 3500 } = {}) {
+    if (!disponivel()) throw new Error('sem GROQ_API_KEY');
+    let ultimo = null;
+    for (const model of CORRENTE) {
+        const corpo = { model, messages: mensagens, temperature: temperatura, max_tokens: maxTokens, reasoning_effort: 'low' };
+        if (json) corpo.response_format = { type: 'json_object' };
+        let r;
+        try {
+            r = await fetch(`${BASE}/chat/completions`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json', authorization: `Bearer ${process.env.GROQ_API_KEY}` },
+                body: JSON.stringify(corpo),
+                signal: AbortSignal.timeout(90000),
+            });
+        } catch (e) { ultimo = new Error(`${model}: ${e.message}`); continue; }
+        if (r.ok) {
+            const j = await r.json();
+            const t = String(j.choices && j.choices[0] && j.choices[0].message && j.choices[0].message.content || '');
+            if (t.trim()) return t;
+            ultimo = new Error(`${model}: resposta vazia`);
+            continue;
+        }
+        ultimo = new Error(`${model}: HTTP ${r.status} ${(await r.text()).slice(0, 160)}`);
+        if (![400, 404, 408, 429, 500, 502, 503].includes(r.status)) break;
+    }
+    throw ultimo || new Error('nenhum modelo respondeu');
+}
+
+/** Tira cerca de ``` e acha o primeiro objeto JSON da resposta. */
+function extrairJson(texto) {
+    const t = String(texto).replace(/```(?:json)?/g, '');
+    const i = t.indexOf('{'), f = t.lastIndexOf('}');
+    if (i < 0 || f < i) throw new Error('a resposta não tem JSON');
+    return JSON.parse(t.slice(i, f + 1));
+}
+
+/** Pede JSON e tenta de novo UMA vez se vier torto. */
+async function pedirJson(llm, mensagens, opcoes = {}) {
+    let erro;
+    for (let t = 0; t < 2; t++) {
+        try { return extrairJson(await llm(mensagens, { json: true, ...opcoes })); } catch (e) { erro = e; }
+    }
+    throw erro;
+}
+
+module.exports = { chamar, disponivel, extrairJson, pedirJson, CORRENTE };

package/lib/plugin/estudio/motion-plano/motor.js

@@ -0,0 +1,50 @@
+/**
+ * motor.js — etapa 4: o PLANO vira a entrada do motor atual (maquina.js, o do estudio_motion).
+ *
+ * Não mexe no motor: só traduz `plano.cenas` para o `args.cenas` que ele já entende ({papel, tipo, titulo, dur,
+ * botao, valor, foto}) e escolhe tipografia, transições e câmera pelas entradas do plano. O kit de marca
+ * (renderMotion em index.js) segue valendo: cores, fontes e logo entram como sempre.
+ */
+'use strict';
+
+const HEROI_PARA_TIPO = { tipografia: 'cinetico', foto: 'foto', numero: 'numero', cor_cheia: 'cinetico', marca: 'cta' };
+const PAPEL_PARA_PAPEL = { gancho: 'gancho', virada: 'virada', prova: 'prova', fecho: 'cta' };
+const TIPOGRAFIA_DA_ENTRADA = { 'mascara-sobe': 'poster', 'palavra-a-palavra': 'pesada', 'escala-assenta': 'poster' };
+const TRANSICAO_DA_ENTRADA = { 'zoom-atravessa': 'zoom', 'cartao-voa': 'empurra', 'cor-expande': 'abre', 'mascara-sobe': 'cortina', 'escala-assenta': 'encolhe', 'palavra-a-palavra': 'desfoque' };
+
+const MODO_DA_ENTRADA = { 'palavra-a-palavra': 'suave', 'mascara-sobe': 'mascara', 'escala-assenta': 'escala', 'zoom-atravessa': 'escala', 'cor-expande': 'escala', 'cartao-voa': 'suave' };
+const sem = (s) => String(s || '').replace(/\*/g, '');
+
+/** plano → cenas do motor. Puro. */
+function planoParaCenas(plano, { fotos = [] } = {}) {
+    const ultima = plano.cenas.length - 1;
+    return plano.cenas.map((c, i) => {
+        let tipo = HEROI_PARA_TIPO[c.heroi] || 'cinetico';
+        let valor;
+        if (c.heroi === 'numero') { const m = sem(c.texto).match(/\d[\d.,:%hH]*/); if (m) valor = m[0]; else tipo = 'cinetico'; }
+        if (tipo === 'foto' && !fotos.length) tipo = 'cinetico';
+        const cena = { papel: i === ultima ? 'cta' : (PAPEL_PARA_PAPEL[c.papel] || 'prova'), tipo: i === ultima && tipo === 'cinetico' ? 'cta' : tipo, titulo: c.texto, dur: c.duracao_s };
+        if (cena.tipo === 'cta') cena.botao = plano.marca || c.palavra_chave || sem(c.texto).split(' ')[0];
+        if (valor) { cena.valor = valor; cena.rotulo = sem(c.texto).replace(valor, '').trim() || undefined; }
+        if (cena.tipo === 'foto') cena.foto = Math.max(0, fotos.indexOf(c.foto));
+        // a peça do Destrava que o kit desenha (kit-ae/destrava.jsx): foto → cartão; cor cheia → círculo; marca → fecho; o resto → frase
+        cena.dz = c.heroi === 'foto' && cena.tipo === 'foto' ? 'foto' : c.heroi === 'cor_cheia' ? 'cor' : c.heroi === 'marca' && plano.marca ? 'marca' : (c.heroi === 'numero' && cena.tipo === 'numero' ? undefined : (c.heroi === 'foto' && cena.tipo === 'foto' ? undefined : 'frase'));
+        if (cena.dz) { cena.modo = MODO_DA_ENTRADA[c.entrada] || 'suave'; cena.tam = c.tamanho_px; }
+        return cena;
+    });
+}
+
+/** Os argumentos do estudio_motion a partir do plano. Puro. */
+function argumentosDoMotor(plano, base = {}, { fotos = [] } = {}) {
+    const entradas = plano.cenas.map((c) => c.entrada);
+    const conta = {};
+    entradas.forEach((e) => { const t = TIPOGRAFIA_DA_ENTRADA[e]; if (t) conta[t] = (conta[t] || 0) + 1; });
+    const tipografia = Object.keys(conta).sort((a, b) => conta[b] - conta[a])[0] || 'poster';
+    const transicoes = plano.cenas.slice(1).map((c) => TRANSICAO_DA_ENTRADA[c.entrada] || 'corte');
+    const { cenas: _c, ...resto } = base;
+    void _c;
+    return { ...resto, assunto: String(plano.assunto || base.assunto || '').slice(0, 160), cenas: planoParaCenas(plano, { fotos }), tipografia, transicoes, camera: base.camera || 'pulso',
+        ...(fotos.length ? { fotos } : {}), _planoDasEtapas: true };
+}
+
+module.exports = { planoParaCenas, argumentosDoMotor, HEROI_PARA_TIPO };

package/lib/plugin/estudio/motion-plano/passos.js

@@ -0,0 +1,38 @@
+/**
+ * passos.js — o "Plano atualizado" na tela: os passos das etapas com ✔ e □, do jeito do protótipo do app
+ * (docs/prototipo/primocode-desktop.html, planCell). No app/terminal chega pelo `ctx.linha` (evento 'linha');
+ * sem ele, vai pro stderr. O fluxo NÃO espera ninguém: é só mostrar.
+ */
+'use strict';
+
+const PASSOS = ['Ajustar o pedido', 'Estruturar as batidas', 'Montar o plano cena por cena', 'Fazer o motion'];
+
+/** O bloco de texto: "Plano atualizado · 2/4 feitos" + os passos + detalhes opcionais. Puro. */
+function bloco(feitos, detalhes = {}, passos = PASSOS) {
+    const n = Math.min(feitos, passos.length);
+    const linhas = [`Plano atualizado · ${n}/${passos.length} feitos`];
+    passos.forEach((p, i) => {
+        linhas.push(`  ${i < n ? '✔' : '□'} ${p}${detalhes[i] ? ` — ${detalhes[i]}` : ''}`);
+        for (const extra of (detalhes[`${i}+`] || [])) linhas.push(`      ${extra}`);
+    });
+    return linhas.join('\n');
+}
+
+/** Quem acompanha as etapas. `mostrar(texto)` padrão: ctx.linha, senão stderr. */
+function acompanhar(ctx = {}) {
+    const mostrar = ctx.linha || ((t) => process.stderr.write(t + '\n'));
+    const detalhes = {};
+    const registro = [];
+    return {
+        registro,
+        detalhe(i, texto, extras) { detalhes[i] = texto; if (extras) detalhes[`${i}+`] = extras; },
+        feito(n) { const t = bloco(n, detalhes); registro.push(t); try { mostrar(t); } catch { /* tela é só enfeite */ } return t; },
+    };
+}
+
+/** As cenas do plano em linhas curtas, para o passo 3 mostrar. Puro. */
+function linhasDoPlano(plano) {
+    return plano.cenas.map((c, i) => `${i + 1}. ${c.texto.replace(/\*/g, '')} [${c.heroi}, ${c.duracao_s} s, ${c.entrada}]`);
+}
+
+module.exports = { PASSOS, bloco, acompanhar, linhasDoPlano };

package/lib/plugin/estudio/motion-plano/pele.js

@@ -0,0 +1,36 @@
+/**
+ * pele.js — a pele PADRÃO do motion com o plano ativo: a do Destrava (creme, tinta escura, Inter 800, degradê rosa → violeta).
+ *
+ * Vale quando o pedido NÃO traz cor de marca nem estilo pedido. Kit de marca ativo, cor de marca (args.marca.cores, site lido),
+ * paleta/estilo/tipografia pedidos, ou o próprio pedido falando de cor/estilo: a pele do usuário manda e esta não entra. Puro.
+ */
+'use strict';
+
+const PELE = Object.freeze({
+    cores: Object.freeze({ fundo: '#f2efea', tinta: '#111111', destaque: '#ff4d7d', destaque2: '#7c3aed' }),
+    fontes: Object.freeze({ titulo: 'Inter-ExtraBold', texto: 'Inter-ExtraBold', destaque: 'Inter-ExtraBold' }),
+});
+
+// o pedido fala de cor ou de estilo: então a escolha é dele, não a pele padrão
+const PEDIU_ESTILO = /\b(cor(es)?|paleta|estilo|tema|visual|minimalista|neon|retr[oô]|vintage|futurista|dark|escur[oa]|claro|colorid[oa]|pastel|azul|verde|vermelh[oa]|amarel[oa]|roxo|laranja|preto|branco|rosa|dourad[oa]|marrom|cinza)\b|#[0-9a-f]{3,6}\b/i;
+
+const cheio = (v) => !!v && (Array.isArray(v) ? v.length > 0 : typeof v === 'object' ? Object.keys(v).length > 0 : true);
+
+/** A pele do Destrava entra? `kit` = o que marca-kit.preencher devolveu (kit ativo tem `.kit`). */
+function deveUsar(args = {}, kit = null) {
+    if (!args._planoDasEtapas) return false;                                  // só com o plano ativo
+    if (kit && kit.kit) return false;                                         // kit escolhido pelo usuário
+    const m = args.marca && typeof args.marca === 'object' ? args.marca : {};
+    if (cheio(m.cores) || cheio(m.fontes)) return false;                      // cor ou fonte de marca
+    if (args.paleta || args.estilo || args.estiloVisual || args.kit || args.pele) return false;
+    if (PEDIU_ESTILO.test(String(args.assunto || '') + ' ' + String(args.pedido || ''))) return false;
+    return true;
+}
+
+/** Os args com a pele do Destrava. Mantém o resto da marca (nome, logo). */
+function aplicar(args) {
+    const m = args.marca && typeof args.marca === 'object' ? args.marca : {};
+    return { ...args, pele: 'destrava', marca: { ...m, cores: { ...PELE.cores }, fontes: { ...PELE.fontes } } };
+}
+
+module.exports = { PELE, deveUsar, aplicar, PEDIU_ESTILO };