primocode 11.0.0 → 11.2.0

package/lib/plugin/entregaveis/carrossel.js

@@ -0,0 +1,93 @@
+/**
+ * carrossel.js — carrossel de rede social (1080x1350), reaproveitando o cartaz.
+ *
+ * Plano: { brief, direcao, formato?:'1080x1350', margem?, slides:[{ tipo:'capa'|'conteudo'|'cta', titulo, corpo?, acao? }] }
+ * Cada slide é um cartaz: UM herói (o título), apoio curto, e o último fecha com o CTA em botão.
+ * Saída: .html, .pdf (uma página por slide) e um .png por slide.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const nucleo = require('./nucleo');
+const cartaz = require('./cartaz');
+
+const TIPOS = ['capa', 'conteudo', 'cta'];
+const corpoDe = (s) => (Array.isArray(s.corpo) ? s.corpo : (s.corpo ? [String(s.corpo)] : []));
+
+/** Cada slide vira um plano de cartaz (herói = título; CTA = ação do último, ou o "arrasta" nos outros). */
+function comoCartaz(plano, s, i, n) {
+    return { direcao: plano.direcao, formato: plano.formato || '1080x1350', margem: plano.margem, heroi: s.titulo, apoio: corpoDe(s),
+        cta: s.tipo === 'cta' ? s.acao : (i < n - 1 ? 'Arraste para o lado' : ''), visual: s.visual };
+}
+
+const REGRAS = [
+    { id: 'formato', peso: 10, bloqueia: true, testa: (p) => cartaz.FORMATOS[p.formato || '1080x1350'] ? [] : [{ msg: `formato "${p.formato}" não existe` }] },
+    { id: 'tamanho-do-carrossel', peso: 10, testa: (p) => (p.slides.length < 5 || p.slides.length > 10) ? [{ msg: `${p.slides.length} slides: o carrossel tem de ter entre 5 e 10` }] : [] },
+    { id: 'tipo-valido', peso: 10, bloqueia: true, testa: (p) => p.slides.flatMap((s, i) => TIPOS.includes(s.tipo) ? [] : [{ slide: i + 1, msg: `tipo "${s.tipo}" não existe (${TIPOS.join(', ')})` }]) },
+    { 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.tipo !== 'capa') f.push({ slide: 1, msg: 'o primeiro slide tem de ser a capa' });
+        if (!z || z.tipo !== 'cta') f.push({ slide: p.slides.length, msg: 'o último slide tem de ser o de ação (tipo "cta")' });
+        else if (nucleo.palavras(z.acao) < 2) f.push({ slide: p.slides.length, msg: 'o slide de ação precisa do campo "acao" com 2+ palavras' });
+        return f;
+    } },
+    { id: 'hierarquia', peso: 15, bloqueia: true, testa: (p) => p.slides.flatMap((s, i) => {
+        const n = nucleo.palavras(s.titulo);
+        if (n < 2 || n > 12) return [{ slide: i + 1, msg: `título com ${n} palavra(s): escreva a afirmação (2 a 12 palavras)` }];
+        const g = cartaz.geometria(comoCartaz(p, s, i, p.slides.length)); if (!g) return [];
+        return g.tamHeroi / g.h < 0.03 ? [{ slide: i + 1, msg: `a letra do título cabe em ${(g.tamHeroi / g.h * 100).toFixed(1)}% da altura (mín 3%): encurte` }] : [];
+    }) },
+    { id: 'palavras-por-slide', peso: 15, testa: (p) => p.slides.flatMap((s, i) => {
+        const n = nucleo.palavras([s.titulo, ...corpoDe(s)].join(' '));
+        return n > 25 ? [{ slide: i + 1, msg: `${n} palavras fora o CTA (máx 25): uma ideia por slide` }] : [];
+    }) },
+    { id: 'encaixe', peso: 10, bloqueia: true, testa: (p) => p.slides.flatMap((s, i) => {
+        if (!corpoDe(s).length) return [];
+        const g = cartaz.geometria(comoCartaz(p, s, i, p.slides.length));
+        return g && g.tamApoio / g.h < 0.022 ? [{ slide: i + 1, msg: 'o apoio não cabe com letra legível (mín 2,2% da altura): corte' }] : [];
+    }) },
+    { id: 'cta', peso: 10, bloqueia: true, testa: (p) => {
+        const c = nucleo.contraste((p.direcao.paleta || {}).destaque, (p.direcao.paleta || {}).fundo);
+        return c != null && c < 4.5 ? [{ msg: `botão (destaque sobre fundo): contraste ${c.toFixed(2)} < 4.5` }] : [];
+    } },
+    { id: 'margem', peso: 5, testa: (p) => (typeof p.margem === 'number' && p.margem < 0.05) ? [{ msg: `margem de ${(p.margem * 100).toFixed(1)}% (mín 5%)` }] : [] },
+    { 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' }] : []) },
+    { id: 'direcao-de-arte', peso: 15, bloqueia: true, testa: (p) => nucleo.conferirDirecao(p.direcao).map((f) => ({ msg: f.msg })) },
+];
+
+function conferirCarrossel(plano, opcoes) {
+    return nucleo.conferirPlano(plano, REGRAS, opcoes, { exige: 'slides', vazio: 'plano sem slides' });
+}
+
+function gerarHtmlCarrossel(plano) {
+    const n = plano.slides.length; const f = cartaz.FORMATOS[plano.formato || '1080x1350'];
+    const c = plano.direcao.paleta;
+    const secoes = plano.slides.map((s, i) => {
+        const cp = comoCartaz(plano, s, i, n);
+        const g = cartaz.geometria(cp);
+        let html = cartaz.pagina(cp, g);
+        // contador discreto no canto: "2/7" (mesma cor suave; não compete com o herói)
+        const tam = Math.round(f.h * 0.022);
+        const contador = `<div style="right:${g.m}px;top:${g.m - 4}px;font:600 ${tam}px/1 '${nucleo.escX(plano.direcao.fonteCorpo)}',system-ui,sans-serif;color:${c.suave || c.texto}">${i + 1}/${n}</div>`;
+        html = html.replace('</section>', contador + '</section>');
+        return html;
+    });
+    return nucleo.htmlDePaginas({ titulo: (plano.brief || {}).tema || 'Carrossel', direcao: plano.direcao, w: f.w, h: f.h, secoes });
+}
+
+async function exportarCarrossel(plano, pasta, { forcar = false, pdf = true, png = true, nome } = {}) {
+    const conferencia = conferirCarrossel(plano);
+    if (!conferencia.passou && !forcar) return { exportado: false, conferencia, arquivos: [] };
+    const f = cartaz.FORMATOS[plano.formato || '1080x1350'];
+    fs.mkdirSync(pasta, { recursive: true });
+    const base = path.join(pasta, nome || nucleo.slug((plano.brief || {}).tema || plano.titulo));
+    const arquivos = []; const erros = [];
+    fs.writeFileSync(base + '.html', gerarHtmlCarrossel(plano)); arquivos.push(base + '.html');
+    if (pdf) { const r = nucleo.htmlParaPdf(base + '.html', base + '.pdf'); if (r.ok) arquivos.push(base + '.pdf'); else erros.push(r.erro); }
+    if (png) { const r = nucleo.htmlParaPngs(base + '.html', base, plano.slides.length, f.w, f.h, { escala: 1 }); arquivos.push(...r.arquivos); if (r.erro) erros.push(r.erro); }
+    return { exportado: true, conferencia, arquivos, erroPdf: erros.join('; ') || null };
+}
+
+module.exports = { TIPOS, REGRAS, conferirCarrossel, relatorio: nucleo.relatorio, gerarHtmlCarrossel, exportarCarrossel };

package/lib/plugin/entregaveis/cartaz.js

@@ -0,0 +1,112 @@
+/**
+ * cartaz.js — flyer / cartaz de ponta a ponta: plano → conferência numérica → HTML + PDF + PNG.
+ *
+ * Mesmo núcleo do deck (nucleo.js). O MODELO escreve o plano; aqui só se confere e se desenha.
+ * Plano: { brief, direcao, formato: 'A4'|'1080x1350', heroi, apoio:[], cta, margem?, visual? }
+ *   heroi  = o texto que se lê a 1 m (string ou { texto })
+ *   cta    = a ação (string ou { texto }), vira botão em cor de destaque
+ *   visual = { imagem?, motivo } — todo elemento extra diz o que tem a ver com o assunto
+ * A geometria é fração da peça (onde cabe o quê); cor, fonte e conceito vêm da direção da IA.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const nucleo = require('./nucleo');
+
+const FORMATOS = { A4: { w: 793, h: 1122, escala: 3 }, '1080x1350': { w: 1080, h: 1350, escala: 1 } };
+const txt = (x) => (x && typeof x === 'object' ? x.texto : x) || '';
+const heroisDe = (p) => (Array.isArray(p.heroi) ? p.heroi : (txt(p.heroi) ? [p.heroi] : []));
+const apoioDe = (p) => (Array.isArray(p.apoio) ? p.apoio.map(txt).filter(Boolean) : []);
+const margemDe = (p) => (typeof p.margem === 'number' ? p.margem : 0.06);
+
+/** A geometria do cartaz em px, para a conferência e o desenho usarem os MESMOS números. */
+function geometria(plano) {
+    const f = FORMATOS[plano.formato]; if (!f) return null;
+    const m = Math.round(f.w * margemDe(plano));
+    const temImg = !!(plano.visual && plano.visual.imagem && fs.existsSync(plano.visual.imagem));
+    const larg = f.w - 2 * m;
+    const heroi = { x: m, y: Math.round(f.h * 0.14), w: larg, h: Math.round(f.h * 0.44) };
+    const apoio = { x: m, y: Math.round(f.h * 0.62), w: temImg ? Math.round(larg * 0.6) : larg, h: Math.round(f.h * 0.2) };
+    const cta = { x: m, h: Math.round(f.h * 0.075), y: f.h - m - Math.round(f.h * 0.075) };
+    const img = temImg ? { x: f.w - m - Math.round(larg * 0.34), y: apoio.y, w: Math.round(larg * 0.34), h: apoio.h } : null;
+    const tamHeroi = nucleo.ajustarTamanho(txt(heroisDe(plano)[0]), heroi.w, heroi.h, f.h * 0.13, { entrelinha: 0.95 });
+    const tamApoio = nucleo.ajustarTamanho(apoioDe(plano).join('\n'), apoio.w, apoio.h, f.h * 0.032, { entrelinha: 1.35 });
+    return { ...f, m, heroi, apoio, cta, img, tamHeroi, tamApoio, tamCta: Math.round(f.h * 0.03) };
+}
+
+const REGRAS = [
+    { id: 'formato', peso: 10, bloqueia: true, testa: (p) => FORMATOS[p.formato] ? [] : [{ msg: `formato "${p.formato}" não existe (${Object.keys(FORMATOS).join(', ')})` }] },
+    { id: 'hierarquia', peso: 20, bloqueia: true, testa: (p) => {
+        const n = heroisDe(p).length;
+        if (n !== 1) return [{ msg: `${n} elementos herói: tem de ser exatamente 1 (o que se lê a 1 m)` }];
+        const g = geometria(p); if (!g) return [];
+        const frac = g.tamHeroi / g.h;
+        return frac < 0.03 ? [{ msg: `a letra do herói cabe em ${(frac * 100).toFixed(1)}% da altura (mín 3%): encurte o herói` }] : [];
+    } },
+    { id: 'cta', peso: 15, bloqueia: true, testa: (p) => {
+        const f = [];
+        if (nucleo.palavras(txt(p.cta)) < 2) f.push({ msg: 'cta com menos de 2 palavras: diga a ação ("Garanta sua vaga hoje")' });
+        const c = nucleo.contraste((p.direcao.paleta || {}).destaque, (p.direcao.paleta || {}).fundo);
+        if (c != null && c < 4.5) f.push({ msg: `botão do CTA (destaque sobre fundo): contraste ${c.toFixed(2)} < 4.5` });
+        return f;
+    } },
+    { id: 'palavras', peso: 15, testa: (p) => {
+        const n = nucleo.palavras([txt(heroisDe(p)[0]), ...apoioDe(p)].join(' '));
+        return n > 25 ? [{ msg: `${n} palavras fora o CTA (máx 25): cartaz se lê de relance` }] : [];
+    } },
+    { id: 'margem', peso: 10, testa: (p) => margemDe(p) < 0.05 ? [{ msg: `margem de ${(margemDe(p) * 100).toFixed(1)}% (mín 5%)` }] : [] },
+    { id: 'encaixe', peso: 10, bloqueia: true, testa: (p) => {
+        const g = geometria(p); if (!g || !apoioDe(p).length) return [];
+        return g.tamApoio / g.h < 0.022 ? [{ msg: 'o apoio não cabe com letra legível (mín 2,2% da altura): corte' }] : [];
+    } },
+    { id: 'visual-com-motivo', peso: 10, testa: (p) => (p.visual && nucleo.palavras(p.visual.motivo) < 4)
+        ? [{ msg: 'visual sem "motivo": todo elemento tem de ter a ver com o assunto' }] : [] },
+    { id: 'direcao-de-arte', peso: 15, bloqueia: true, testa: (p) => nucleo.conferirDirecao(p.direcao).map((f) => ({ msg: f.msg })) },
+];
+
+function conferirCartaz(plano, opcoes) {
+    return nucleo.conferirPlano(plano, REGRAS, opcoes, { exige: 'heroi', vazio: 'plano sem heroi' });
+}
+
+/** O HTML de UMA página de cartaz (usado também pelo carrossel via `pagina`). */
+function pagina(plano, g) {
+    const d = plano.direcao; const c = d.paleta;
+    const esc = nucleo.escX;
+    const famT = `'${esc(d.fonteTitulo)}',system-ui,sans-serif`;
+    const caixa = (b) => `left:${b.x}px;top:${b.y}px;width:${b.w}px;height:${b.h}px`;
+    const comGrad = c.destaque2 && c.destaque2.toLowerCase() !== c.destaque.toLowerCase();
+    const heroiTxt = txt(heroisDe(plano)[0]);
+    const heroiHtml = comGrad
+        ? `<div style="${caixa(g.heroi)}">${nucleo.tituloGradiente(heroiTxt, g.heroi.w, g.heroi.h, { familia: d.fonteTitulo, peso: 800, tam: g.tamHeroi, entrelinha: 0.95, cor1: c.destaque, cor2: c.destaque2 })}</div>`
+        : `<div style="${caixa(g.heroi)};font:800 ${g.tamHeroi}px/0.95 ${famT};color:${c.destaque}">${esc(heroiTxt)}</div>`;
+    const apoio = apoioDe(plano);
+    const apoioHtml = apoio.length ? `<div style="${caixa(g.apoio)};font-size:${g.tamApoio}px;line-height:1.35;color:${c.suave || c.texto}">${apoio.map((a) => `<p style="margin:0 0 ${Math.round(g.tamApoio * 0.4)}px">${esc(a)}</p>`).join('')}</div>` : '';
+    const imgHtml = g.img ? `<img alt="" src="data:image/${path.extname(plano.visual.imagem).slice(1).toLowerCase().replace('jpg', 'jpeg')};base64,${fs.readFileSync(plano.visual.imagem).toString('base64')}" style="${caixa(g.img)};object-fit:cover">` : '';
+    const ctaW = Math.min(g.w - 2 * g.m, Math.round(nucleo.palavras(txt(plano.cta)) * g.tamCta * 0.56 * 5.2 + g.tamCta * 2.4));
+    const ctaHtml = !txt(plano.cta) ? '' : `<div style="left:${g.cta.x}px;top:${g.cta.y}px;width:${ctaW}px;height:${g.cta.h}px;background:${c.destaque};color:${c.fundo};font:800 ${g.tamCta}px/${g.cta.h}px ${famT};text-align:center;border-radius:${Math.round(g.cta.h * 0.14)}px;white-space:nowrap">${esc(txt(plano.cta))}</div>`;
+    const barra = `<i style="left:${g.m}px;top:${g.m}px;width:${Math.round(g.w * 0.18)}px;height:${Math.max(6, Math.round(g.h * 0.012))}px;background:${c.destaque}"></i>`;
+    return `<section>${barra}${heroiHtml}${apoioHtml}${imgHtml}${ctaHtml}</section>`;
+}
+
+function gerarHtmlCartaz(plano) {
+    const g = geometria(plano);
+    return nucleo.htmlDePaginas({ titulo: (plano.brief || {}).tema || 'Cartaz', direcao: plano.direcao, w: g.w, h: g.h, secoes: [pagina(plano, g)] });
+}
+
+/** Exporta: confere, escreve .html, .pdf e .png. Reprovado não exporta, a menos que { forcar: true }. */
+async function exportarCartaz(plano, pasta, { forcar = false, pdf = true, png = true, nome } = {}) {
+    const conferencia = conferirCartaz(plano);
+    if (!conferencia.passou && !forcar) return { exportado: false, conferencia, arquivos: [] };
+    const g = geometria(plano);
+    if (!g) return { exportado: false, conferencia, arquivos: [] };
+    fs.mkdirSync(pasta, { recursive: true });
+    const base = path.join(pasta, nome || nucleo.slug((plano.brief || {}).tema || plano.titulo));
+    const arquivos = []; const erros = [];
+    fs.writeFileSync(base + '.html', gerarHtmlCartaz(plano)); arquivos.push(base + '.html');
+    if (pdf) { const r = nucleo.htmlParaPdf(base + '.html', base + '.pdf'); if (r.ok) arquivos.push(base + '.pdf'); else erros.push(r.erro); }
+    if (png) { const r = nucleo.htmlParaPngs(base + '.html', base, 1, g.w, g.h, { escala: g.escala }); arquivos.push(...r.arquivos); if (r.erro) erros.push(r.erro); }
+    return { exportado: true, conferencia, arquivos, erroPdf: erros.join('; ') || null };
+}
+
+module.exports = { FORMATOS, REGRAS, geometria, pagina, txt, margemDe, conferirCartaz, relatorio: nucleo.relatorio, gerarHtmlCartaz, exportarCartaz };

package/lib/plugin/entregaveis/cli.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+/**
+ * cli.js — a linha de comando que as skills e os especialistas chamam.
+ *   node lib/plugin/entregaveis/cli.js [tipo] conferir|exportar plano.json [pasta] [--forcar] [--sem-pdf] [--sem-png]
+ * tipo: slides (padrão, e o único que dispensa o nome) · cartaz · carrossel · documento
+ * Sai com 1 se a conferência reprova (ou se não exportou).
+ */
+'use strict';
+const fs = require('fs');
+const path = require('path');
+
+const TIPOS = {
+    slides: () => { const m = require('./slides'); return { conferir: m.conferirDeck, relatorio: m.relatorio, exportar: m.exportarDeck }; },
+    cartaz: () => { const m = require('./cartaz'); return { conferir: m.conferirCartaz, relatorio: m.relatorio, exportar: m.exportarCartaz }; },
+    carrossel: () => { const m = require('./carrossel'); return { conferir: m.conferirCarrossel, relatorio: m.relatorio, exportar: m.exportarCarrossel }; },
+    documento: () => { const m = require('./documento'); return { conferir: m.conferirDocumento, relatorio: m.relatorio, exportar: m.exportarDocumento }; },
+};
+const USO = 'uso: cli.js [slides|cartaz|carrossel|documento] conferir|exportar plano.json [pasta] [--forcar] [--sem-pdf] [--sem-png]';
+
+async function main(argv) {
+    const args = argv.filter((a) => !a.startsWith('--'));
+    const tipo = TIPOS[args[0]] ? args.shift() : 'slides';
+    const [cmd, arq, pasta] = args;
+    if (!['conferir', 'exportar'].includes(cmd) || !arq) { console.error(USO); return 2; }
+    let plano;
+    try { plano = JSON.parse(fs.readFileSync(arq, 'utf8')); } catch (e) { console.error('plano ilegível: ' + e.message); return 2; }
+    const t = TIPOS[tipo]();
+    if (cmd === 'conferir') { const r = t.conferir(plano); console.log(t.relatorio(r)); return r.passou ? 0 : 1; }
+    const r = await t.exportar(plano, path.resolve(pasta || path.dirname(arq)), { forcar: argv.includes('--forcar'), pdf: !argv.includes('--sem-pdf'), png: !argv.includes('--sem-png') });
+    console.log(t.relatorio(r.conferencia));
+    if (!r.exportado) { console.log('NÃO exportou: conserte as falhas (ou --forcar).'); return 1; }
+    r.arquivos.forEach((a) => console.log('arquivo: ' + a));
+    if (r.erroPdf) console.log('aviso: ' + r.erroPdf);
+    return 0;
+}
+main(process.argv.slice(2)).then((c) => process.exit(c));

package/lib/plugin/entregaveis/documento.js

@@ -0,0 +1,169 @@
+/**
+ * documento.js — relatório/proposta/documento de ponta a ponta: plano → conferência → .docx + PDF.
+ *
+ * Plano: { brief, direcao, titulo?, sumario?, secoes:[{ nivel:1|2, titulo, paragrafos:[], fonte? }] }
+ * O .docx sai com estilos REAIS (Heading1, Heading2, Title, Source), sumário em campo TOC e rodapé
+ * com número de página; o PDF sai do mesmo plano via HTML + Chrome (@page A4, número de página no rodapé).
+ * O .docx é escrito à mão com o jszip que já vem em vendor/pptxgenjs (MIT): sem dependência nova.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const nucleo = require('./nucleo');
+
+const PALAVRAS_POR_PAGINA = 380;
+const paragrafosDe = (s) => (Array.isArray(s.paragrafos) ? s.paragrafos.map(String).filter((x) => x.trim()) : []);
+const secoesDe = (p) => (Array.isArray(p.secoes) ? p.secoes : []);
+
+function paginasEstimadas(p) {
+    const w = secoesDe(p).reduce((n, s) => n + nucleo.palavras(s.titulo) + paragrafosDe(s).reduce((a, x) => a + nucleo.palavras(x), 0), 0);
+    return Math.max(1, Math.ceil(w / PALAVRAS_POR_PAGINA));
+}
+const temSumario = (p) => paginasEstimadas(p) > 3 || p.sumario === true;
+
+const REGRAS = [
+    { id: 'um-h1', peso: 20, bloqueia: true, testa: (p) => {
+        const n = secoesDe(p).filter((s) => s.nivel === 1).length;
+        return n === 1 ? [] : [{ msg: `${n} títulos de nível 1: o documento tem exatamente 1 (o título)` }];
+    } },
+    { id: 'nivel-valido', peso: 10, bloqueia: true, testa: (p) => secoesDe(p).flatMap((s, i) => [1, 2].includes(s.nivel) ? [] : [{ secao: i + 1, msg: `nível "${s.nivel}" inválido (1 ou 2)` }]) },
+    { id: 'secao-orfa', peso: 15, testa: (p) => {
+        const f = []; let h1 = false;
+        secoesDe(p).forEach((s, i) => {
+            if (s.nivel === 1) h1 = true;
+            if (s.nivel === 2 && !h1) f.push({ secao: i + 1, msg: 'H2 antes de qualquer H1: seção órfã' });
+            if (s.nivel === 2 && !paragrafosDe(s).length) f.push({ secao: i + 1, msg: `H2 "${s.titulo}" sem parágrafo: seção órfã (escreva ou apague)` });
+        });
+        return f;
+    } },
+    { id: 'titulo-claro', peso: 5, testa: (p) => secoesDe(p).flatMap((s, i) => nucleo.palavras(s.titulo) < 2 ? [{ secao: i + 1, msg: `título "${s.titulo || ''}" com menos de 2 palavras: diga o que a seção afirma` }] : []) },
+    { id: 'paragrafo-curto', peso: 15, testa: (p) => secoesDe(p).flatMap((s, i) => paragrafosDe(s).flatMap((x) => nucleo.palavras(x) > 120
+        ? [{ secao: i + 1, msg: `parágrafo com ${nucleo.palavras(x)} palavras (máx 120): divida` }] : [])) },
+    { id: 'numero-com-fonte', peso: 20, testa: (p) => secoesDe(p).flatMap((s, i) => (/\d/.test(paragrafosDe(s).join(' ')) && nucleo.palavras(s.fonte) < 1)
+        ? [{ secao: i + 1, msg: `"${s.titulo}" cita número e não tem "fonte" (de onde veio? sem fonte, tire o número ou marque a fonte)` }] : []) },
+    { id: 'sumario', peso: 10, testa: (p) => (paginasEstimadas(p) > 3 && p.sumario === false) ? [{ msg: `~${paginasEstimadas(p)} páginas e sumario:false: documento de mais de 3 páginas leva sumário` }] : [] },
+    { id: 'tamanho', peso: 5, testa: (p) => secoesDe(p).length < 3 ? [{ msg: 'menos de 3 seções: documento curto demais para a estrutura (use um e-mail)' }] : [] },
+    { id: 'direcao-de-arte', peso: 15, bloqueia: true, testa: (p) => nucleo.conferirDirecao(p.direcao).map((f) => ({ msg: f.msg })) },
+];
+
+function conferirDocumento(plano, opcoes) {
+    return nucleo.conferirPlano(plano, REGRAS, opcoes, { exige: 'secoes', vazio: 'plano sem seções' });
+}
+
+const tituloDo = (p) => (secoesDe(p).find((s) => s.nivel === 1) || {}).titulo || (p.brief || {}).tema || 'Documento';
+
+// ───────────────────────── .docx ─────────────────────────
+
+const x = nucleo.escX;
+const semHash = (c) => String(c).replace('#', '').toUpperCase();
+
+function gerarDocumentXml(plano) {
+    const sec = secoesDe(plano);
+    const corpo = [];
+    const run = (t, rpr = '') => `<w:r>${rpr ? `<w:rPr>${rpr}</w:rPr>` : ''}<w:t xml:space="preserve">${x(t)}</w:t></w:r>`;
+    const par = (estilo, conteudo, ppr = '') => `<w:p><w:pPr><w:pStyle w:val="${estilo}"/>${ppr}</w:pPr>${conteudo}</w:p>`;
+    let bm = 0;
+    const cabecalhos = sec.map((s, i) => ({ s, i, id: ++bm, nome: `_Toc${100000 + i}` }));
+    if (temSumario(plano)) {
+        corpo.push(par('TOCHeading', run('Sumário')));
+        const ents = cabecalhos.filter((c) => c.s.nivel === 2);
+        const itens = ents.length ? ents : cabecalhos.filter((c) => c.s.nivel === 1);
+        itens.forEach((c, k) => {
+            const ini = k === 0 ? '<w:r><w:fldChar w:fldCharType="begin"/></w:r><w:r><w:instrText xml:space="preserve"> TOC \\o "2-2" \\h \\z \\u </w:instrText></w:r><w:r><w:fldChar w:fldCharType="separate"/></w:r>' : '';
+            const fim = k === itens.length - 1 ? '<w:r><w:fldChar w:fldCharType="end"/></w:r>' : '';
+            corpo.push(par('TOC2', `${ini}<w:hyperlink w:anchor="${c.nome}" w:history="1">${run(c.s.titulo)}</w:hyperlink>${fim}`));
+        });
+        corpo.push('<w:p><w:r><w:br w:type="page"/></w:r></w:p>');
+    }
+    for (const c of cabecalhos) {
+        const h = c.s.nivel === 1 ? 'Heading1' : 'Heading2';
+        corpo.push(`<w:p><w:pPr><w:pStyle w:val="${h}"/></w:pPr><w:bookmarkStart w:id="${c.id}" w:name="${c.nome}"/>${run(c.s.titulo)}<w:bookmarkEnd w:id="${c.id}"/></w:p>`);
+        paragrafosDe(c.s).forEach((t) => corpo.push(par('Normal', run(t))));
+        if (nucleo.palavras(c.s.fonte) >= 1) corpo.push(par('Source', run('Fonte: ' + c.s.fonte)));
+    }
+    const sect = '<w:sectPr><w:footerReference w:type="default" r:id="rId2"/><w:pgSz w:w="11906" w:h="16838"/><w:pgMar w:top="1417" w:right="1417" w:bottom="1417" w:left="1417" w:header="708" w:footer="708" w:gutter="0"/></w:sectPr>';
+    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><w:body>${corpo.join('')}${sect}</w:body></w:document>`;
+}
+
+function gerarStylesXml(plano) {
+    const d = plano.direcao; const c = d.paleta;
+    const ft = x(d.fonteTitulo); const fc = x(d.fonteCorpo);
+    const fonte = (f) => `<w:rFonts w:ascii="${f}" w:hAnsi="${f}" w:cs="${f}"/>`;
+    const estilo = (id, nome, { base = 'Normal', next, ppr = '', rpr = '', tipo = 'paragraph', extra = '' } = {}) =>
+        `<w:style w:type="${tipo}" w:styleId="${id}"><w:name w:val="${nome}"/>${base ? `<w:basedOn w:val="${base}"/>` : ''}${next ? `<w:next w:val="${next}"/>` : ''}${extra}<w:qFormat/><w:pPr>${ppr}</w:pPr><w:rPr>${rpr}</w:rPr></w:style>`;
+    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:styles xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+<w:docDefaults><w:rPrDefault><w:rPr>${fonte(fc)}<w:sz w:val="22"/><w:szCs w:val="22"/><w:lang w:val="pt-BR"/></w:rPr></w:rPrDefault><w:pPrDefault><w:pPr><w:spacing w:after="160" w:line="300" w:lineRule="auto"/></w:pPr></w:pPrDefault></w:docDefaults>
+<w:style w:type="paragraph" w:default="1" w:styleId="Normal"><w:name w:val="Normal"/><w:qFormat/></w:style>
+${estilo('Title', 'Title', { next: 'Normal', ppr: '<w:spacing w:before="0" w:after="240"/>', rpr: `${fonte(ft)}<w:b/><w:color w:val="${semHash(c.destaque)}"/><w:sz w:val="56"/><w:szCs w:val="56"/>` })}
+${estilo('Heading1', 'heading 1', { next: 'Normal', ppr: '<w:keepNext/><w:spacing w:before="360" w:after="160"/><w:outlineLvl w:val="0"/>', rpr: `${fonte(ft)}<w:b/><w:color w:val="${semHash(c.destaque)}"/><w:sz w:val="40"/><w:szCs w:val="40"/>` })}
+${estilo('Heading2', 'heading 2', { next: 'Normal', ppr: '<w:keepNext/><w:spacing w:before="280" w:after="120"/><w:outlineLvl w:val="1"/>', rpr: `${fonte(ft)}<w:b/><w:sz w:val="30"/><w:szCs w:val="30"/>` })}
+${estilo('Source', 'Source', { ppr: '<w:spacing w:before="0" w:after="200"/>', rpr: '<w:i/><w:color w:val="595959"/><w:sz w:val="18"/><w:szCs w:val="18"/>' })}
+${estilo('TOCHeading', 'TOC Heading', { next: 'Normal', ppr: '<w:spacing w:before="0" w:after="200"/>', rpr: `${fonte(ft)}<w:b/><w:sz w:val="36"/><w:szCs w:val="36"/>` })}
+${estilo('TOC2', 'toc 2', { next: 'Normal', ppr: '<w:spacing w:after="80"/><w:ind w:left="220"/>', rpr: '' })}
+</w:styles>`;
+}
+
+async function gerarDocx(plano, destino) {
+    const JSZip = require('../../../vendor/pptxgenjs/jszip.min.js');
+    const zip = new JSZip();
+    const W = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+    zip.file('[Content_Types].xml', '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="xml" ContentType="application/xml"/><Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/><Override PartName="/word/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"/><Override PartName="/word/footer1.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml"/><Override PartName="/docProps/core.xml" ContentType="application/vnd.openxmlformats-package.core-properties+xml"/></Types>');
+    zip.file('_rels/.rels', '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/><Relationship Id="rId2" Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties" Target="docProps/core.xml"/></Relationships>');
+    zip.file('word/_rels/document.xml.rels', '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/><Relationship Id="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer" Target="footer1.xml"/></Relationships>');
+    zip.file('word/document.xml', gerarDocumentXml(plano));
+    zip.file('word/styles.xml', gerarStylesXml(plano));
+    zip.file('word/footer1.xml', `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:ftr xmlns:w="${W}"><w:p><w:pPr><w:jc w:val="center"/></w:pPr><w:r><w:rPr><w:sz w:val="18"/></w:rPr><w:fldChar w:fldCharType="begin"/></w:r><w:r><w:rPr><w:sz w:val="18"/></w:rPr><w:instrText xml:space="preserve"> PAGE </w:instrText></w:r><w:r><w:rPr><w:sz w:val="18"/></w:rPr><w:fldChar w:fldCharType="separate"/></w:r><w:r><w:rPr><w:sz w:val="18"/></w:rPr><w:t>1</w:t></w:r><w:r><w:rPr><w:sz w:val="18"/></w:rPr><w:fldChar w:fldCharType="end"/></w:r></w:p></w:ftr>`);
+    zip.file('docProps/core.xml', `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/"><dc:title>${x(tituloDo(plano))}</dc:title><dc:creator>PrimoCode</dc:creator></cp:coreProperties>`);
+    fs.writeFileSync(destino, await zip.generateAsync({ type: 'nodebuffer', compression: 'DEFLATE' }));
+    return destino;
+}
+
+// ───────────────────────── HTML → PDF ─────────────────────────
+
+function gerarHtmlDocumento(plano) {
+    const d = plano.direcao; const c = d.paleta; const sec = secoesDe(plano);
+    const f = nucleo.fontesEmbutidas([d.fonteTitulo, d.fonteCorpo]);
+    const ft = `'${x(d.fonteTitulo)}',system-ui,sans-serif`; const fc = `'${x(d.fonteCorpo)}',system-ui,sans-serif`;
+    const itensToc = sec.map((s, i) => ({ s, i })).filter((e) => e.s.nivel === 2);
+    const toc = temSumario(plano) ? `<nav class="toc"><h2>Sumário</h2><ol>${itensToc.map((e) => `<li><a href="#s${e.i}">${x(e.s.titulo)}</a></li>`).join('')}</ol></nav>` : '';
+    const corpo = sec.map((s, i) => {
+        const h = s.nivel === 1 ? `<h1 id="s${i}">${x(s.titulo)}</h1>` : `<h2 id="s${i}">${x(s.titulo)}</h2>`;
+        const ps = paragrafosDe(s).map((t) => `<p>${x(t)}</p>`).join('');
+        const fonte = nucleo.palavras(s.fonte) >= 1 ? `<p class="fonte">Fonte: ${x(s.fonte)}</p>` : '';
+        return h + ps + fonte;
+    });
+    // o sumário entra logo depois do H1 (e dos parágrafos dele), antes da primeira seção H2
+    const iH2 = sec.findIndex((s) => s.nivel === 2);
+    const partes = corpo.slice(); if (toc) partes.splice(iH2 < 0 ? partes.length : iH2, 0, toc);
+    return `<!doctype html><html lang="pt-BR"><head><meta charset="utf-8"><title>${x(tituloDo(plano))}</title>
+<style>${f.css}
+@page{size:A4;margin:22mm 20mm 24mm;background:${c.fundo};@bottom-center{content:counter(page);font:10pt ${fc};color:${c.suave || c.texto}}}
+*{box-sizing:border-box}html{background:${c.fundo};-webkit-print-color-adjust:exact;print-color-adjust:exact}
+body{margin:0;background:${c.fundo};color:${c.texto};font:11pt/1.55 ${fc}}
+h1{font:800 30pt/1.05 ${ft};color:${c.destaque};margin:0 0 10mm;padding-top:6mm;border-top:3mm solid ${c.destaque}}
+h2{font:800 17pt/1.2 ${ft};margin:9mm 0 3mm;break-after:avoid}
+p{margin:0 0 3.2mm;orphans:3;widows:3}.fonte{font-size:8.5pt;font-style:italic;color:${c.suave || c.texto};margin-bottom:5mm}
+.toc{break-inside:avoid;margin:6mm 0 4mm;padding:5mm 6mm;border-left:1.2mm solid ${c.destaque}}
+.toc h2{margin:0 0 3mm;font-size:13pt}.toc ol{margin:0;padding-left:5mm}.toc li{margin:1mm 0}.toc a{color:${c.texto};text-decoration:none}
+</style></head><body>
+${partes.join('\n')}
+</body></html>`;
+}
+
+/** Exporta: confere, escreve .docx, .html, .pdf e um .png por página (se houver pdftoppm). */
+async function exportarDocumento(plano, pasta, { forcar = false, pdf = true, png = true, nome } = {}) {
+    const conferencia = conferirDocumento(plano);
+    if (!conferencia.passou && !forcar) return { exportado: false, conferencia, arquivos: [] };
+    fs.mkdirSync(pasta, { recursive: true });
+    const base = path.join(pasta, nome || nucleo.slug(tituloDo(plano)));
+    const arquivos = []; const erros = [];
+    await gerarDocx(plano, base + '.docx'); arquivos.push(base + '.docx');
+    fs.writeFileSync(base + '.html', gerarHtmlDocumento(plano)); arquivos.push(base + '.html');
+    let pdfOk = false;
+    if (pdf) { const r = nucleo.htmlParaPdf(base + '.html', base + '.pdf'); if (r.ok) { arquivos.push(base + '.pdf'); pdfOk = true; } else erros.push(r.erro); }
+    if (png && pdfOk) { const r = nucleo.pdfParaPngs(base + '.pdf', base); arquivos.push(...r.arquivos); if (r.erro) erros.push(r.erro); }
+    return { exportado: true, conferencia, arquivos, erroPdf: erros.join('; ') || null };
+}
+
+module.exports = { REGRAS, paginasEstimadas, conferirDocumento, relatorio: nucleo.relatorio, gerarDocx, gerarDocumentXml, gerarHtmlDocumento, exportarDocumento };

package/lib/plugin/entregaveis/especialistas.js

@@ -0,0 +1,72 @@
+/**
+ * especialistas.js (entregáveis) — quem faz cada parte do slide, do cartaz e do documento.
+ *
+ * Mesmo formato de lib/skill/especialistas.js (faz + briefing curto que vai na frente da tarefa).
+ * Ficam separados de propósito: os nomes de lib/skill/especialistas.js são um acordo com o enum
+ * do spawn_agent do servidor (test/especialistas.test.js), e aqui os papéis são de ofício
+ * de entregável. O briefing termina sempre em como PROVAR que acabou.
+ */
+'use strict';
+
+const NUCLEO = 'Conferência é código: rode `node lib/plugin/entregaveis/cli.js [tipo] conferir plano.json` (tipo: slides, cartaz, carrossel ou documento) e só diga "pronto" com nota >= 80 e sem falha de bloqueio.';
+
+const ESPECIALISTAS_ENTREGAVEIS = {
+    roteirista: {
+        tipos: ['slides', 'documento', 'carrossel'],
+        faz: 'transforma o brief em estrutura: uma ideia por slide/seção, título que é afirmação',
+        briefing: `Você é o ROTEIRISTA. Parta do brief (tema, público, objetivo). Escreva primeiro a história em uma frase, depois a lista de slides com UMA afirmação cada (3 a 12 palavras, nunca "Visão geral"). O texto do slide é o que se lê de longe; o que se fala vai em "nota". Abra com capa, feche com ação concreta (campo "acao"). Cada número citado tem fonte [LI] ou vira "[VERIFICAR]". Prova: plano.json com slides e notas, sem conferência de texto ainda.`,
+    },
+    'diretor-de-arte': {
+        tipos: ['slides', 'cartaz', 'carrossel', 'documento'],
+        faz: 'escolhe a direção visual a partir de material solto, nunca de modelo pronto',
+        briefing: `Você é o DIRETOR DE ARTE. NÃO use template: junte material solto (objetos, cores e textura do assunto; referências que o dono aprovou) e escreva a direção em "direcao": conceito (por que este visual é DESTE assunto, >= 6 palavras), paleta {fundo,texto,destaque,destaque2?,suave?} em hex, fonteTitulo, fonteCorpo (fonte que a outra máquina tem, ou a que será embutida no PDF). Título gigante em degradê (destaque → destaque2, sai como SVG no PDF) ou em cor de destaque. Todo elemento visual extra leva "visual.motivo": o que ele tem a ver com o conteúdo. Prova: contraste texto/fundo >= 4.5 calculado, não olhado.`,
+    },
+    tipografo: {
+        tipos: ['slides', 'cartaz', 'carrossel', 'documento'],
+        faz: 'hierarquia, tamanhos e encaixe do texto',
+        briefing: `Você é o TIPÓGRAFO. Defina a escala (título 40-80pt, corpo >= 24pt em slide) e dê UM peso de destaque por slide. Encurte até o texto caber na caixa (a conferência estima o encaixe). Nada de três fontes. Prova: regras "tamanho-da-letra" e "encaixe" sem falha.`,
+    },
+    copywriter: {
+        tipos: ['cartaz', 'carrossel', 'slides'],
+        faz: 'escreve o herói e o CTA: a frase que se lê a 1 m e a ação que o público faz',
+        briefing: `Você é o COPYWRITER. Escreva UM herói (3 a 8 palavras, afirmação com benefício ou tensão, nunca o nome do tema) e no máximo 2 linhas de apoio; o total fora o CTA tem até 25 palavras num cartaz e até 25 por slide de carrossel. O CTA é um verbo de ação com prazo ou ganho ("Inscreva seu time até quarta"), 2+ palavras. Cada número leva fonte [LI] ou vira "[VERIFICAR]". Prova: plano.json com heroi, apoio e cta, e a conferência sem falha nas regras "hierarquia", "cta" e "palavras".`,
+    },
+    'editor-de-texto': {
+        tipos: ['documento'],
+        faz: 'deixa o texto do documento claro: títulos que afirmam, parágrafos curtos, uma ideia por seção',
+        briefing: `Você é o EDITOR DE TEXTO. Cada título de seção afirma algo (não "Contexto"); 1 H1; H2 sem seção órfã (todo H2 tem parágrafo); parágrafo com até 120 palavras e uma ideia só; corte adjetivo e abertura vazia. Mais de 3 páginas leva sumário. Prova: \`node lib/plugin/entregaveis/cli.js documento conferir plano.json\` sem as falhas "um-h1", "secao-orfa", "paragrafo-curto" e "titulo-claro".`,
+    },
+    'revisor-de-fatos': {
+        tipos: ['documento'],
+        faz: 'caça número, data e afirmação sem fonte; aponta, não inventa',
+        briefing: `Você é o REVISOR DE FATOS. Para cada seção com número, data ou "estudos mostram", confira o campo "fonte": quem disse, onde, quando. Fonte que você não conseguiu abrir leva "[VERIFICAR]" no texto, nunca "[LI]". Não preencha fonte de cabeça. Prova: lista seção a seção (com fonte aberta, ou marcada [VERIFICAR]) e a regra "numero-com-fonte" sem falha.`,
+    },
+    revisor: {
+        tipos: ['slides', 'cartaz', 'carrossel', 'documento'],
+        faz: 'confere o resultado com os números e aponta; não reescreve',
+        briefing: `Você é o REVISOR e não fez este plano: aponte, não conserte. ${NUCLEO} Depois abra os PNG exportados (um por slide/página) e olhe de verdade a capa, a mais cheia e a última: texto vazando, contraste, layout repetido, degradê que virou retângulo. Liste falha por slide/página com o número. Prova: relatório da conferência + o que viu nos PNG.`,
+    },
+};
+
+const NOMES = Object.keys(ESPECIALISTAS_ENTREGAVEIS);
+
+function porNome(nome) {
+    const n = String(nome || '').trim().toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/\s+/g, '-');
+    const mapa = { diretor: 'diretor-de-arte', arte: 'diretor-de-arte', designer: 'diretor-de-arte', roteiro: 'roteirista', tipografia: 'tipografo', review: 'revisor', reviewer: 'revisor', copy: 'copywriter', redator: 'copywriter', editor: 'editor-de-texto', fatos: 'revisor-de-fatos', checagem: 'revisor-de-fatos' };
+    const k = mapa[n] || n;
+    return ESPECIALISTAS_ENTREGAVEIS[k] ? { nome: k, ...ESPECIALISTAS_ENTREGAVEIS[k] } : null;
+}
+
+/** A ordem em que os especialistas trabalham em cada tipo de entregável. */
+const ORDEM = {
+    slides: ['roteirista', 'diretor-de-arte', 'tipografo', 'revisor'],
+    cartaz: ['copywriter', 'diretor-de-arte', 'tipografo', 'revisor'],
+    carrossel: ['roteirista', 'copywriter', 'diretor-de-arte', 'tipografo', 'revisor'],
+    documento: ['roteirista', 'editor-de-texto', 'revisor-de-fatos', 'diretor-de-arte', 'revisor'],
+};
+
+function equipe(tipo) {
+    return (ORDEM[tipo] || []).filter((n) => ESPECIALISTAS_ENTREGAVEIS[n].tipos.includes(tipo));
+}
+
+module.exports = { ESPECIALISTAS_ENTREGAVEIS, NOMES, porNome, equipe, ORDEM };