primocode 11.0.0 → 11.2.0

package/lib/estudio/conferencia-visual.js

@@ -1,76 +0,0 @@
-/**
- * conferencia-visual.js — o olho DEPOIS do render: o quadro de cada cena, lido de verdade.
- *
- *   conferir({quadros, pl, guarda, visao}) → {olho: 'vision'|'caixas', problemas: [{cena, tipo, texto}], leituras}
- *
- * Com o Vision do macOS (lib/estudio/visao.js): o texto que aparece no quadro (OCR) e os rostos. Reprova:
- *   borda        texto a menos de 3% da beira do quadro (colado na borda)
- *   rosto        texto em cima de um rosto
- *   encavalado   duas linhas de texto uma em cima da outra
- * Sempre (com ou sem o Vision): as caixas finais da guarda do kit (linhas "GUARDA {json}") conferidas de novo
- * (maquina-guarda.verificarCaixas): sobreposição e fora da zona segura. Sem Vision, é só isso ("caixas").
- * Puro na decisão (julgarLeitura): testável sem quadro nem Vision.
- */
-'use strict';
-
-const G = require('./maquina-guarda.js');
-
-const LIM = { borda: 0.03, conf: 0.5, alturaMin: 0.012, rostoMin: 0.004 };
-const area = (c) => Math.max(0, c[2] - c[0]) * Math.max(0, c[3] - c[1]);
-const inter = (a, b) => Math.max(0, Math.min(a[2], b[2]) - Math.max(a[0], b[0])) * Math.max(0, Math.min(a[3], b[3]) - Math.max(a[1], b[1]));
-
-/** Os problemas de UM quadro lido pelo Vision ({w, h, textos:[{texto, conf, caixa}], rostos:[caixa]}). */
-function julgarLeitura(q, cena, { foto = null } = {}) {
-    const out = [];
-    if (!q || !q.ok || !q.w || !q.h) return out;
-    const W = q.w, H = q.h;
-    const textos = (q.textos || []).filter((t) => t.conf >= LIM.conf && (t.caixa[3] - t.caixa[1]) >= H * LIM.alturaMin && String(t.texto).replace(/[^A-Za-zÀ-ÿ0-9]/g, '').length >= 2);
-    // com a caixa da foto (já na escala do quadro), só vale rosto DENTRO dela: o fundo desfocado é a mesma foto ampliada e também tem rosto
-    const naFoto = (r) => !foto || ((r[0] + r[2]) / 2 >= foto[0] && (r[0] + r[2]) / 2 <= foto[2] && (r[1] + r[3]) / 2 >= foto[1] && (r[1] + r[3]) / 2 <= foto[3]);
-    const rostos = (q.rostos || []).filter((r) => area(r) >= W * H * LIM.rostoMin && naFoto(r));
-    for (const t of textos) {
-        const c = t.caixa;
-        if (c[0] < W * LIM.borda || c[2] > W * (1 - LIM.borda) || c[1] < H * LIM.borda || c[3] > H * (1 - LIM.borda)) out.push({ cena, tipo: 'borda', texto: `texto colado na borda: "${t.texto}"` });
-        for (const r of rostos) if (inter(c, r) > 0.15 * area(c)) out.push({ cena, tipo: 'rosto', texto: `texto sobre o rosto: "${t.texto}"` });
-    }
-    for (let i = 0; i < textos.length; i++) for (let j = i + 1; j < textos.length; j++) {
-        const a = textos[i].caixa, b = textos[j].caixa;
-        if (inter(a, b) > 0.3 * Math.min(area(a), area(b))) out.push({ cena, tipo: 'encavalado', texto: `textos encavalados: "${textos[i].texto}" × "${textos[j].texto}"` });
-    }
-    return out;
-}
-
-/** As linhas "GUARDA {json}" que o kit escreveu (uma por cena). */
-function lerGuarda(saida) {
-    return String(saida || '').split('\n').filter((l) => /^GUARDA \{/.test(l)).map((l) => { try { return JSON.parse(l.slice(7)); } catch { return null; } }).filter(Boolean);
-}
-
-/** `quadros[i]` é o quadro da cena i. `guarda` = lerGuarda(saida). `visao` injetável (testes); null = sem olho. */
-function conferir({ quadros = [], pl = {}, guarda = [], visao } = {}) {
-    const problemas = [];
-    const legenda = !!(pl.legenda && pl.legenda.chunks && pl.legenda.chunks.length);
-    for (const g of guarda) {
-        for (const v of G.verificarCaixas(g.caixas, g.w || pl.w, g.h || pl.h, { legenda })) problemas.push({ cena: g.cena, tipo: /fora|trilho/.test(v) ? 'zona' : 'sobreposicao', texto: v });
-    }
-    let V = visao;
-    if (V === undefined) { try { V = require('./visao.js'); } catch { V = null; } }
-    let olho = 'caixas', leituras = null;
-    if (V && V.disponivel() && quadros.length) {
-        const r = V.ler(quadros);
-        if (r && r.ok) {
-            olho = 'vision'; leituras = r.quadros;
-            r.quadros.forEach((q) => {
-                const i = quadros.indexOf(q.arquivo);
-                if (i < 0) return;
-                // a caixa da foto (layout) levada pro quadro: escala do quadro, câmera ~0,94 em volta do centro, 20% de folga
-                const g = guarda.find((x) => x.cena === i), fc = g && (g.caixas || []).find((c) => c.tipo === 'foto');
-                let foto = null;
-                if (fc && q.w) { const W0 = g.w || pl.w, H0 = g.h || pl.h, k = q.w / W0, cx = W0 / 2, cy = H0 / 2, e = (x, c0) => (c0 + (x - c0) * 0.94) * k; const fw = (fc.c[2] - fc.c[0]) * 0.1 * k, fh = (fc.c[3] - fc.c[1]) * 0.1 * k; foto = [e(fc.c[0], cx) - fw, e(fc.c[1], cy) - fh, e(fc.c[2], cx) + fw, e(fc.c[3], cy) + fh]; }
-                problemas.push(...julgarLeitura(q, i, { foto }));
-            });
-        }
-    }
-    return { olho, problemas, leituras };
-}
-
-module.exports = { conferir, julgarLeitura, lerGuarda, LIM };

package/lib/estudio/cota.js

@@ -1,157 +0,0 @@
-/**
- * cota.js — o plano decide o vídeo: cota do mês, resolução e marca d'água.
- *
- *   "o plano ter render de vídeo" (Joel, 18/10/2026)
- *
- * A regra mora no servidor (server/lib/planos.js, POST /api/video/cota); aqui
- * só se pergunta antes do render do estudio_motion/estudio_ae, se aplica o que
- * o plano libera no mp4 pronto (teto de resolução, marca d'água) e se conta o
- * vídeo depois que ele saiu. Sem rede ou servidor mudo: MODO LOCAL generoso —
- * 4K, sem marca, sem teto. Errar para o lado de quem trabalha, como o gate.
- */
-
-'use strict';
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const zlib = require('zlib');
-const { spawnSync } = require('child_process');
-
-const LOCAL = { ok: true, offline: true, liberado: true, plano: 'local', restam: null, usados: 0,
-    recursos: { videosMes: 0, resolucao: 2160, marcaDagua: false, narracaoPremium: true, clubeCompleto: true, scriptsAE: true, subagentes: 7, kitsMarca: 0, versoesEditor: 0 } };
-
-/** Pergunta (acao "checar") ou conta (acao "gastar") no servidor. */
-async function consultar(acao = 'checar', { buscar = fetch, servidor, token, prazo = 6000 } = {}) {
-    try {
-        if (servidor === undefined) servidor = require('../config').loadConfig().server;
-        if (token === undefined) token = await require('../conta').tokenValido().catch(() => null);
-        const h = { 'Content-Type': 'application/json' };
-        if (token) h['x-primocode-token'] = token;
-        const r = await buscar(new URL('/api/video/cota', servidor).href, {
-            method: 'POST', headers: h, body: JSON.stringify({ acao }), signal: AbortSignal.timeout(prazo),
-        });
-        const j = await r.json();
-        if (!r.ok || !j || !j.recursos) return LOCAL;
-        require('../limites.js').guardar(j);
-        return j;
-    } catch { return LOCAL; }
-}
-
-/** A mensagem do limite, com o degrau seguinte e o caminho para assinar. */
-function mensagemLimite(c) {
-    const u = c.upgrade;
-    const reais = (n) => `R$ ${Number(n).toFixed(2).replace('.', ',')}`;
-    return `Seus ${c.recursos.videosMes} vídeos do mês acabaram (plano ${c.plano}).`
-        + (u ? ` O ${u.nome} (${reais(u.preco)}/mês) libera ${u.videosMes} por mês. Veja com: primocode planos`
-            : ' A cota volta no primeiro dia do próximo mês.');
-}
-
-/* ── a marca d'água: um PNG pequeno desenhado aqui, sem depender de fonte no ffmpeg ── */
-const LETRAS = {
-    P: ['1111', '1  1', '1111', '1   ', '1   '], R: ['1111', '1  1', '1111', '1 1 ', '1  1'],
-    I: ['111', ' 1 ', ' 1 ', ' 1 ', '111'], M: ['1   1', '11 11', '1 1 1', '1   1', '1   1'],
-    O: ['1111', '1  1', '1  1', '1  1', '1111'], C: ['1111', '1   ', '1   ', '1   ', '1111'],
-    D: ['111 ', '1  1', '1  1', '1  1', '111 '], E: ['1111', '1   ', '111 ', '1   ', '1111'],
-};
-
-function crc32(buf) {
-    let c, crc = ~0;
-    for (const b of buf) { c = (crc ^ b) & 0xff; for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1; crc = (crc >>> 8) ^ c; }
-    return ~crc >>> 0;
-}
-function pedaco(tipo, dados) {
-    const t = Buffer.from(tipo), len = Buffer.alloc(4), crc = Buffer.alloc(4);
-    len.writeUInt32BE(dados.length); crc.writeUInt32BE(crc32(Buffer.concat([t, dados])));
-    return Buffer.concat([len, t, dados, crc]);
-}
-
-/** PNG RGBA do texto "PRIMOCODE" (letras brancas sobre fundo preto translúcido), `px` pixels por ponto da fonte. */
-function pngMarca(px = 3, texto = 'PRIMOCODE') {
-    const cols = [], pad = 3;
-    for (const ch of texto) { const g = LETRAS[ch]; for (let x = 0; x < g[0].length; x++) cols.push(g.map((l) => l[x] === '1')); cols.push(null); }
-    cols.pop();
-    const L = (cols.length + pad * 2) * px, A = (5 + pad * 2) * px;
-    const raw = Buffer.alloc((L * 4 + 1) * A);
-    for (let y = 0; y < A; y++) {
-        raw[y * (L * 4 + 1)] = 0;
-        for (let x = 0; x < L; x++) {
-            const cx = Math.floor(x / px) - pad, cy = Math.floor(y / px) - pad;
-            const aceso = cx >= 0 && cy >= 0 && cy < 5 && cols[cx] && cols[cx][cy];
-            const o = y * (L * 4 + 1) + 1 + x * 4;
-            const v = aceso ? [255, 255, 255, 235] : [0, 0, 0, 110];
-            raw[o] = v[0]; raw[o + 1] = v[1]; raw[o + 2] = v[2]; raw[o + 3] = v[3];
-        }
-    }
-    const ihdr = Buffer.alloc(13); ihdr.writeUInt32BE(L, 0); ihdr.writeUInt32BE(A, 4); ihdr[8] = 8; ihdr[9] = 6;
-    return Buffer.concat([Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]), pedaco('IHDR', ihdr), pedaco('IDAT', zlib.deflateSync(raw)), pedaco('IEND', Buffer.alloc(0))]);
-}
-
-function dimensoes(arquivo) {
-    const r = spawnSync('ffprobe', ['-v', 'error', '-select_streams', 'v:0', '-show_entries', 'stream=width,height', '-of', 'csv=p=0', arquivo], { encoding: 'utf8' });
-    const [w, h] = String(r.stdout || '').trim().split(',').map(Number);
-    return w && h ? { w, h } : null;
-}
-
-/** Os filtros que o plano pede para um vídeo `w`×`h`; [] quando nada muda. */
-function filtros({ w, h }, recursos) {
-    const lado = Math.min(w, h), teto = recursos.resolucao || 2160;
-    return { escala: lado > teto ? (w >= h ? `scale=-2:${teto}` : `scale=${teto}:-2`) : null, marca: !!recursos.marcaDagua };
-}
-
-/**
- * Aplica o plano ao mp4 pronto (no lugar). Devolve {ok, resolucao, marcaDagua, mudou}.
- * `rodar` e `dim` são injetáveis nos testes.
- */
-function aplicar(arquivo, recursos, { rodar = spawnSync, dim = dimensoes } = {}) {
-    if (!arquivo || !fs.existsSync(arquivo)) return { ok: false, mudou: false };
-    const d = dim(arquivo);
-    if (!d) return { ok: false, mudou: false };
-    const f = filtros(d, recursos);
-    if (!f.escala && !f.marca) return { ok: true, mudou: false, resolucao: Math.min(d.w, d.h), marcaDagua: false };
-
-    const tmp = path.join(os.tmpdir(), `primocode-marca-${process.pid}-${Date.now()}`);
-    const png = tmp + '.png', saida = arquivo.replace(/\.mp4$/i, '') + '.plano.mp4';
-    const args = ['-y', '-i', arquivo];
-    let g;
-    if (f.marca) {
-        const lado = Math.min(d.w, d.h) / (f.escala ? Math.min(d.w, d.h) / recursos.resolucao : 1);
-        fs.writeFileSync(png, pngMarca(Math.max(2, Math.round(lado / 300))));
-        args.push('-i', png);
-        g = `[0:v]${f.escala ? f.escala : 'null'}[v];[v][1:v]overlay=W-w-24:H-h-24[o]`;
-        args.push('-filter_complex', g, '-map', '[o]', '-map', '0:a?');
-    } else {
-        args.push('-vf', f.escala, '-map', '0:v', '-map', '0:a?');
-    }
-    args.push('-c:v', 'libx264', '-pix_fmt', 'yuv420p', '-crf', '18', '-c:a', 'copy', saida);
-    const r = rodar('ffmpeg', args, { encoding: 'utf8', timeout: 10 * 60000 });
-    fs.rmSync(png, { force: true });
-    if (r.status !== 0 || !fs.existsSync(saida)) return { ok: false, mudou: false, erro: String(r.stderr || '').slice(-300) };
-    fs.renameSync(saida, arquivo);
-    return { ok: true, mudou: true, resolucao: Math.min(f.escala ? recursos.resolucao : Math.min(d.w, d.h), Math.min(d.w, d.h)), marcaDagua: f.marca };
-}
-
-/**
- * O envelope do render: checa a cota, roda `render()`, aplica o plano ao mp4 e
- * conta o vídeo. `render` devolve o resultado da ferramenta ({ok, video,...}).
- */
-async function comCota(render, deps = {}) {
-    const c = await (deps.consultar || consultar)('checar');
-    if (!c.liberado) return { ok: false, error: mensagemLimite(c), cota: { plano: c.plano, restam: 0, upgrade: c.upgrade } };
-    const lim = require('../limites.js');
-    lim.guardar(c); lim.pegarAvisos();
-    const r = await render();
-    const extra = lim.pegarAvisos();
-    if (!r || !r.ok) return r;
-    const a = c.offline ? { ok: true, mudou: false } : (deps.aplicar || aplicar)(r.video, c.recursos);
-    if (!c.offline) await (deps.consultar || consultar)('gastar');
-    const restam = c.restam == null ? null : Math.max(0, c.restam - 1);
-    return { ...r, plano: { id: c.plano, restam, resolucao: c.recursos.resolucao, marcaDagua: !!(a.mudou && c.recursos.marcaDagua) },
-        ...((() => {
-            const a = [...(c.offline ? ['sem rede: modo local, sem cota nem marca d\'água.'] : []),
-                ...(!c.offline && restam === 0 ? ['Foi o seu último vídeo do mês. Veja os planos com: primocode planos'] : []), ...extra];
-            return a.length ? { aviso: a.join(' ') } : {};
-        })()) };
-}
-
-module.exports = { LOCAL, consultar, mensagemLimite, pngMarca, filtros, aplicar, comCota };

package/lib/estudio/diretor.js

@@ -1,392 +0,0 @@
-/**
- * diretor.js — o agente que ESTRUTURA antes de alguém produzir.
- *
- *   "Tenha uma IA específica pra roteiro que monta tudo: narração, qual voz,
- *    roteiro, etc. Ela estrutura tudo antes de mandar pra IA. Funciona assim:
- *    a IA identifica que precisa criar vídeo, ativa o agente, esse agente faz
- *    a estrutura e manda pra IA, e depois ela só faz o vídeo."
- *
- * ── POR QUE UM PAPEL SEPARADO, E NÃO UM PARÁGRAFO NO PROMPT ──────────────
- * É o mesmo motivo do pipeline.js: o modelo que está montando as cenas já
- * gastou a atenção dele em JSON — fonte, cor, duração, layout — e é ali que o
- * roteiro morre. Vira legenda do que aparece na tela ("Vantagens", "Nossos
- * serviços"), sem arco, sem narração escrita, sem decisão de voz. O diretor
- * roda numa conversa PRÓPRIA, sem ver JSON nenhum, e só decide: o que se
- * conta, em que ordem, em quantos segundos, com que voz, com quais imagens e
- * qual música. Depois disso o produtor tem pouco a inventar — e inventar é
- * justamente onde ele erra.
- *
- * ── O PLANO É UM CONTRATO, NÃO UM TEXTO BONITO ───────────────────────────
- * A saída do diretor é JSON com forma conhecida, e este módulo NORMALIZA e
- * CONFERE o que voltou: duração que fecha, narração em toda cena, keyframes
- * onde faz sentido, lista de mídia a buscar. Um plano que não fecha volta ao
- * diretor com o defeito apontado — uma vez. Aceitar "quase certo" aqui custa
- * um vídeo de 40 segundos que dura 12.
- *
- * ── O QUE O DIRETOR NÃO ESCOLHE MAIS ─────────────────────────────────────
- * Ele escolhia o MOTOR (estúdio ou Remotion) e o TEMA, o LAYOUT e o FUNDO,
- * cada um numa lista fechada — "meia-noite | claro | papel | neon", "capa |
- * titulo | secao | duas-colunas". Motor não existe mais: o Remotion é o
- * único renderizador. E as outras três listas saíram por decisão do produto:
- *
- *   "tira os templates e os estilos prontos, eles deixam a IA preguiçosa e
- *    todo vídeo sai igual e genérico"
- *
- * Uma lista de seis temas é um template com outro nome — o modelo escolhe um
- * dos seis e para de pensar em cor. No lugar delas o diretor DESCREVE: que
- * paleta, que ar, o que está na tela, como a cena troca. Descrição não tem
- * seis opções, e é o produtor quem compõe aquilo com os primitivos.
- */
-
-'use strict';
-
-// ── 1. reconhecer que o pedido é de vídeo ────────────────────────────────
-
-const PEDE_VIDEO = /\b(v[ií]deo|reels?|tiktok|short|shorts|motion|anima[cç][aã]o|anima\b|teaser|trailer|comercial|propaganda|v[ií]nheta|vinheta|abertura|capcut|premiere|after\s*effects|aftereffects)\b/i;
-const PEDE_SLIDE = /\b(slide|slides|deck|apresenta[cç][aã]o|pitch|powerpoint|keynote|prisma)\b/i;
-const SO_TEXTO = /\b(roteiro apenas|s[oó] o roteiro|s[oó] o texto|sem v[ií]deo)\b/i;
-
-/**
- * O pedido precisa de produção audiovisual? E de que tipo?
- *
- * Isto é o gatilho do agente: o CLI pergunta aqui antes de deixar o produtor
- * começar. Pedir "só o roteiro" NÃO liga a produção — quem pediu texto quer
- * texto, e devolver um mp4 é ignorar a pessoa.
- */
-function precisaDeProducao(texto) {
-    const t = String(texto || '');
-    if (!t.trim()) return { producao: false };
-    if (SO_TEXTO.test(t)) return { producao: false, motivo: 'pediu só o texto' };
-    if (PEDE_VIDEO.test(t)) return { producao: true, formato: 'video', motivo: 'o pedido é de vídeo' };
-    if (PEDE_SLIDE.test(t)) return { producao: true, formato: 'apresentacao', motivo: 'o pedido é de apresentação' };
-    return { producao: false };
-}
-
-/* Editar a GRAVAÇÃO da pessoa não é produzir vídeo do zero: aí o caminho é o
-   editor por linha do tempo (`primocode video`, lib/video/), não o roteiro. */
-const PEDE_EDICAO = /\b(edit[ae]r?|edi[cç][aã]o|cort[ae]r?|legend[ae]r?|tir[ae]r?\s+(o|os)\s+sil[eê]ncios?)\b[\s\S]{0,80}\b(grava[cç][aã]o|meu\s+v[ií]deo|esse\s+v[ií]deo|este\s+v[ií]deo|[\w-]+\.(mp4|mov|mkv|webm|m4v))\b|\b[\w-]+\.(mp4|mov|mkv|webm|m4v)\b[\s\S]{0,80}\b(edit|cort|legend|sil[eê]nci)/i;
-
-/* Os pedidos de EFEITO sobre a gravação (lib/video/ops-fx.js): fundo, camadas,
-   estalo, objeto na mão, legenda na cabeça. Falam da pessoa ("me", "minha
-   mão"), não do arquivo — por isso não casavam com a regra de cima. */
-const PEDE_EFEITO = /\b(tir[ae]r?|remov\w*|troc\w*)\s+(o\s+)?fundo\b|\bsepar\w*\s+em\s+camadas\b|\bestal\w*\s+(o\s+)?dedo\b|\b(logo|objeto)\b[\s\S]{0,40}\bm[aã]os?\b|\bjunt\w*\s+as\s+m[aã]os\b|\blegenda\b[\s\S]{0,40}\b(azul|vermelh|verde|amarel|rosa|roxa|branc|cabe[cç]a|em cima|embaixo)/i;
-
-/* "edite: /Users/…/Fototeca do Photo Booth/…/Filme em 30-09-2026 às 23.56.mov": o caminho
-   do Photo Booth tem mais de 80 caracteres, e o pedido ia para o Estúdio de
-   motion — que tratava a gravação como b-roll (01/10). Verbo de editar + um
-   arquivo de vídeo em qualquer lugar da frase é edição. */
-const EDITA_ARQUIVO = /\b(edit\w*|edi[cç][aã]o|p[oõ]e\s+(ele\s+)?pra\s+editar)\b[\s\S]*\.(mp4|mov|mkv|webm|m4v)\b|\.(mp4|mov|mkv|webm|m4v)\b[\s\S]*\b(edit\w*|edi[cç][aã]o)\b/i;
-
-/* A gravação da pessoa FALANDO, sem caminho de arquivo na frase (20/10, a edição completa do
-   editor_pro): "edita meu vídeo", "faz um reels disso", "coloca legenda e efeitos nele". Fala de
-   uma gravação que JÁ existe ("disso", "meu vídeo", "nele"), não de criar um vídeo do zero. */
-const PEDE_EDICAO_FALADA = /\bedit\w*\s+(o\s+|esse\s+|este\s+)?(meu\s+)?(v[ií]deo|grava[cç][aã]o)\s+(meu|que\s+eu\s+gravei)\b|\bedit\w*\s+(o\s+)?meu\s+v[ií]deo\b|\b(faz|fa[cç]a|transform\w*|vir\w*)\s+(um\s+|uma\s+|em\s+)?(reels?|tiktok|shorts?|criativo|corte)\s+(disso|desse|dessa|deste|desta|com\s+(esse|essa|este|esta|a\s+minha|o\s+meu))\b|\bcoloc\w*\s+(uma\s+)?legendas?\s+e\s+(uns\s+)?efeitos?\b|\b(legend\w*|efeitos?)\b[\s\S]{0,30}\b(no\s+meu\s+v[ií]deo|na\s+minha\s+grava[cç][aã]o|nele|nessa\s+grava[cç][aã]o)\b/i;
-
-function precisaDeEdicao(texto) {
-    const t = String(texto || '');
-    return PEDE_EDICAO.test(t) || PEDE_EFEITO.test(t) || EDITA_ARQUIVO.test(t) || PEDE_EDICAO_FALADA.test(t);
-}
-
-// ── 2. as decisões que não são do modelo ─────────────────────────────────
-
-/**
- * A voz. Tom e idioma decidem; o nome exato quem resolve é o estúdio, que
- * sabe o que está instalado — aqui sai a INTENÇÃO, que é o que o diretor
- * precisa escrever no plano.
- */
-function vozPara({ tom = 'neutro', idioma = 'pt-BR', genero } = {}) {
-    const t = String(tom).toLowerCase();
-    const perfil = /urgente|energ|hype|an[uú]ncio|venda/.test(t) ? 'energica'
-        : /calm|institucional|corporativ|s[eé]ri/.test(t) ? 'firme'
-            : /doc|narrativ|hist[oó]ria|documental/.test(t) ? 'grave'
-                : /leve|simp[aá]tic|amig|casual/.test(t) ? 'proxima'
-                    : 'neutra';
-    const ritmo = perfil === 'energica' ? 1.08 : perfil === 'grave' ? 0.94 : 1;
-    return { perfil, idioma, genero: genero || 'indiferente', ritmo,
-        instrucao: {
-            energica: 'projeção alta, frases curtas, corte seco entre elas',
-            firme: 'ritmo constante, sem exagero, pausa depois do número',
-            grave: 'grave e pausada, respira entre as frases',
-            proxima: 'como quem conversa, sorriso na voz',
-            neutra: 'clara e neutra, sem cor demais',
-        }[perfil] };
-}
-
-/** Quantas cenas cabem, e de que tamanho, num vídeo desta duração. */
-function ritmoPara(segundos) {
-    const s = Math.max(5, Number(segundos) || 30);
-    // (15/10) As referências cortam a cada 1 a 2 s; o PrimoCode pedia 2,6 a 5 s e saía lento.
-    const media = s <= 20 ? 1.8 : s <= 45 ? 2.2 : s <= 90 ? 2.6 : 3;
-    return { cenas: Math.max(3, Math.round(s / media)), duracaoMedia: media,
-        palavrasPorCena: Math.round(media * 2.6) };   // ~155 palavras/minuto de narração
-}
-
-// ── 2b. a estrutura: um cardápio, e a memória do que já saiu ─────────────
-
-/* "o roteiro vicia: todo vídeo começa igual, não escolhe outra estrutura"
-   (Joel, 09/10). A regra 3 do diretor tinha UM arco só — prende em 2
-   segundos, entrega, pede ação — e o produtor nem isso via: todo roteiro
-   saía com a mesma abertura de impacto e o mesmo miolo de lista. Aqui não
-   tem regex escolhendo pelo pedido: o modelo recebe o CARDÁPIO (cada
-   estrutura com o "quando serve" e o jeito de abrir) e o que os últimos
-   vídeos já usaram. Quem escolhe é ele; o código só lembra. */
-const ESTRUTURAS = [
-    { id: 'historia', nome: 'história', quando: 'tem uma pessoa, um caso real ou um antes e depois', abre: 'uma cena concreta: alguém, um lugar, um momento ("Às 6h, a Ana abriu o caixa e…")' },
-    { id: 'problema-solucao', nome: 'problema → solução', quando: 'o assunto resolve uma dor clara', abre: 'a dor dita como quem sente ("Você perde duas horas por semana com…")' },
-    { id: 'lista', nome: 'lista', quando: 'são dicas, razões ou passos que se sustentam sozinhos', abre: 'a promessa com o número ("3 erros que…")' },
-    { id: 'pergunta-resposta', nome: 'pergunta → resposta', quando: 'o público já tem uma dúvida', abre: 'a pergunta, direta, sem a resposta ainda' },
-    { id: 'dialogo', nome: 'diálogo', quando: 'o pedido fala em duas pessoas, duas vozes, conversa ou entrevista', abre: 'a fala de um, e o outro responde' },
-    { id: 'demonstracao', nome: 'demonstração', quando: 'o valor está em VER funcionando', abre: 'o resultado pronto primeiro; depois, como se chega lá' },
-    { id: 'mito-verdade', nome: 'contraste (mito × verdade)', quando: 'existe uma crença comum que está errada', abre: 'o mito, dito como se fosse verdade' },
-    { id: 'dado-surpresa', nome: 'dado que surpreende', quando: 'há um número que muda o jeito de ver o assunto', abre: 'o número sozinho, e a frase que diz por que ele importa' },
-];
-
-const vari = () => require('./variedade.js');   // tardio: a memória mora em ~/.primocode/studio
-const idEstrutura = (x) => String(x || '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '')
-    .replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 40);
-
-/** As últimas estruturas e aberturas que saíram em vídeo, mais nova primeiro. */
-function recentes(n = 3) {
-    return { estruturas: vari().usadas('estrutura').slice(0, n), aberturas: vari().usadas('abertura').slice(0, n) };
-}
-
-/** O cardápio em texto, para o prompt — com o que foi usado por último. */
-function cardapioEstruturas({ usadas = recentes() } = {}) {
-    const linhas = ESTRUTURAS.map((e) => `- ${e.id} (${e.nome}): se ${e.quando}. Abre com ${e.abre}.`);
-    if (usadas.estruturas.length) linhas.push(`Usadas recentemente: ${usadas.estruturas.join(', ')} — prefira outra, a menos que o pedido peça essa.`);
-    if (usadas.aberturas.length) linhas.push(`Os últimos vídeos começaram assim: ${usadas.aberturas.map((a) => `"${a}"`).join(' · ')} — não comece do mesmo jeito.`);
-    linhas.push('Nenhuma serve? Invente a estrutura e dê um nome a ela.');
-    return 'CARDÁPIO DE ESTRUTURAS (você escolhe pelo pedido):\n' + linhas.join('\n');
-}
-
-/**
- * Depois que o roteiro virou plano: guarda a estrutura que o modelo escolheu
- * e como o vídeo abriu. Aceita o roteiro (partes/fala) ou o plano do diretor
- * (cenas/narracao). Não julga a escolha — só lembra dela.
- */
-function registrarEstrutura(r) {
-    const x = r && typeof r === 'object' ? r : {};
-    const estrutura = idEstrutura(x.estrutura) || null;
-    const p0 = (x.partes || x.cenas || [])[0] || {};
-    const abertura = String(p0.fala || p0.narracao || p0.titulo || '').split(/\s+/).filter(Boolean).slice(0, 8).join(' ') || null;
-    if (estrutura) vari().marcar('estrutura', estrutura);
-    if (abertura) vari().marcar('abertura', abertura);
-    return { estrutura, abertura };
-}
-
-// ── 3. o plano ───────────────────────────────────────────────────────────
-
-const CAMPOS_CENA = ['titulo', 'falante', 'narracao', 'duracao', 'aTela', 'fundo', 'transicao',
-    'elementos', 'midia', 'camera', 'chaves', 'notas'];
-
-/**
- * Normaliza o que o diretor devolveu e aponta o que ficou faltando.
- *
- * Não conserta conteúdo — conteúdo é dele. Conserta FORMA: duração que virou
- * string, cena sem transição, o total que não fecha com o pedido. E lista os
- * defeitos que só o diretor resolve (cena muda, narração vazia), para voltar
- * com o apontamento em vez de seguir com o plano torto.
- */
-function normalizarPlano(bruto, { segundos } = {}) {
-    const p = bruto && typeof bruto === 'object' ? bruto : {};
-    const defeitos = [];
-    const cenas = Array.isArray(p.cenas) ? p.cenas : [];
-    if (!cenas.length) defeitos.push('o plano veio sem cenas');
-
-    const limpas = cenas.map((c, i) => {
-        const cena = {};
-        for (const k of CAMPOS_CENA) if (c && c[k] !== undefined) cena[k] = c[k];
-        cena.duracao = Math.max(1.2, Math.min(15, Number(cena.duracao) || 3.5));
-        cena.narracao = typeof cena.narracao === 'string' ? cena.narracao.trim() : '';
-        if (!cena.narracao) defeitos.push(`cena ${i + 1} sem narração`);
-        if (!cena.titulo && !cena.aTela && !cena.elementos) defeitos.push(`cena ${i + 1} sem nada na tela`);
-        /* A transição é texto: "o logo desce e o fundo abre com ele", não um
-           item de lista. O rodízio que havia aqui (fade, deslizar, subir…
-           em ordem) escondia o defeito em vez de apontá-lo: preenchia a
-           lacuna com a próxima palavra da fila, e o vídeo saía com oito
-           transições que ninguém escolheu. Cena sem transição é DEFEITO, e
-           volta para o diretor decidir. */
-        cena.transicao = typeof cena.transicao === 'string' ? cena.transicao.trim() : '';
-        if (!cena.transicao) defeitos.push(`cena ${i + 1} não diz como entra`);
-        cena.midia = Array.isArray(cena.midia) ? cena.midia.filter((m) => m && m.busca) : [];
-        return cena;
-    });
-
-    const total = Math.round(limpas.reduce((s, c) => s + c.duracao, 0) * 10) / 10;
-    const alvo = Number(segundos) || Number(p.segundos) || total;
-    // 20% de folga: o alvo é intenção, não cronômetro. Fora disso o vídeo
-    // entrega outra coisa — 12 segundos onde pediram 40.
-    const fecha = !alvo || Math.abs(total - alvo) <= Math.max(3, alvo * 0.2);
-    if (!fecha) defeitos.push(`a soma das cenas dá ${total}s e o pedido é ${alvo}s`);
-
-    if (!String(p.visual || '').trim()) defeitos.push('o plano não diz a direção de arte (visual): paleta, ar e tipografia');
-
-    const plano = {
-        titulo: String(p.titulo || '').trim() || 'Sem título',
-        formato: p.formato === 'apresentacao' ? 'apresentacao' : 'video',
-        proporcao: ['16:9', '9:16', '1:1', '4:5'].includes(p.proporcao) ? p.proporcao : '16:9',
-        visual: String(p.visual || '').trim() || null,
-        tom: p.tom || 'neutro',
-        publico: p.publico || null,
-        promessa: p.promessa || null,          // o que a pessoa leva do vídeo
-        estrutura: idEstrutura(p.estrutura) || null,
-        segundos: total,
-        voz: vozPara({ tom: p.tom, idioma: p.idioma || 'pt-BR',
-            genero: p.voz && p.voz.genero }),
-        trilha: p.trilha && (p.trilha.busca || p.trilha.arquivo)
-            ? { busca: p.trilha.busca || null, arquivo: p.trilha.arquivo || null,
-                volume: Number(p.trilha.volume) || 0.18, humor: p.trilha.humor || p.tom || null }
-            : null,
-        cenas: limpas,
-        midia: limpas.flatMap((c, i) => c.midia.map((m) => ({ cena: i + 1, ...m }))),
-        creditos: !!p.creditos,
-    };
-    // Duas vozes (falantes.js): o mapa e quem fala cada cena, quando o diretor escreveu diálogo.
-    const { vozes } = require('./falantes.js').normalizar({ vozes: p.vozes, partes: limpas });
-    if (vozes) plano.vozes = vozes;
-    return { plano, defeitos, ok: defeitos.length === 0 };
-}
-
-// ── 4. o prompt do diretor ───────────────────────────────────────────────
-
-const DIRETOR = (pedido, { segundos = 30, formato = 'video', contexto = '' } = {}) => {
-    const r = ritmoPara(segundos);
-    return `Você é o DIRETOR de conteúdo. Você NÃO produz nada: você ESTRUTURA, e outra IA produz a partir do que você escrever. Não escreva código, não escreva JSON de cena de ferramenta, não chame ferramenta nenhuma.
-
-PEDIDO: ${pedido}
-${contexto ? `CONTEXTO: ${contexto}\n` : ''}FORMATO: ${formato} · DURAÇÃO ALVO: ${segundos}s · RITMO: ~${r.cenas} cenas de ~${r.duracaoMedia}s (~${r.palavrasPorCena} palavras de narração por cena)
-
-Devolva SÓ um bloco \`\`\`json com este formato, sem texto antes nem depois:
-
-{
-  "titulo": "…",
-  "estrutura": "o id que você escolheu no cardápio abaixo (ou o nome da que inventou)",
-  "formato": "${formato}",
-  "proporcao": "16:9 | 9:16 | 1:1 | 4:5",
-  "visual": "a direção de arte em uma ou duas frases: paleta (diga as cores em hex), que ar tem (limpo, denso, luminoso, sujo), que tipografia pede. NÃO existe lista de temas — descreva o que este vídeo tem de próprio.",
-  "tom": "como deve soar (institucional, urgente, documental, leve…)",
-  "publico": "para quem é",
-  "promessa": "o que a pessoa leva ao terminar de ver",
-  "trilha": { "busca": "termo de busca da música", "humor": "…", "volume": 0.18 },
-  "vozes": { "nome de quem fala": "antonio | thalita | francisca" },
-  "cenas": [
-    {
-      "titulo": "o que aparece grande na tela",
-      "falante": "quem fala esta cena (um nome de vozes) — só quando houver mais de uma voz",
-      "narracao": "a frase FALADA, escrita para ser lida em voz alta",
-      "duracao": 3.5,
-      "aTela": "o que se vê nesta cena, descrito como você descreveria para um motion designer: onde está cada coisa, que tamanho tem, o que domina o quadro",
-      "fundo": "o fundo desta cena — uma cor, um gradiente (diga as cores), uma imagem da lista midia, ou o que ele vira no meio da cena",
-      "transicao": "como esta cena ENTRA, descrito: o que se move, em que direção, quanto dura. Corte seco também é resposta — diga 'corte'.",
-      "midia": [ { "busca": "o que procurar", "tipo": "imagem | logo", "papel": "fundo | destaque | selo", "semFundo": false } ],
-      "camera": "aproximar | afastar | pan-direita | pan-esquerda | subir | descer | empurrar | balanco | nenhuma",
-      "chaves": "descreva em uma frase o movimento principal desta cena (o que entra, o que atravessa, o que cresce)",
-      "notas": "o que o produtor precisa saber e não está acima"
-    }
-  ]
-}
-
-REGRAS QUE SEPARAM UM VÍDEO BOM DE UM GENÉRICO:
-1. NARRAÇÃO É FALA, NÃO LEGENDA. "Vantagens" não é narração. Escreva a frase que a pessoa ouve.
-2. O QUE SE OUVE E O QUE SE VÊ NÃO SE REPETEM. A tela mostra a prova (número, imagem, logo); a voz conta o que ela significa.
-3. ESTRUTURA. Escolha no cardápio do fim a que serve a ESTE pedido; a primeira cena abre do jeito dela e prende em 2 segundos, a última pede uma ação. Sem "Introdução / Desenvolvimento / Conclusão".
-4. NÚMERO É CONCRETO. Nada de "muitos clientes": ou tem o número, ou a frase muda.
-5. RITMO VARIADO. Cenas de durações diferentes e transições diferentes. Tudo em fade parece slide.
-5b. NADA DE GAVETA. Não existe tema pronto, layout pronto nem fundo pronto: é você que decide a cor, a tipografia e a composição DESTE vídeo. Dois vídeos seus sobre assuntos diferentes não podem sair parecidos.
-6. MÍDIA COM PROPÓSITO. Só peça imagem ou logo quando ela PROVA algo. Diga o termo de busca de verdade ("painel solar em telhado residencial", não "imagem legal").
-6b. CADA FRASE PEDE UMA ROTA DE IMAGEM, nesta ordem: número ou citação → nenhuma (a tipografia é a imagem); fala do produto → a tela ou a logo dele; coisa concreta → o vídeo DELA, com a busca no substantivo ("espresso cup", não a frase inteira); ideia abstrata → textura que se move. A imagem entra logo DEPOIS da palavra que a nomeia, nunca antes.
-7. MOVIMENTO. Em cada cena diga em "chaves" o movimento principal — é ele que tira a cara de apresentação parada.
-8. CÂMERA COM PARCIMÔNIA. Movimento de quadro em UMA cena a cada duas ou três ("camera": "nenhuma" nas outras): o que dá ritmo é alternar cena parada e cena que se move. Em cena com foto de fundo, prefira "aproximar" ou "empurrar".
-9. UMA VOZ OU DUAS. Se o pedido fala em dois narradores, duas vozes, diálogo, conversa ou entrevista, escreva como DIÁLOGO: dê nome a cada um em "vozes" (com vozes diferentes) e diga em cada cena quem fala ("falante"). Com uma voz só, deixe "vozes" e "falante" de fora.
-
-${cardapioEstruturas()}`;
-};
-
-const REVISAO = (defeitos) => `O plano voltou com defeitos de FORMA. Corrija SÓ o que está listado e devolva o JSON inteiro de novo, no mesmo formato:
-
-${defeitos.map((d) => '- ' + d).join('\n')}
-
-Nada de explicação: só o bloco \`\`\`json.`;
-
-/** Tira o JSON do que o modelo escreveu, com ou sem cerca. */
-function extrairJSON(texto) {
-    const t = String(texto || '');
-    const cerca = t.match(/```(?:json)?\s*([\s\S]*?)```/i);
-    const cru = cerca ? cerca[1] : t.slice(t.indexOf('{'), t.lastIndexOf('}') + 1);
-    try { return JSON.parse(cru); } catch { /* tenta limpar vírgula sobrando */ }
-    try { return JSON.parse(String(cru).replace(/,\s*([}\]])/g, '$1')); } catch { return null; }
-}
-
-/**
- * Roda o diretor: uma conversa própria, o plano de volta, conferido, e uma
- * segunda chance quando a forma não fecha.
- *
- * @param {object} op
- * @param {string} op.pedido
- * @param {(prompt:string, papel:string)=>Promise<string>} op.correr  uma conversa NOVA
- * @param {number} [op.segundos]
- * @param {(s:string)=>void} [op.mostrar]
- */
-async function planejar({ pedido, correr, segundos = 30, formato = 'video',
-    contexto = '', mostrar = () => {} } = {}) {
-    if (!pedido) return { ok: false, error: 'Diga o que produzir.' };
-    if (typeof correr !== 'function') return { ok: false, error: 'sem quem rode o diretor' };
-
-    mostrar('diretor — roteiro, narração e voz');
-    let bruto = extrairJSON(await correr(DIRETOR(pedido, { segundos, formato, contexto }), 'diretor'));
-    if (!bruto) return { ok: false, error: 'o diretor não devolveu um plano legível' };
-
-    let { plano, defeitos, ok } = normalizarPlano({ ...bruto, pedido }, { segundos });
-    if (!ok) {
-        mostrar('diretor — corrigindo o plano');
-        const segunda = extrairJSON(await correr(REVISAO(defeitos), 'diretor (revisão)'));
-        if (segunda) {
-            const r2 = normalizarPlano({ ...segunda, pedido }, { segundos });
-            // Fica com o melhor dos dois: a segunda volta só vale se corrigiu.
-            if (r2.defeitos.length <= defeitos.length) ({ plano, defeitos, ok } = r2);
-        }
-    }
-    return { ok: true, plano, defeitos, aprovado: defeitos.length === 0 };
-}
-
-/**
- * O plano vira a PAUTA do produtor — o texto que a IA de produção recebe no
- * lugar do pedido cru. Ela não precisa mais decidir o que contar: só montar.
- */
-function pauta(plano) {
-    const p = plano || {};
-    const linhas = [];
-    linhas.push(`PLANO DE PRODUÇÃO — ${p.titulo}`);
-    linhas.push(`formato ${p.formato} · ${p.proporcao} · ${p.segundos}s · tom ${p.tom}`);
-    if (p.visual) linhas.push(`visual: ${p.visual}`);
-    if (p.estrutura) linhas.push(`estrutura: ${p.estrutura} (mande em roteiro.estrutura)`);
-    if (p.promessa) linhas.push(`promessa: ${p.promessa}`);
-    if (p.publico) linhas.push(`público: ${p.publico}`);
-    linhas.push(`voz: ${p.voz && p.voz.perfil} · ${p.voz && p.voz.instrucao} · ${p.voz && p.voz.idioma}`);
-    if (p.vozes) linhas.push(`vozes: ${Object.entries(p.vozes).map(([k, v]) => `${k} = ${v}`).join(', ')} (mande em roteiro.vozes, e falante em cada parte)`);
-    if (p.trilha) linhas.push(`trilha: ${p.trilha.busca || p.trilha.arquivo} (volume ${p.trilha.volume})`);
-    linhas.push('');
-    (p.cenas || []).forEach((c, i) => {
-        linhas.push(`CENA ${i + 1} — ${c.duracao}s · entra: ${c.transicao}`);
-        if (c.titulo) linhas.push(`  na tela: ${c.titulo}`);
-        if (c.aTela) linhas.push(`  composição: ${c.aTela}`);
-        if (c.fundo) linhas.push(`  fundo: ${typeof c.fundo === 'string' ? c.fundo : JSON.stringify(c.fundo)}`);
-        linhas.push(`  narração${c.falante ? ` (${c.falante})` : ''}: ${c.narracao}`);
-        if (c.camera && c.camera !== 'nenhuma') linhas.push(`  câmera: ${c.camera}`);
-        if (c.chaves) linhas.push(`  movimento: ${c.chaves}`);
-        (c.midia || []).forEach((m) => linhas.push(
-            `  mídia: ${m.tipo || 'imagem'} "${m.busca}" como ${m.papel || 'destaque'}${m.semFundo ? ' (sem fundo)' : ''}`));
-        if (c.notas) linhas.push(`  nota: ${c.notas}`);
-        linhas.push('');
-    });
-    linhas.push('Produza EXATAMENTE este plano. As decisões de conteúdo já foram tomadas:');
-    linhas.push('não invente cena, não troque a ordem, não reescreva a narração.');
-    return linhas.join('\n');
-}
-
-module.exports = {
-    precisaDeProducao, precisaDeEdicao, vozPara, ritmoPara,
-    ESTRUTURAS, recentes, cardapioEstruturas, registrarEstrutura,
-    normalizarPlano, extrairJSON, planejar, pauta,
-    DIRETOR, REVISAO,
-};