primocode 10.19.0 → 11.0.0

package/lib/entregaveis/nucleo.js

@@ -0,0 +1,111 @@
+/**
+ * nucleo.js — a parte que slides, cartaz e documento dividem.
+ *
+ *   brief → direção de arte → conferência numérica → exportação
+ *
+ * Nada aqui sabe de "slide": só cor, texto, contagem e o corredor de checagem.
+ * Cada tipo de entregável (slides.js, depois cartaz.js e documento.js) entrega
+ * ao `conferir` uma lista de REGRAS, e recebe de volta { nota, falhas }.
+ * Sem modelo, sem rede: tudo é número que dá para testar.
+ */
+'use strict';
+
+/** Palavras de um texto (hífen e apóstrofo ficam dentro da palavra). */
+function palavras(t) {
+    return (String(t || '').match(/[\p{L}\p{N}][\p{L}\p{N}'’-]*/gu) || []).length;
+}
+
+function hex(h) {
+    const m = /^#?([0-9a-f]{6}|[0-9a-f]{3})$/i.exec(String(h || '').trim());
+    if (!m) return null;
+    let s = m[1];
+    if (s.length === 3) s = s.split('').map((c) => c + c).join('');
+    return [0, 2, 4].map((i) => parseInt(s.slice(i, i + 2), 16));
+}
+
+/** Luminância relativa WCAG 2.x. */
+function luminancia(h) {
+    const rgb = hex(h);
+    if (!rgb) return null;
+    const [r, g, b] = rgb.map((v) => { v /= 255; return v <= 0.03928 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4; });
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+
+/** Razão de contraste WCAG (1 a 21). null se uma das cores não for hex. */
+function contraste(a, b) {
+    const la = luminancia(a); const lb = luminancia(b);
+    if (la == null || lb == null) return null;
+    const [claro, escuro] = la >= lb ? [la, lb] : [lb, la];
+    return (claro + 0.05) / (escuro + 0.05);
+}
+
+/** O brief mínimo: sem tema e sem público não há o que desenhar. Devolve { ok, faltam }. */
+function conferirBrief(brief) {
+    const b = brief || {};
+    const faltam = ['tema', 'publico', 'objetivo'].filter((k) => !String(b[k] || '').trim());
+    return { ok: faltam.length === 0, faltam };
+}
+
+/**
+ * Direção de arte escolhida pela IA a partir de material solto, não de modelo pronto.
+ * A direção válida tem: conceito (a ideia visual, ligada ao assunto), paleta com
+ * fundo/texto/destaque, e duas fontes. Aqui só se confere; quem escolhe é o modelo.
+ */
+function conferirDirecao(d) {
+    const falhas = [];
+    const x = d || {};
+    if (palavras(x.conceito) < 6) falhas.push({ regra: 'direcao-conceito', msg: 'conceito visual com menos de 6 palavras: diga por que este visual é DESTE assunto' });
+    const p = x.paleta || {};
+    for (const k of ['fundo', 'texto', 'destaque']) if (!hex(p[k])) falhas.push({ regra: 'direcao-paleta', msg: `paleta.${k} não é cor hex` });
+    if (!x.fonteTitulo || !x.fonteCorpo) falhas.push({ regra: 'direcao-fontes', msg: 'faltam fonteTitulo e fonteCorpo' });
+    const c = contraste(p.texto, p.fundo);
+    if (c != null && c < 4.5) falhas.push({ regra: 'contraste', msg: `texto sobre fundo: contraste ${c.toFixed(2)} < 4.5` });
+    const cd = contraste(p.destaque, p.fundo);
+    if (cd != null && cd < 3) falhas.push({ regra: 'contraste-destaque', msg: `destaque sobre fundo: contraste ${cd.toFixed(2)} < 3 (texto grande)` });
+    return falhas;
+}
+
+/**
+ * O corredor de checagem. `regras` é uma lista de { id, peso, testa(alvo) → falhas[] }.
+ * Nota = 100 menos o peso de cada regra que falhou; passa quando nenhuma regra de
+ * peso 'bloqueia' falha e a nota é >= minimo.
+ */
+function conferir(alvo, regras, { minimo = 80 } = {}) {
+    const falhas = [];
+    let nota = 100;
+    for (const r of regras) {
+        const f = r.testa(alvo) || [];
+        if (f.length) {
+            nota -= r.peso;
+            for (const item of f) falhas.push({ regra: r.id, ...item });
+        }
+    }
+    nota = Math.max(0, nota);
+    const bloqueia = regras.some((r) => r.bloqueia && falhas.some((f) => f.regra === r.id));
+    return { nota, falhas, passou: !bloqueia && nota >= minimo };
+}
+
+/** Slug de arquivo: afirmação curta vira nome seguro. */
+function slug(t) {
+    return String(t || 'entrega').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 60) || 'entrega';
+}
+
+/** O caminho do Chrome/Chromium para imprimir PDF, ou null. */
+function acharNavegador(env = process.env, existe = require('fs').existsSync) {
+    const lista = [env.PRIMO_CHROME, '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+        '/Applications/Chromium.app/Contents/MacOS/Chromium', '/usr/bin/google-chrome', '/usr/bin/chromium',
+        '/usr/bin/chromium-browser', 'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe'];
+    return lista.find((c) => c && existe(c)) || null;
+}
+
+/** HTML → PDF com o Chrome sem cabeça. Devolve { ok, erro }. */
+function htmlParaPdf(htmlPath, pdfPath, { navegador = acharNavegador() } = {}) {
+    if (!navegador) return { ok: false, erro: 'Chrome/Chromium não encontrado (defina PRIMO_CHROME)' };
+    const { spawnSync } = require('child_process');
+    const r = spawnSync(navegador, ['--headless=new', '--disable-gpu', '--no-pdf-header-footer',
+        `--print-to-pdf=${pdfPath}`, 'file://' + htmlPath], { encoding: 'utf8', timeout: 90000 });
+    return require('fs').existsSync(pdfPath) ? { ok: true } : { ok: false, erro: (r.stderr || '').slice(-300) || 'PDF não saiu' };
+}
+
+module.exports = { palavras, hex, luminancia, contraste, conferirBrief, conferirDirecao, conferir, slug, acharNavegador, htmlParaPdf };

package/lib/entregaveis/slides.js

@@ -0,0 +1,221 @@
+/**
+ * slides.js — o deck de ponta a ponta: plano → conferência numérica → .pptx + PDF.
+ *
+ * O MODELO escreve o plano (JSON): brief, direção de arte e os slides. Este
+ * arquivo NÃO escolhe cor nem texto. Ele (1) confere o plano com números,
+ * (2) desenha o mesmo plano em duas saídas: .pptx editável (pptxgenjs, MIT)
+ * e PDF (HTML → Chrome sem cabeça).
+ *
+ * Os layouts abaixo são GEOMETRIA (onde cabe o quê), não estilo: cor, fonte e
+ * conceito vêm sempre da direção que a IA escolheu para aquele assunto.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const nucleo = require('./nucleo');
+
+const LARGURA = 13.333; const ALTURA = 7.5; // polegadas, 16:9
+const PX = 144; // 13.333 pol * 144 = 1920 px
+
+/** Geometria por layout: caixas em polegadas e tamanho da letra em pt. */
+const LAYOUTS = {
+    capa: { titulo: { x: 0.8, y: 1.5, w: 11.7, h: 3.6, pt: 80 }, sub: { x: 0.8, y: 5.3, w: 11.7, h: 1.2, pt: 28 } },
+    gigante: { titulo: { x: 0.8, y: 0.9, w: 11.7, h: 3.6, pt: 66 }, corpo: { x: 0.8, y: 4.7, w: 11.7, h: 2.2, pt: 28 } },
+    numero: { numero: { x: 0.6, y: 1.0, w: 6.4, h: 4.6, pt: 190 }, titulo: { x: 7.2, y: 1.6, w: 5.5, h: 2.6, pt: 40 }, corpo: { x: 7.2, y: 4.3, w: 5.5, h: 2.4, pt: 26 } },
+    colunas: { titulo: { x: 0.8, y: 0.6, w: 11.7, h: 1.4, pt: 40 }, col1: { x: 0.8, y: 2.3, w: 5.6, h: 4.2, pt: 26 }, col2: { x: 6.9, y: 2.3, w: 5.6, h: 4.2, pt: 26 } },
+    citacao: { citacao: { x: 1.3, y: 1.4, w: 10.7, h: 3.9, pt: 44 }, autor: { x: 1.3, y: 5.6, w: 10.7, h: 0.8, pt: 24 } },
+    lista: { titulo: { x: 0.8, y: 0.6, w: 11.7, h: 1.4, pt: 44 }, corpo: { x: 0.8, y: 2.3, w: 11.7, h: 4.4, pt: 28 } },
+    divisor: { titulo: { x: 0.8, y: 2.4, w: 11.7, h: 2.4, pt: 60 } },
+    fechamento: { titulo: { x: 0.8, y: 1.2, w: 11.7, h: 3.0, pt: 64 }, acao: { x: 0.8, y: 4.8, w: 11.7, h: 1.4, pt: 34 } },
+};
+const NOMES_LAYOUT = Object.keys(LAYOUTS);
+
+/** Cabe o texto na caixa? Estimativa conservadora (0,52 em por letra, entrelinha 1,2). */
+function cabe(texto, pt, wIn, hIn) {
+    const t = String(texto || '');
+    if (!t) return true;
+    const porLinha = Math.max(1, Math.floor((wIn * 72) / (pt * 0.52)));
+    let linhas = 0;
+    for (const par of t.split('\n')) linhas += Math.max(1, Math.ceil(par.length / porLinha));
+    return linhas * pt * 1.2 / 72 <= hIn;
+}
+
+function itens(s) { return Array.isArray(s.corpo) ? s.corpo : (s.corpo ? [String(s.corpo)] : []); }
+
+function textoDoSlide(s) {
+    return [s.titulo, s.subtitulo, s.numero, s.legenda, s.citacao, s.autor, s.acao, ...itens(s)].filter(Boolean).join(' ');
+}
+
+const REGRAS = [
+    { id: 'tamanho-do-deck', peso: 10, testa: (p) => (p.slides.length < 5 || p.slides.length > 20) ? [{ msg: `${p.slides.length} slides: o deck tem de ter entre 5 e 20` }] : [] },
+    { id: 'layout-valido', peso: 10, bloqueia: true, testa: (p) => p.slides.flatMap((s, i) => NOMES_LAYOUT.includes(s.layout) ? [] : [{ slide: i + 1, msg: `layout "${s.layout}" não existe (${NOMES_LAYOUT.join(', ')})` }]) },
+    { id: 'palavras-por-slide', peso: 15, testa: (p) => p.slides.flatMap((s, i) => {
+        const max = ['capa', 'divisor', 'fechamento', 'numero', 'citacao'].includes(s.layout) ? 30 : 40;
+        const n = nucleo.palavras(textoDoSlide(s));
+        return n > max ? [{ slide: i + 1, msg: `${n} palavras (máx ${max}): corte ou divida em dois slides` }] : [];
+    }) },
+    { id: 'titulo-afirmacao', peso: 10, testa: (p) => p.slides.flatMap((s, i) => {
+        if (s.layout === 'citacao' || s.layout === 'divisor' || s.layout === 'numero') return [];
+        const n = nucleo.palavras(s.titulo);
+        return n < 3 ? [{ slide: i + 1, msg: `título com ${n} palavra(s): escreva a afirmação (3 a 12 palavras), não o tema` }]
+            : n > 12 ? [{ slide: i + 1, msg: `título com ${n} palavras (máx 12)` }] : [];
+    }) },
+    { id: 'uma-ideia', peso: 10, testa: (p) => p.slides.flatMap((s, i) => {
+        const it = itens(s); const out = [];
+        if (it.length > 4) out.push({ slide: i + 1, msg: `${it.length} itens (máx 4): uma ideia por slide` });
+        it.forEach((x) => { if (nucleo.palavras(x) > 14) out.push({ slide: i + 1, msg: `item com ${nucleo.palavras(x)} palavras (máx 14): "${String(x).slice(0, 30)}…"` }); });
+        return out;
+    }) },
+    { id: 'layout-repetido', peso: 15, testa: (p) => p.slides.flatMap((s, i) => (i && s.layout === p.slides[i - 1].layout) ? [{ slide: i + 1, msg: `layout "${s.layout}" igual ao slide anterior` }] : []) },
+    { id: 'variedade', peso: 10, testa: (p) => {
+        const n = p.slides.length; const dist = new Set(p.slides.map((s) => s.layout)).size; const meta = Math.min(4, Math.ceil(n / 2));
+        return n >= 6 && dist < meta ? [{ msg: `${dist} layouts diferentes em ${n} slides (mínimo ${meta})` }] : [];
+    } },
+    { id: 'abertura-e-fim', peso: 10, testa: (p) => {
+        const f = []; const a = p.slides[0]; const z = p.slides[p.slides.length - 1];
+        if (!a || a.layout !== 'capa') f.push({ slide: 1, msg: 'o primeiro slide tem de ser a capa' });
+        if (!z || z.layout !== 'fechamento') f.push({ slide: p.slides.length, msg: 'o último slide tem de ser o fechamento' });
+        else if (nucleo.palavras(z.acao) < 2) f.push({ slide: p.slides.length, msg: 'o fechamento precisa de uma ação (campo "acao"): o que o público faz agora' });
+        return f;
+    } },
+    { id: 'notas-do-orador', peso: 5, testa: (p) => p.slides.flatMap((s, i) => (s.layout === 'divisor' || nucleo.palavras(s.nota) >= 8) ? [] : [{ slide: i + 1, msg: 'sem nota do orador (mín 8 palavras): o texto do slide é o que se lê, a fala vai na nota' }]) },
+    { id: 'tamanho-da-letra', peso: 10, bloqueia: true, testa: (p) => {
+        const t = (p.direcao || {}).tamanhoCorpo || 28;
+        return t < 24 ? [{ msg: `corpo com ${t}pt (mín 24pt): lê-se de longe` }] : [];
+    } },
+    { id: 'encaixe', peso: 10, bloqueia: true, testa: (p) => p.slides.flatMap((s, i) => {
+        const g = LAYOUTS[s.layout]; if (!g) return [];
+        const mapa = { titulo: s.titulo, sub: s.subtitulo, numero: s.numero, citacao: s.citacao, autor: s.autor, acao: s.acao,
+            corpo: itens(s).join('\n'), col1: itens(s).filter((_, k) => k % 2 === 0).join('\n'), col2: itens(s).filter((_, k) => k % 2 === 1).join('\n') };
+        return Object.keys(g).filter((k) => mapa[k] && !cabe(mapa[k], g[k].pt, g[k].w, g[k].h))
+            .map((k) => ({ slide: i + 1, msg: `${k} não cabe na caixa (${g[k].pt}pt em ${g[k].w}x${g[k].h} pol): encurte` }));
+    }) },
+    { id: 'visual-com-motivo', peso: 10, testa: (p) => p.slides.flatMap((s, i) => (s.visual && nucleo.palavras(s.visual.motivo) < 4)
+        ? [{ slide: i + 1, msg: 'visual sem "motivo": todo elemento tem de ter a ver com o conteúdo do slide' }] : []) },
+    { id: 'direcao-de-arte', peso: 15, bloqueia: true, testa: (p) => nucleo.conferirDirecao(p.direcao).map((f) => ({ msg: f.msg })) },
+];
+
+/** Confere o plano. Devolve { nota, falhas, passou }. Plano malformado reprova sem estourar. */
+function conferirDeck(plano, opcoes) {
+    if (!plano || !Array.isArray(plano.slides) || !plano.slides.length) {
+        return { nota: 0, passou: false, falhas: [{ regra: 'plano', msg: 'plano sem slides' }] };
+    }
+    const brief = nucleo.conferirBrief(plano.brief);
+    const r = nucleo.conferir(plano, REGRAS, opcoes);
+    if (!brief.ok) { r.falhas.unshift({ regra: 'brief', msg: `brief sem: ${brief.faltam.join(', ')}` }); r.nota = Math.max(0, r.nota - 10); r.passou = false; }
+    return r;
+}
+
+/** Resumo para o agente ler e consertar: uma linha por falha. */
+function relatorio(r) {
+    const linhas = r.falhas.map((f) => `- [${f.regra}]${f.slide ? ` slide ${f.slide}:` : ''} ${f.msg}`);
+    return `nota ${r.nota}/100 — ${r.passou ? 'PASSOU' : 'REPROVADO'}${linhas.length ? '\n' + linhas.join('\n') : ''}`;
+}
+
+// ───────────────────────── .pptx editável ─────────────────────────
+
+const semHash = (c) => String(c).replace('#', '').toUpperCase();
+
+async function gerarPptx(plano, destino) {
+    const PptxGenJS = require('../../vendor/pptxgenjs/carregar.js');
+    const pptx = new PptxGenJS();
+    pptx.defineLayout({ name: 'W169', width: LARGURA, height: ALTURA });
+    pptx.layout = 'W169';
+    pptx.title = (plano.brief || {}).tema || 'Apresentação';
+    pptx.author = 'PrimoCode';
+    const d = plano.direcao; const c = d.paleta;
+    const fundo = semHash(c.fundo); const texto = semHash(c.texto); const dest = semHash(c.destaque);
+    const suave = semHash(c.suave || c.texto);
+    const T = (s, caixa, extra) => s.addText(extra.text, { x: caixa.x, y: caixa.y, w: caixa.w, h: caixa.h, fontSize: caixa.pt,
+        fontFace: extra.face || d.fonteCorpo, color: extra.color || texto, bold: !!extra.bold, italic: !!extra.italic,
+        valign: extra.valign || 'top', margin: 0, fit: 'none', align: extra.align || 'left', lineSpacingMultiple: extra.ls || 1 });
+    plano.slides.forEach((sl) => {
+        const s = pptx.addSlide();
+        s.background = { color: fundo };
+        const g = LAYOUTS[sl.layout];
+        // Cada layout carrega UM gesto visual feito só de forma + cor da direção.
+        if (sl.layout === 'capa') s.addShape('rect', { x: 0, y: 0, w: 0.35, h: ALTURA, fill: { color: dest }, line: { color: dest, width: 0 } });
+        if (sl.layout === 'gigante') s.addShape('rect', { x: 0.8, y: 0.5, w: 1.6, h: 0.12, fill: { color: dest }, line: { color: dest, width: 0 } });
+        if (sl.layout === 'numero') s.addShape('rect', { x: 7.0, y: 1.2, w: 0.06, h: 5.2, fill: { color: dest }, line: { color: dest, width: 0 } });
+        if (sl.layout === 'divisor') s.addShape('rect', { x: 0, y: 0, w: LARGURA, h: ALTURA, fill: { color: dest }, line: { color: dest, width: 0 } });
+        if (sl.layout === 'fechamento') s.addShape('rect', { x: 0.8, y: 4.55, w: 3, h: 0.1, fill: { color: dest }, line: { color: dest, width: 0 } });
+        if (sl.visual && sl.visual.imagem && fs.existsSync(sl.visual.imagem)) {
+            s.addImage({ path: sl.visual.imagem, x: 9.0, y: 4.6, w: 3.8, h: 2.6, sizing: { type: 'cover', w: 3.8, h: 2.6 } });
+        }
+        const sobreDestaque = sl.layout === 'divisor' ? { color: fundo } : {};
+        if (sl.layout === 'capa') { T(s, g.titulo, { text: sl.titulo, face: d.fonteTitulo, bold: true, color: texto, valign: 'bottom', ls: 0.9 }); if (sl.subtitulo) T(s, g.sub, { text: sl.subtitulo, color: dest }); }
+        else if (sl.layout === 'gigante') { T(s, g.titulo, { text: sl.titulo, face: d.fonteTitulo, bold: true, color: dest, ls: 0.9 }); if (itens(sl).length) T(s, g.corpo, { text: itens(sl).join('\n') }); }
+        else if (sl.layout === 'numero') { T(s, g.numero, { text: sl.numero, face: d.fonteTitulo, bold: true, color: dest, valign: 'middle' }); T(s, g.titulo, { text: sl.titulo, face: d.fonteTitulo, bold: true }); if (sl.legenda || itens(sl).length) T(s, g.corpo, { text: sl.legenda || itens(sl).join('\n'), color: suave }); }
+        else if (sl.layout === 'colunas') { T(s, g.titulo, { text: sl.titulo, face: d.fonteTitulo, bold: true }); T(s, g.col1, { text: itens(sl).filter((_, k) => k % 2 === 0).join('\n') }); T(s, g.col2, { text: itens(sl).filter((_, k) => k % 2 === 1).join('\n') }); }
+        else if (sl.layout === 'citacao') { T(s, g.citacao, { text: '“' + sl.citacao + '”', face: d.fonteTitulo, italic: true, color: dest, valign: 'middle' }); if (sl.autor) T(s, g.autor, { text: '— ' + sl.autor, color: suave }); }
+        else if (sl.layout === 'lista') { T(s, g.titulo, { text: sl.titulo, face: d.fonteTitulo, bold: true }); s.addText(itens(sl).map((t) => ({ text: t, options: { bullet: { code: '25A0', color: dest }, breakLine: true, paraSpaceAfter: 10 } })), { x: g.corpo.x, y: g.corpo.y, w: g.corpo.w, h: g.corpo.h, fontSize: g.corpo.pt, fontFace: d.fonteCorpo, color: texto, margin: 0, valign: 'top', fit: 'none' }); }
+        else if (sl.layout === 'divisor') T(s, g.titulo, { text: sl.titulo, face: d.fonteTitulo, bold: true, color: sobreDestaque.color, valign: 'middle' });
+        else if (sl.layout === 'fechamento') { T(s, g.titulo, { text: sl.titulo, face: d.fonteTitulo, bold: true, valign: 'bottom', ls: 0.9 }); T(s, g.acao, { text: sl.acao, color: dest, bold: true }); }
+        if (sl.nota) s.addNotes(sl.nota);
+    });
+    await pptx.writeFile({ fileName: destino });
+    return destino;
+}
+
+// ───────────────────────── HTML → PDF ─────────────────────────
+
+const esc = (t) => String(t == null ? '' : t).replace(/[&<>"]/g, (m) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[m]));
+const px = (pol) => Math.round(pol * PX) + 'px';
+const pt2px = (pt) => Math.round(pt * PX / 72) + 'px';
+
+function gerarHtml(plano) {
+    const d = plano.direcao; const c = d.paleta;
+    const dest2 = c.destaque2 || c.destaque;
+    const caixa = (g, extra = '') => `position:absolute;left:${px(g.x)};top:${px(g.y)};width:${px(g.w)};height:${px(g.h)};font-size:${pt2px(g.pt)};${extra}`;
+    const grad = `color:${c.destaque};`; // o degradê vai no <span> interno (ver gradiente)
+    // background-clip:text vira retângulo cheio no print-to-pdf do Chrome (visto em 29/10): título gigante sai em cor sólida; degradê de texto só via SVG (ver entregaveis-proximos.md).
+    const gradiente = `color:${c.destaque}`;
+    const fam = (f) => `'${esc(f)}',system-ui,sans-serif`;
+    const secoes = plano.slides.map((s) => {
+        const g = LAYOUTS[s.layout]; let h = '';
+        const t = (k, txt, extra = '') => {
+            if (!txt) return '';
+            const miolo = esc(txt).replace(/\n/g, '<br>');
+            return `<div style="${caixa(g[k], extra)}">${extra.includes(grad) ? `<span style="${gradiente}">${miolo}</span>` : miolo}</div>`;
+        };
+        if (s.layout === 'capa') h = `<i style="position:absolute;left:0;top:0;width:${px(0.35)};height:100%;background:${c.destaque}"></i>` + t('titulo', s.titulo, `font-family:${fam(d.fonteTitulo)};font-weight:800;line-height:.92;display:flex;align-items:flex-end;${grad}`) + t('sub', s.subtitulo, `color:${c.destaque}`);
+        else if (s.layout === 'gigante') h = `<i style="position:absolute;left:${px(0.8)};top:${px(0.5)};width:${px(1.6)};height:${px(0.12)};background:${c.destaque}"></i>` + t('titulo', s.titulo, `font-family:${fam(d.fonteTitulo)};font-weight:800;line-height:.92;${grad}`) + t('corpo', itens(s).join('\n'));
+        else if (s.layout === 'numero') h = `<i style="position:absolute;left:${px(7.0)};top:${px(1.2)};width:${px(0.06)};height:${px(5.2)};background:${c.destaque}"></i>` + t('numero', s.numero, `font-family:${fam(d.fonteTitulo)};font-weight:800;line-height:1;display:flex;align-items:center;${grad}`) + t('titulo', s.titulo, `font-family:${fam(d.fonteTitulo)};font-weight:700`) + t('corpo', s.legenda || itens(s).join('\n'), `color:${c.suave || c.texto}`);
+        else if (s.layout === 'colunas') h = t('titulo', s.titulo, `font-family:${fam(d.fonteTitulo)};font-weight:700`) + t('col1', itens(s).filter((_, k) => k % 2 === 0).join('\n')) + t('col2', itens(s).filter((_, k) => k % 2 === 1).join('\n'));
+        else if (s.layout === 'citacao') h = t('citacao', '“' + s.citacao + '”', `font-family:${fam(d.fonteTitulo)};font-style:italic;display:flex;align-items:center;color:${c.destaque}`) + t('autor', s.autor && '— ' + s.autor, `color:${c.suave || c.texto}`);
+        else if (s.layout === 'lista') h = t('titulo', s.titulo, `font-family:${fam(d.fonteTitulo)};font-weight:700`) + `<ul style="${caixa(LAYOUTS.lista.corpo, 'margin:0;padding:0;list-style:none')}">${itens(s).map((x) => `<li style="margin-bottom:${px(0.14)};padding-left:${px(0.5)};position:relative"><b style="position:absolute;left:0;color:${c.destaque}">■</b>${esc(x)}</li>`).join('')}</ul>`;
+        else if (s.layout === 'divisor') h = t('titulo', s.titulo, `font-family:${fam(d.fonteTitulo)};font-weight:800;display:flex;align-items:center;color:${c.fundo}`);
+        else if (s.layout === 'fechamento') h = `<i style="position:absolute;left:${px(0.8)};top:${px(4.55)};width:${px(3)};height:${px(0.1)};background:${c.destaque}"></i>` + t('titulo', s.titulo, `font-family:${fam(d.fonteTitulo)};font-weight:800;line-height:.92;display:flex;align-items:flex-end;${grad}`) + t('acao', s.acao, `color:${c.destaque};font-weight:700`);
+        if (s.visual && s.visual.imagem && fs.existsSync(s.visual.imagem)) {
+            const b64 = fs.readFileSync(s.visual.imagem).toString('base64');
+            const ext = path.extname(s.visual.imagem).slice(1).toLowerCase().replace('jpg', 'jpeg');
+            h += `<img alt="" src="data:image/${ext};base64,${b64}" style="position:absolute;left:${px(9)};top:${px(4.6)};width:${px(3.8)};height:${px(2.6)};object-fit:cover">`;
+        }
+        const fundo = s.layout === 'divisor' ? c.destaque : c.fundo;
+        return `<section style="background:${fundo};color:${c.texto};font-family:${fam(d.fonteCorpo)}">${h}</section>`;
+    }).join('\n');
+    return `<!doctype html><html lang="pt-BR"><head><meta charset="utf-8"><title>${esc((plano.brief || {}).tema || 'Apresentação')}</title>
+<style>@page{size:1920px 1080px;margin:0}*{box-sizing:border-box}html,body{margin:0;background:${c.fundo}}
+section{position:relative;width:1920px;height:1080px;overflow:hidden;page-break-after:always;break-after:page;-webkit-print-color-adjust:exact;print-color-adjust:exact}
+section>div{line-height:1.2}</style></head><body>\n${secoes}\n</body></html>`;
+}
+
+/**
+ * Exporta o deck: confere, escreve .pptx, .html e (se houver Chrome) .pdf.
+ * Plano reprovado não exporta, a menos que { forcar: true }.
+ */
+async function exportarDeck(plano, pasta, { forcar = false, pdf = true, nome } = {}) {
+    const resultado = conferirDeck(plano);
+    if (!resultado.passou && !forcar) return { exportado: false, conferencia: resultado, arquivos: [] };
+    fs.mkdirSync(pasta, { recursive: true });
+    const base = path.join(pasta, nome || nucleo.slug((plano.brief || {}).tema || plano.titulo));
+    const arquivos = [];
+    await gerarPptx(plano, base + '.pptx'); arquivos.push(base + '.pptx');
+    fs.writeFileSync(base + '.html', gerarHtml(plano)); arquivos.push(base + '.html');
+    let erroPdf = null;
+    if (pdf) { const r = nucleo.htmlParaPdf(base + '.html', base + '.pdf'); if (r.ok) arquivos.push(base + '.pdf'); else erroPdf = r.erro; }
+    return { exportado: true, conferencia: resultado, arquivos, erroPdf };
+}
+
+module.exports = { LAYOUTS, NOMES_LAYOUT, cabe, conferirDeck, relatorio, gerarPptx, gerarHtml, exportarDeck };

package/lib/estudio/materiais.js

@@ -0,0 +1,172 @@
+/**
+ * materiais.js — peças soltas por estilo. A IA monta o vídeo DO ZERO.
+ *
+ * Um estilo migrado tem `materiais/<estilo>/` com só peças (formas, texturas, transições, tipografia, câmera, sons),
+ * a paleta, as regras e o índice `pecas.json`. Não existe Montagem, receita nem plano pronto: a IA lista as peças,
+ * lê as que quer, escreve a cena nova (TSX) e o conferir cobra a densidade mínima.
+ *
+ *   primocode kit pecas <estilo>                 as peças (nome · o que é · params · duração)
+ *   primocode kit pecas <estilo> ver <peça>      o código da peça (ou os dados do áudio)
+ *   primocode kit pecas <estilo> regras          as regras e a densidade mínima
+ *   primocode kit pecas <estilo> escrever <nome> --arquivo <cena.tsx>   grava a cena em motion/ e confere
+ *   primocode kit pecas <estilo> conferir <cena.tsx>
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const RAIZ = path.join(__dirname, '..', '..', 'materiais');
+const CATEGORIAS = ['formas', 'texturas', 'transicoes', 'tipografia', 'camera', 'sons', 'paleta'];
+/** Nada disto pode existir como peça, nem ser lido nem importado no caminho da IA. */
+const PROIBIDO = /(^|[\\/'"._-])(Montagem|receita|plano)(\.(tsx?|jsx?|json))?(['"]|$)|Montagem\.tsx|receita\.json|plano\.json/;
+const MINIMO = { camadas: 4, pecasDiferentes: 6, chavesCamera: 4, efeitosPorCorte: 1 };
+
+const pastaDe = (estilo, raiz = RAIZ) => path.join(raiz, String(estilo || '').replace(/[^a-z0-9-]/gi, ''));
+
+/** O estilo foi migrado pra peças soltas? */
+function migrado(estilo, raiz = RAIZ) { return !!estilo && fs.existsSync(path.join(pastaDe(estilo, raiz), 'pecas.json')); }
+function estilos(raiz = RAIZ) {
+    try { return fs.readdirSync(raiz, { withFileTypes: true }).filter((d) => d.isDirectory() && migrado(d.name, raiz)).map((d) => d.name); } catch { return []; }
+}
+
+function ler(estilo, raiz = RAIZ) {
+    try { return JSON.parse(fs.readFileSync(path.join(pastaDe(estilo, raiz), 'pecas.json'), 'utf8')); } catch { return null; }
+}
+
+/** Confere o índice: campos, arquivos que existem, nenhuma peça que seja cena/vídeo pronto. Devolve a lista de erros. */
+function validar(estilo, raiz = RAIZ) {
+    const erros = [];
+    const idx = ler(estilo, raiz);
+    if (!idx) return [`materiais/${estilo}/pecas.json ausente ou inválido`];
+    const base = pastaDe(estilo, raiz);
+    if (!Array.isArray(idx.pecas) || !idx.pecas.length) return ['pecas.json sem peças'];
+    const nomes = new Set();
+    for (const p of idx.pecas) {
+        const q = `peça "${p && p.nome}"`;
+        if (!p || !p.nome || !p.categoria || !p.arquivo || !p.descricao) { erros.push(`${q}: faltam nome, categoria, arquivo ou descricao`); continue; }
+        if (nomes.has(p.nome)) erros.push(`${q}: nome repetido`);
+        nomes.add(p.nome);
+        if (!CATEGORIAS.includes(p.categoria)) erros.push(`${q}: categoria "${p.categoria}" fora de ${CATEGORIAS.join(', ')}`);
+        if (!Array.isArray(p.params)) erros.push(`${q}: params precisa ser lista`);
+        if (p.duracao != null && !(Array.isArray(p.duracao) && p.duracao.length === 2 && p.duracao[0] <= p.duracao[1])) erros.push(`${q}: duracao é null ou [min, max]`);
+        if (!Array.isArray(p.tags)) erros.push(`${q}: tags precisa ser lista`);
+        if (/\n/.test(p.descricao) || p.descricao.length > 200) erros.push(`${q}: a descrição é de uma linha (até 200 caracteres)`);
+        if (PROIBIDO.test(p.arquivo) || PROIBIDO.test(p.nome)) erros.push(`${q}: peça não pode ser Montagem, receita ou plano`);
+        const arq = path.join(base, p.arquivo);
+        if (!arq.startsWith(base + path.sep)) erros.push(`${q}: arquivo fora da pasta do estilo`);
+        else if (!fs.existsSync(arq)) erros.push(`${q}: arquivo ${p.arquivo} não existe`);
+        else if (/\.tsx?$/.test(arq) && fs.readFileSync(arq, 'utf8').split('\n').length > 140) erros.push(`${q}: arquivo grande demais pra ser uma peça (mais de 140 linhas)`);
+    }
+    for (const f of ['regras.md', 'paleta.json']) if (!fs.existsSync(path.join(base, f))) erros.push(`falta ${f}`);
+    return erros;
+}
+
+const linha = (p) => `- ${p.nome} [${p.categoria}] ${p.descricao} | params: ${(p.params || []).join(', ') || '-'} | duração: ${p.duracao ? p.duracao.join('-') + ' quadros' : 'contínua'} | tags: ${(p.tags || []).join(', ')}`;
+
+function listar(estilo, raiz = RAIZ) {
+    const idx = ler(estilo, raiz);
+    if (!idx) return { ok: false, texto: `O estilo "${estilo}" não tem peças soltas. Migrados: ${estilos(raiz).join(', ') || 'nenhum'}.` };
+    const porCat = {};
+    for (const p of idx.pecas) (porCat[p.categoria] = porCat[p.categoria] || []).push(p);
+    const out = [`# Peças de ${idx.estilo} (${idx.pecas.length}): só peças soltas, nenhuma cena pronta.`,
+        `Leia as regras (primocode kit pecas ${estilo} regras), leia as peças que vai usar (… ver <peça>), escreva a cena NOVA e grave (… escrever <nome> --arquivo <cena.tsx>).`, ''];
+    for (const c of CATEGORIAS) if (porCat[c]) out.push(`## ${c}`, ...porCat[c].map(linha), '');
+    return { ok: true, texto: out.join('\n').trim() };
+}
+
+function lerPeca(estilo, nome, raiz = RAIZ) {
+    const idx = ler(estilo, raiz);
+    const p = idx && idx.pecas.find((x) => x.nome.toLowerCase() === String(nome || '').toLowerCase());
+    if (!p) return { ok: false, texto: `Peça "${nome}" não existe em ${estilo}. Veja: primocode kit pecas ${estilo}` };
+    const arq = path.join(pastaDe(estilo, raiz), p.arquivo);
+    const cab = linha(p);
+    if (/\.(mp3|wav)$/.test(arq)) return { ok: true, texto: `${cab}\narquivo de áudio: ${p.arquivo} (toque com <Efeito som="${p.nome}" em={quadro}/> ou <Trilha/>; volume sugerido ${p.volumeSugerido ?? '-'})`, peca: p };
+    return { ok: true, texto: `${cab}\nimport: ${p.arquivo.replace(/\.tsx?$/, '')}\n\n${fs.readFileSync(arq, 'utf8')}`, peca: p };
+}
+
+function regras(estilo, raiz = RAIZ) {
+    try { return { ok: true, texto: fs.readFileSync(path.join(pastaDe(estilo, raiz), 'regras.md'), 'utf8') }; } catch { return { ok: false, texto: `Sem regras para ${estilo}.` }; }
+}
+
+/** O texto que entra no prompt da IA pra um estilo migrado (no lugar do `kit ver`). */
+function promptDoEstilo(estilo, raiz = RAIZ) {
+    const l = listar(estilo, raiz);
+    if (!l.ok) return l.texto;
+    return [`ESTILO ${estilo}: montagem a partir de peças soltas. Você COMPÕE a cena do zero; não há vídeo, receita nem plano pronto pra copiar.`,
+        'Passos: 1) leia o pedido e o roteiro; 2) escreva o plano da cena (linha do tempo em quadros, camadas, chaves de câmera, cues de som); 3) leia as peças que vai usar;',
+        '4) escreva UM arquivo TSX com a composição nova: import só do remotion e das peças, no caminho `./pecas/<categoria>/<Peça>` (ex.: `import {Agenda} from "./pecas/formas/Agenda"`, `import {e4} from "./pecas/base"`); exporte `Video` (componente) e `DURACAO` (quadros); 5) grave com `escrever`, que confere a densidade; 6) conserte o que o conferir apontar; 7) renderize.',
+        '', l.texto, '', '## regras', regras(estilo, raiz).texto].join('\n');
+}
+
+const SEM_COMENTARIO = (s) => s.replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^:])\/\/.*$/gm, '$1');
+
+/**
+ * Conferir uma cena escrita pela IA (estático, sem render). Cobra: só importa peças do estilo, nada de Montagem/receita/plano,
+ * camadas, peças diferentes, chaves de câmera, SFX em todo corte, trilha. Devolve {ok, erros, medidas}.
+ */
+function conferirCena(estilo, codigo, raiz = RAIZ) {
+    const idx = ler(estilo, raiz);
+    const erros = [];
+    if (!idx) return { ok: false, erros: [`estilo ${estilo} sem peças`], medidas: {} };
+    const src = SEM_COMENTARIO(String(codigo || ''));
+    if (PROIBIDO.test(src)) erros.push('a cena não pode usar Montagem, receita nem plano: componha as peças direto');
+    const nomes = new Set(idx.pecas.map((p) => p.nome));
+    const usadas = new Set();
+    for (const m of src.matchAll(/import\s+(?:type\s+)?(?:\{([^}]*)\}|(\w+))\s+from\s+['"]([^'"]+)['"]/g)) {
+        const de = m[3];
+        if (/^(react|remotion)(\/|$)/.test(de)) continue;
+        if (!/(^|\/)(formas|texturas|transicoes|tipografia|camera|sons)\/|(^|\/)base$|(^|\/)paleta/.test(de) && !/\.(json|mp3|svg|png|jpg)$/.test(de)) { erros.push(`import fora das peças: "${de}"`); continue; }
+        for (const n of (m[1] || m[2] || '').split(',').map((x) => x.trim().split(/\s+as\s+/)[0]).filter(Boolean)) if (nomes.has(n)) usadas.add(n);
+    }
+    const cenas = (src.match(/<Cena\b/g) || []).length;
+    const cortes = Math.max(0, cenas - 1);
+    const efeitos = (src.match(/<Efeito\b/g) || []).length;
+    const chaves = (src.match(/\{\s*em\s*:/g) || []).length;
+    const camadasPorCena = cenas ? Math.round(([...usadas].filter((n) => !['Cena', 'Camera', 'Som'].includes(n)).length)) : 0;
+    const medidas = { cenas, cortes, efeitos, chavesCamera: chaves, pecasDiferentes: usadas.size, camadas: camadasPorCena };
+    if (!/<Camera\b/.test(src)) erros.push('falta <Camera> (a câmera nunca para)');
+    if (!/<Trilha\b/.test(src)) erros.push('falta <Trilha> (trilha forte sempre)');
+    if (cenas < 2) erros.push('use ao menos 2 <Cena> (um vídeo é uma sequência de cenas)');
+    if (usadas.size < MINIMO.pecasDiferentes) erros.push(`só ${usadas.size} peças diferentes; mínimo ${MINIMO.pecasDiferentes}`);
+    if (camadasPorCena < MINIMO.camadas) erros.push(`só ${camadasPorCena} tipos de camada; mínimo ${MINIMO.camadas} (fundo, partículas, herói, apoio)`);
+    if (chaves < MINIMO.chavesCamera) erros.push(`só ${chaves} chaves de câmera; mínimo ${MINIMO.chavesCamera}`);
+    if (efeitos < cortes * MINIMO.efeitosPorCorte) erros.push(`${efeitos} <Efeito> para ${cortes} cortes: SFX em todo corte (alvo 2 por corte)`);
+    return { ok: !erros.length, erros, medidas };
+}
+
+/** Grava a cena em <pasta>/motion/<nome>.tsx (com as peças ao lado, em motion/pecas/) e confere. */
+function escreverCena(estilo, pasta, nome, codigo, raiz = RAIZ) {
+    const slug = String(nome || '').toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/^-+|-+$/g, '');
+    if (!slug) return { ok: false, texto: 'Dê um nome à cena: … escrever <nome> --arquivo <cena.tsx>' };
+    const c = conferirCena(estilo, codigo, raiz);
+    const proibido = c.erros.some((e) => /Montagem|receita|plano|import fora/.test(e));
+    if (proibido) return { ok: false, texto: `Cena recusada:\n- ${c.erros.join('\n- ')}`, ...c };
+    const dir = path.join(pasta, 'motion');
+    fs.mkdirSync(dir, { recursive: true });
+    const arq = path.join(dir, `${slug}.tsx`);
+    fs.writeFileSync(arq, codigo);
+    const texto = c.ok ? `Cena gravada em ${arq}. Conferida: ${JSON.stringify(c.medidas)}.`
+        : `Cena gravada em ${arq}, mas NÃO passou no conferir; conserte e grave de novo:\n- ${c.erros.join('\n- ')}`;
+    return { ok: true, passou: c.ok, texto, arquivo: arq, ...c };
+}
+
+/** Copia as peças do estilo pra <dir>/pecas e escreve a entrada do render que registra a cena da IA. */
+function prepararRender(estilo, dir, arqCena, { duracao, raiz = RAIZ } = {}) {
+    fs.mkdirSync(dir, { recursive: true });
+    const alvo = path.join(dir, 'pecas');
+    fs.rmSync(alvo, { recursive: true, force: true });
+    fs.cpSync(pastaDe(estilo, raiz), alvo, { recursive: true });
+    fs.copyFileSync(arqCena, path.join(dir, 'Cena-ia.tsx'));
+    fs.writeFileSync(path.join(dir, 'entrada.tsx'), `// gerado por lib/estudio/materiais.js
+import React from 'react';
+import {Composition, registerRoot} from 'remotion';
+import {Video, DURACAO} from './Cena-ia';
+const Raiz: React.FC = () => <Composition id="Video" component={Video as React.FC} durationInFrames={${duracao || 'DURACAO'}} fps={30} width={1080} height={1920} />;
+registerRoot(Raiz);
+`);
+    return { dir, entrada: path.join(dir, 'entrada.tsx') };
+}
+
+module.exports = { RAIZ, CATEGORIAS, MINIMO, PROIBIDO, migrado, estilos, ler, validar, listar, lerPeca, regras, promptDoEstilo, conferirCena, escreverCena, prepararRender };

package/lib/fundo.js

@@ -64,6 +64,38 @@ function anexar(t, pedaco) {
     if (t.log) { try { fs.writeSync(t.log, pedaco); } catch { /* disco cheio: o buffer ainda serve */ } }
 }
 
+/* ── AVISO DE FIM ─────────────────────────────────────────────────────────
+ * Quando uma tarefa acaba SOZINHA (não foi o agente que mandou parar), o aviso entra numa fila. O loop do agente
+ * esvazia a fila a cada volta (pegarAvisos) e põe o texto na conversa; a tela mostra uma linha; no macOS sai
+ * também uma notificação do sistema. PRIMOCODE_SEM_NOTIFICACAO=1 desliga só a do sistema. */
+const avisos = [];
+const ouvintes = new Set();
+function aoTerminar(fn) { ouvintes.add(fn); return () => ouvintes.delete(fn); }
+function pegarAvisos() { return avisos.splice(0, avisos.length); }
+
+function notificarSistema(titulo, texto) {
+    if (process.platform !== 'darwin' || process.env.PRIMOCODE_SEM_NOTIFICACAO === '1') return false;
+    try {
+        const p = spawn('osascript', ['-e', 'on run argv\ndisplay notification (item 2 of argv) with title (item 1 of argv)\nend run', String(titulo).slice(0, 80), String(texto).slice(0, 200)],
+            { stdio: 'ignore', detached: true });
+        p.on('error', () => {}); p.unref();
+        return true;
+    } catch { return false; }
+}
+
+function avisarFim(t) {
+    if (t.pedidoParar) return;
+    const cauda = t.buffer.split('\n').filter(Boolean).slice(-6).join('\n').slice(-600);
+    const ok = t.codigo === 0;
+    const curto = t.comando.length > 60 ? t.comando.slice(0, 57) + '…' : t.comando;
+    const texto = `[aviso do sistema] A tarefa em segundo plano ${t.id} (${curto}) terminou ${ok ? 'com sucesso' : `com erro (código ${t.codigo ?? t.sinal})`}.`
+        + (cauda ? `\nFim da saída:\n${cauda}` : '') + `\nLeia tudo com background_output id:"${t.id}" se precisar.`;
+    const aviso = { id: t.id, comando: t.comando, ok, codigo: t.codigo, texto };
+    avisos.push(aviso);
+    for (const f of ouvintes) { try { f(aviso); } catch { /* ouvinte não derruba */ } }
+    notificarSistema(ok ? 'PrimoCode: tarefa terminou' : 'PrimoCode: tarefa falhou', `${curto}${ok ? '' : ` (código ${t.codigo})`}`);
+}
+
 function iniciar(comando, { projectDir, env } = {}) {
     const cmd = String(comando || '').trim();
     if (!cmd) return { ok: false, error: 'Comando vazio.' };
@@ -101,6 +133,7 @@ function iniciar(comando, { projectDir, env } = {}) {
     // 'close' (e não 'exit'): só dispara depois de a saída ser toda lida.
     filho.on('close', (codigo, sinal) => {
         t.rodando = false; t.codigo = codigo; t.sinal = sinal || null; t.terminou = Date.now(); fechaLog();
+        avisarFim(t);
     });
     tarefas.set(id, t);
     ligarSinais();
@@ -196,4 +229,4 @@ function linhasRodape(lista, c) {
     return linhas;
 }
 
-module.exports = { iniciar, saida, parar, pararTodas, listar, endereco, linhasRodape, TETO_BUFFER, TETO_LEITURA };
+module.exports = { aoTerminar, pegarAvisos, avisarFim, iniciar, saida, parar, pararTodas, listar, endereco, linhasRodape, TETO_BUFFER, TETO_LEITURA };