primocode 11.4.0 → 11.5.0

package/lib/permissao-sistema.js

@@ -0,0 +1,60 @@
+/**
+ * permissao-sistema.js — falta permissão do macOS: parar na PRIMEIRA falha.
+ *
+ * O que aconteceu: sem Acessibilidade/Gravação de Tela, o agente tentava abrir o
+ * navegador, falhava, e tentava de novo (5+ vezes) — cada volta com o mesmo erro.
+ * Aqui o erro é reconhecido, vira uma frase clara ("falta a permissão X") e o laço
+ * do agente (act.js) para na hora. No app desktop, a linha de protocolo
+ * `primocode:permissao <id>` no stderr abre a tela de permissões.
+ *
+ * Puro de propósito: sem I/O, o teste mede a política inteira.
+ */
+
+'use strict';
+
+/** As ferramentas que mexem no computador: só nelas um erro vira "falta permissão". */
+const FERRAMENTA_DE_COMPUTADOR = /^(desktop_|browser_|open_in_browser$)/;
+
+const NOMES = { accessibility: 'Acessibilidade', screen: 'Gravação de Tela', automation: 'Automação' };
+
+/** Texto de erro do macOS → qual permissão falta. A ordem importa: a mais específica primeiro. */
+const PADROES = [
+    ['automation', /-1743|not authori[sz]ed to send apple events|apple events? (is|are) not allowed/i],
+    ['accessibility', /-25211|-1719|-1002|not allowed assistive access|assistive access|is not allowed to send keystrokes|osascript[^\n]*n(ã|a)o tem permiss(ã|a)o|acessibilidade/i],
+    ['screen', /could not create image from display|screen ?recording|grava(ç|c)(ã|a)o de tela|not authori[sz]ed to capture screen/i],
+];
+
+function ehFerramentaDeComputador(nome) {
+    return FERRAMENTA_DE_COMPUTADOR.test(String(nome || ''));
+}
+
+/** Qual permissão falta, ou null. Só vale no macOS e para resultado com ok === false. */
+function detectar(nome, resultado, plataforma = process.platform) {
+    if (plataforma !== 'darwin' || !ehFerramentaDeComputador(nome)) return null;
+    if (!resultado || resultado.ok !== false) return null;
+    const texto = [resultado.error, resultado.stderr, resultado.message].filter(Boolean).join('\n');
+    if (!texto) return null;
+    for (const [id, re] of PADROES) if (re.test(texto)) return id;
+    return null;
+}
+
+/** A frase que volta pro modelo e pra pessoa. Diz o que fazer e proíbe tentar de novo. */
+function mensagem(id) {
+    const nome = NOMES[id] || id;
+    return `Falta a permissão ${nome} do macOS. Abri a tela de permissões do PrimoCode: ative ${nome} e peça de novo. `
+        + 'NÃO tente outra vez nem outra ferramenta de computador/navegador até a pessoa ativar.';
+}
+
+const PROTOCOLO = 'primocode:permissao';
+const linhaProtocolo = (id) => `${PROTOCOLO} ${id}\n`;
+function idDaLinha(linha) {
+    const m = String(linha || '').trim().match(/^primocode:permissao (accessibility|screen|automation)$/);
+    return m ? m[1] : null;
+}
+
+/** O resultado trocado: mesmo `ok:false`, erro claro e a marca `permissao`. */
+function comoErro(id, resultado) {
+    return { ...resultado, ok: false, permissao: id, error: mensagem(id) };
+}
+
+module.exports = { detectar, mensagem, comoErro, linhaProtocolo, idDaLinha, ehFerramentaDeComputador, NOMES, PADROES, PROTOCOLO };

package/lib/permission/perigo.js

@@ -350,6 +350,7 @@ async function portao(estado, { modo, nome, args, projectDir, subagent = false,
     const travado = trava.recusa(nome, args, projectDir);
     if (travado) return { ok: false, motivo: travado.motivo, error: travado.error };
     if (m === 'livre') return { ok: true };
+    if (m !== 'plano' && require('./sem-perguntar.js').ativo()) return { ok: true };   // --yolo: sem perguntas (o modo plano continua só lendo)
     if (m === 'plano') {
         const mexe = ESCRITAS.has(nome) || nome === 'mcp_conectar'
             || (COMANDOS.has(nome) && !somenteLeitura((args || {}).command));

package/lib/permission/permissao.js

@@ -93,6 +93,7 @@ function descrever(nome, args) {
  */
 async function pedir(estado, nome, args, perguntar) {
     if (!precisa(nome)) return { ok: true };
+    if (require('./sem-perguntar.js').ativo()) return { ok: true };   // --yolo: sem perguntas
     if (estado.liberado) return { ok: true };
 
     /* Negar uma vez vale para a sessão. Sem isto, quem disse não leva a mesma

package/lib/permission/sem-perguntar.js

@@ -0,0 +1,29 @@
+/**
+ * sem-perguntar.js — o modo `--dangerously-skip-permissions` (alias `--yolo`).
+ *
+ * Com ele o PrimoCode não pede confirmação nenhuma: controle do computador,
+ * comando perigoso, troca de pasta, servidor MCP do projeto. Vale por variável
+ * de ambiente (PRIMOCODE_SEM_PERGUNTAR=1) para chegar aos subprocessos e ao
+ * motor do desktop. Sem a variável, nada muda.
+ *
+ * Duas coisas continuam valendo de propósito: o /lock (arquivo travado só se
+ * lê) e a recusa de escrever fora da pasta do projeto (lib/tool/tools.js).
+ */
+'use strict';
+
+const FLAGS = ['--dangerously-skip-permissions', '--yolo'];
+const AVISO = 'modo sem perguntas: o PrimoCode vai agir sem pedir confirmação';
+
+function ativo() { return process.env.PRIMOCODE_SEM_PERGUNTAR === '1'; }
+
+/** Tira a flag do argv (muta) e liga a variável. Devolve true se estava lá. */
+function consumir(argv) {
+    let achou = false;
+    for (let i = argv.length - 1; i >= 2; i--) {
+        if (FLAGS.includes(argv[i])) { argv.splice(i, 1); achou = true; }
+    }
+    if (achou) process.env.PRIMOCODE_SEM_PERGUNTAR = '1';
+    return achou;
+}
+
+module.exports = { ativo, consumir, FLAGS, AVISO };

package/lib/plugin/desktop.js

@@ -35,12 +35,13 @@ const TOOLS = {
 function run(cmd, opts = {}) {
     try {
         execSync(cmd, {
-            stdio: 'ignore',
+            stdio: ['ignore', 'ignore', 'pipe'],
             timeout: opts.timeout || 15000,
             env: opts.env ? { ...process.env, ...opts.env } : undefined,
         });
         return { ok: true };
-    } catch (e) { return { ok: false, error: e.message }; }
+    // o stderr entra no erro: é nele que o macOS diz "falta permissão" (lib/permissao-sistema.js)
+    } catch (e) { return { ok: false, error: [e.message, String((e && e.stderr) || '').trim()].filter(Boolean).join('\n') }; }
 }
 
 // Igual ao run(), mas devolve o stdout — para os comandos que PERGUNTAM algo
@@ -49,12 +50,12 @@ function runOut(cmd, opts = {}) {
     try {
         const out = execSync(cmd, {
             encoding: 'utf-8',
-            stdio: ['ignore', 'pipe', 'ignore'],
+            stdio: ['ignore', 'pipe', 'pipe'],
             timeout: opts.timeout || 15000,
             env: opts.env ? { ...process.env, ...opts.env } : undefined,
         });
         return { ok: true, out: String(out || '') };
-    } catch (e) { return { ok: false, error: e.message, out: String((e && e.stdout) || '') }; }
+    } catch (e) { return { ok: false, error: [e.message, String((e && e.stderr) || '').trim()].filter(Boolean).join('\n'), out: String((e && e.stdout) || '') }; }
 }
 
 // Argumento de shell entre aspas simples, à prova de apóstrofo. O truque

package/lib/plugin/estudio/cota.js

@@ -143,10 +143,12 @@ async function comCota(render, deps = {}) {
     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);
+    // a marca d'água do PrimoCode só entra no vídeo do usuário se ELE pediu (Joel, 13/11): `deps.marca` vem do pedido; o teto de resolução segue valendo
+    const rec = deps.marca ? c.recursos : { ...c.recursos, marcaDagua: false };
+    const a = c.offline ? { ok: true, mudou: false } : (deps.aplicar || aplicar)(r.video, rec);
     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) },
+    return { ...r, plano: { id: c.plano, restam, resolucao: c.recursos.resolucao, marcaDagua: !!(a.mudou && rec.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];

package/lib/plugin/estudio/dialogo3d.js

@@ -0,0 +1,71 @@
+/**
+ * dialogo3d.js — os personagens falando, pela MESMA estrutura da maquete (kits/3d).
+ *
+ * Pega a partitura que o personagem.js já faz (quem fala, quando, o lugar, o elenco)
+ * e a traduz num roteiro por etapas para o montador: uma etapa por fala, a câmera
+ * no falante, a boca na palavra, o gesto da fala. Versão SIMPLES: sem cartões, sem
+ * planos de filme. O caminho antigo (kit/personagem.jsx) continua intacto; este só
+ * entra quando o roteiro pede `motor: 'montador'`.
+ *
+ * Render: `node kits/3d/render.mjs roteiro3d.json saida.mp4 --audio voz.mp3 --audio-pronto`.
+ */
+'use strict';
+
+// A animação da biblioteca para o gesto que o personagem.js escolheu (acaoDe) e a emoção.
+const GESTO = { falar: 'falar', acenar: 'falar', apontar: 'apontar', pular: 'comemorar', dancar: 'comemorar', comemorar: 'comemorar', pensar: 'pensar', andar: 'falar', correr: 'falar', sentar: 'falar' };
+const EMOCAO = { surpreso: 'surpreso', pensativo: 'pensar' };
+
+const r2 = (x) => Math.round(x * 100) / 100;
+const XS = { 1: [0], 2: [-1.25, 1.25], 3: [-2.2, 0, 2.2], 4: [-3.3, -1.1, 1.1, 3.3] };
+
+/** A aparência de um membro do elenco na biblioteca (boneco único; robô e bicho viram cor). */
+function pecaDoElenco(e, i, n) {
+    const x = XS[Math.min(4, Math.max(1, n))][i];
+    const base = { id: `p${i}`, tipo: 'personagem', pos: [x, 0, 0], giro: r2(-x * 0.16), escala: 1 };
+    if (e.tipo === 'pessoa') return { ...base, pele: e.pele, roupa: e.roupa, cabelo: e.corCabelo };
+    if (e.tipo === 'robo') return { ...base, pele: e.cor || '#dd5a2b', roupa: '#cfd6df', calca: '#8b95a3', capacete: e.cor || '#dd5a2b' };
+    return { ...base, pele: e.cor || '#c8a27a', roupa: e.cor || '#c8a27a', escala: 0.85 };   // bicho/coisa: boneco na cor dele
+}
+
+/** O lugar (mundo.js) em peças da biblioteca: chão, árvores, casas e prédios. O resto do catálogo antigo fica de fora. */
+function cenarioDoMundo(m) {
+    const pecas = [{ id: 'chao', tipo: 'terreno', w: 80, d: 80, cor: (m.chao && m.chao.cor) || '#b99362' }];
+    (m.props || []).forEach((p, i) => {
+        const base = { id: `c${i}`, pos: [p.x, 0, Math.min(p.z, -2.5)], giro: p.giro || 0 };
+        if (/^(arvore|palmeira|arbusto)$/.test(p.peca)) pecas.push({ ...base, tipo: 'arvore', escala: p.escala || 1, forma: 'redonda' });
+        else if (/^pinheiro/.test(p.peca)) pecas.push({ ...base, tipo: 'arvore', escala: p.escala || 1, forma: 'pinheiro' });
+        else if (p.peca === 'casa' || p.peca === 'celeiro') pecas.push({ ...base, tipo: 'casa', escala: p.escala || 1 });
+        else if (p.peca === 'predio') pecas.push({ ...base, tipo: 'predio', andares: 4 + (i % 4), pos: [p.x, 0, Math.min(p.z, -6)] });
+    });
+    return pecas;
+}
+
+/**
+ * @param {object} partitura  a saída de personagem.partituraDe
+ * @returns {object} roteiro do montador (JSON puro)
+ */
+function roteiroDeDialogo(partitura) {
+    const elenco = partitura.elenco, falas = partitura.falas;
+    const pecas = elenco.map((e, i) => pecaDoElenco(e, i, elenco.length));
+    const mundo = (partitura.mundos && partitura.mundos[0]) || {};
+    const ceu = mundo.dentro ? [mundo.parede || '#e6d6c3', mundo.parede || '#e6d6c3'] : (mundo.ceu || ['#8fd0ff', '#d8efff']);
+    const etapas = falas.map((f, i) => {
+        const ini = i === 0 ? 0 : r2(falas[i].de - 0.25);
+        const fim = i === falas.length - 1 ? partitura.duracao : r2(falas[i + 1].de - 0.25);
+        const dur = r2(Math.max(0.5, fim - ini)), x = pecas[f.quem].pos[0];
+        const amplo = i === 0 || (elenco.length > 1 && i % 4 === 0);
+        const gesto = EMOCAO[f.emocao] || GESTO[f.acao] || 'falar';
+        return {
+            id: `fala${i}`, dur, titulo: elenco[f.quem].rotulo || elenco[f.quem].nome, legenda: f.texto, inicio: ini,
+            voz: { de: f.de, ate: f.ate }, vozEm: r2(f.de - ini),
+            camera: amplo ? { de: [0, 2.2, 10.2], para: [0, 2.0, 9.4], alvo: [0, 1.0, 0], fov: 40 }
+                : { de: [x * 0.55, 1.6, 5.2], para: [x * 0.55, 1.55, 4.5], alvo: [x, 1.25, 0], fov: 38 },
+            pecas: i === 0 ? [...(mundo ? cenarioDoMundo(mundo) : []), ...pecas] : [],
+            acoes: [{ em: 0, dur, quem: `p${f.quem}`, faz: 'anim', nome: gesto }],
+            falas: [{ quem: `p${f.quem}`, de: r2(f.de - ini), ate: r2(f.ate - ini), palavras: (f.palavras || []).map((w) => ({ de: r2(w.de - ini), ate: r2(w.ate - ini) })) }],
+        };
+    });
+    return { ceu, horizonte: (mundo.chao && mundo.chao.cor) || '#8fc46b', modo: 'dialogo', etapas };
+}
+
+module.exports = { roteiroDeDialogo, cenarioDoMundo, pecaDoElenco, GESTO };

package/lib/plugin/estudio/effectcraft.js

@@ -108,7 +108,7 @@ async function renderizar({ pasta, script, comp, fontes = [], audio, conferir =
     if (fontes && fontes.length) {
         const glifos = require('./glifos.js');
         for (const f of fontes) {
-            try { if (await glifos.baixarFonte(f.familia, f.peso || 400)) dirs.push(glifos.CACHE); } catch { /* sem rede: segue com a fonte do sistema */ }
+            try { const arq = await glifos.baixarFonte(f.familia, f.peso || 400); if (arq) dirs.push(path.dirname(arq)); } catch { /* sem rede: segue com a fonte do sistema */ }
         }
     }
     if (dirs.length) env.EFFECTCRAFT_FONT_DIRS = [...new Set(dirs)].join(path.delimiter);

package/lib/plugin/estudio/glifos.js

@@ -191,6 +191,8 @@ const CACHE = path.join(os.homedir(), '.primocode', 'studio', 'cache-fontes');
 
 async function baixarFonte(familia, peso = 700) {
     const nome = String(familia).replace(/[^a-z0-9]+/gi, '-').toLowerCase() + '-' + peso + '.ttf';
+    const embutida = path.join(__dirname, '..', '..', '..', 'vendor', 'fontes', 'ttf', nome);   // as embutidas (Inter 800 da pele do Destrava) não dependem de rede nem do cache
+    if (fs.existsSync(embutida)) return embutida;
     const arq = path.join(CACHE, nome);
     if (fs.existsSync(arq)) return arq;
     // A API antiga (css, não css2) devolve .ttf; a nova devolve woff2, que não tem a glyf crua.

package/lib/plugin/estudio/gsap-local.js

@@ -0,0 +1,43 @@
+/**
+ * gsap-local.js — o GSAP vem de um arquivo versionado (vendor/gsap/gsap.min.js), nunca de CDN.
+ *
+ * `embutir(pastaDaComposicao)` roda antes do render do Hyperframes: troca qualquer <script src> de CDN do núcleo do
+ * GSAP pelo arquivo local, e, se o HTML usa `gsap.` sem carregar nada, injeta o script. Puro no texto (`trocar`),
+ * com efeito só em `embutir` (copia o arquivo e regrava o index.html).
+ */
+'use strict';
+const fs = require('fs');
+const path = require('path');
+
+const ARQUIVO = path.join(__dirname, '..', '..', '..', 'vendor', 'gsap', 'gsap.min.js');
+const DESTINO_REL = 'vendor/gsap.min.js';
+// <script ... src="...gsap(.min).js..."> do núcleo (não pega ScrollTrigger.min.js, MotionPathPlugin etc.)
+const CDN = /<script\b([^>]*?)\bsrc\s*=\s*(["'])(https?:)?\/\/[^"']*?\/gsap(?:@[^/"']*)?(?:\/dist)?(?:\/gsap)?(?:\.min)?\.js(?:\?[^"']*)?\2([^>]*)><\/script>/gi;
+
+/** Puro. Devolve { html, trocou, injetou }. */
+function trocar(html) {
+    let trocou = 0;
+    let saida = String(html || '').replace(CDN, (_m, antes, q, _p, depois) => { trocou++; return `<script${antes}src=${q}${DESTINO_REL}${q}${depois}></script>`; });
+    const jaTem = new RegExp(`src\\s*=\\s*["'][^"']*gsap[^"']*\\.js`, 'i').test(saida);
+    let injetou = false;
+    if (!jaTem && /\bgsap\s*\./.test(saida)) {
+        const tag = `<script src="${DESTINO_REL}"></script>`;
+        saida = /<head[^>]*>/i.test(saida) ? saida.replace(/<head[^>]*>/i, (h) => `${h}\n${tag}`) : /<body[^>]*>/i.test(saida) ? saida.replace(/<body[^>]*>/i, (b) => `${b}\n${tag}`) : `${tag}\n${saida}`;
+        injetou = true;
+    }
+    return { html: saida, trocou, injetou };
+}
+
+/** Efeito: copia o arquivo e regrava o index.html da pasta. Devolve { ok, trocou, injetou, erro? }. */
+function embutir(pasta) {
+    const idx = path.join(pasta, 'index.html');
+    if (!fs.existsSync(idx)) return { ok: false, erro: 'sem index.html' };
+    const r = trocar(fs.readFileSync(idx, 'utf8'));
+    if (!r.trocou && !r.injetou) return { ok: true, trocou: 0, injetou: false };
+    fs.mkdirSync(path.join(pasta, 'vendor'), { recursive: true });
+    fs.copyFileSync(ARQUIVO, path.join(pasta, DESTINO_REL));
+    fs.writeFileSync(idx, r.html);
+    return { ok: true, trocou: r.trocou, injetou: r.injetou };
+}
+
+module.exports = { trocar, embutir, ARQUIVO, DESTINO_REL };

package/lib/plugin/estudio/index.js

@@ -674,7 +674,7 @@ async function ferramentaAE(args) {
     const p = args.id ? projeto.ler(args.id) : null;
     if (!args.id || !p) return semProjeto(args.id);
     if (!args.script || !args.comp) return { ok: false, error: 'estudio_ae pede script (o JSX) e comp (o nome da composição).' };
-    return require('./cota.js').comCota(() => renderAE(args, p));
+    return require('./cota.js').comCota(() => renderAE(args, p), { marca: args.marcaDagua === true });
 }
 
 async function renderAE(args, p) {
@@ -707,7 +707,7 @@ function entregar(args, p, r) {
 }
 
 /** A máquina de motion: assunto + cenas em JSON viram o mp4 (maquina.js), com sons, trilha e voz opcionais. */
-async function ferramentaMotion(args) {
+async function ferramentaMotion(args, ctx = {}, deps = {}) {
     const p = args.id ? projeto.ler(args.id) : null;
     if (!args.id || !p) return semProjeto(args.id);
     let receita = null;
@@ -721,10 +721,29 @@ async function ferramentaMotion(args) {
     // primeiro motion: aprende o gosto antes de renderizar (a pessoa pode fechar ou pular; o render segue de qualquer jeito)
     // no terminal abre o navegador; no app (desktop ou Primo.app, -p com PRIMOCODE_APP=1) o app abre a tela pela linha de protocolo
     try { await require('./gosto.js').antesDoMotion(args); } catch { /* sem tela, segue */ }
-    return require('./cota.js').comCota(() => renderMotion(args, p, receita));
+    // As etapas na frente do motor (motion-plano): ajusta o pedido, estrutura, monta o plano; o plano vira `cenas`.
+    // `etapas:false` ou PRIMOCODE_MOTION_ETAPAS=0 liga o caminho antigo. Falhou e não é estrito: segue pelo antigo, com aviso.
+    const MP = require('./motion-plano/index.js');
+    let etapas = null, avisoEtapas = null;
+    if (MP.ligado(args)) {
+        const fotosDoPedido = [...new Set([...(Array.isArray(args.fotos) ? args.fotos : args.fotos ? [args.fotos] : []), ...referencias.imagens()])];
+        const r = await MP.preparar(args, { escolher: ctx.escolher, linha: ctx.linha }, { llm: deps.llm, pasta: p.pasta, fotos: fotosDoPedido });
+        if (r.ok) { args = r.args; etapas = r.etapas; }
+        else if (deps.estrito || args.estrito) return { ok: false, error: r.error, etapa: r.etapa, passos: r.passos };
+        else avisoEtapas = `As etapas (ajustar, estruturar, planejar) não rodaram: ${r.error} Segui pelo caminho antigo.`;
+    }
+    const saida = await require('./cota.js').comCota(() => renderMotion(args, p, receita, deps.motor), { marca: args.marcaDagua === true });
+    if (!saida || saida.ok === false) return saida;
+    const extra = {};
+    if (etapas) {
+        extra.etapas = { briefing: etapas.briefing, plano: etapas.plano, respostas: etapas.respostas };
+        extra.critico = MP.critico(saida.video, p.pasta);
+    }
+    if (avisoEtapas) extra.avisos = [...(saida.avisos || []), avisoEtapas];
+    return { ...saida, ...extra };
 }
 
-async function renderMotion(args, p, receita) {
+async function renderMotion(args, p, receita, depsMotor = {}) {
     const narrar = async (texto, mp3, voz) => rodarPython('narrar.py', ['falar', '--texto', texto, '--saida', mp3, '--voz', String(voz || 'francisca')], { timeout: 5 * 60000 });
     // Kit de marca ativo: cores, fontes e logo entram onde o JSON não disse; o logo vai no CTA (última cena).
     const kitM = marcaKit.preencher(args.marca, { pastas: [p.pasta, process.cwd()] });
@@ -734,13 +753,16 @@ async function renderMotion(args, p, receita) {
             args.cenas = args.cenas.map((c, i) => (i === args.cenas.length - 1 && c && !c.logo ? { ...c, logo: kitM.logo } : c));
         }
     }
+    // Com o plano ativo e sem cor de marca nem estilo pedido, a pele é a do Destrava (creme, Inter 800, degradê rosa → violeta).
+    const pele = require('./motion-plano/pele.js');
+    if (pele.deveUsar(args, kitM)) args = pele.aplicar(args);
     // As fotos do pedido: as que a IA passou em `fotos` e as que o terminal achou no texto do pedido (referencias.imagens()).
     // Antes só o prepararRoteiro (Remotion) as lia: no motion elas viravam "referência" e nenhuma peça aceitava foto.
     const doPedido = referencias.imagens();
     const dadas = Array.isArray(args.fotos) ? args.fotos : (args.fotos ? [args.fotos] : []);
     const todas = [...new Set([...dadas, ...doPedido])];
     if (todas.length) args = { ...args, fotos: todas, ...(dadas.length ? {} : { fotosImplicitas: true }) };
-    const r = await require('./maquina.js').motion(args, { pasta: p.pasta, receita, deps: { narrar } });
+    const r = await require('./maquina.js').motion(args, { pasta: p.pasta, receita, deps: { narrar, ...depsMotor } });
     if (r.ok) projeto.anotar(p.id, 'motion', `${r.duracao}s, ${r.cenas.length} cenas, ${r.lufs} LUFS`);
     if (r.ok) entregar(args, p, r);
     if (!r.ok) return r;
@@ -2413,16 +2435,47 @@ async function transcrever(p, alvo, ctx) {
    escondido — sem telemetria (HYPERFRAMES_NO_TELEMETRY). Depois, o mesmo do
    Remotion: volume de Reels, a conferência e o vídeo aberto. */
 const HYPERFRAMES = 'hyperframes@0.8.154';
-async function renderHyperframes(p, args, ctx = {}) {
+/* Acha a composição que a IA escreveu. O contrato é "uma pasta com index.html", mas o modelo erra de três jeitos:
+   passa o caminho do próprio .html, passa o HTML no lugar do caminho, ou deixa o HTML num bloco ```html no argumento.
+   Os três viram a pasta certa em vez de um erro técnico. Devolve { origem } ou { erro }. */
+function acharComposicao(p, args) {
     const pedido = String(args.html || args.composicao || 'hyperframes').trim();
-    const origem = [path.resolve(p.pasta, pedido), args.__pasta && path.resolve(args.__pasta, pedido), path.isAbsolute(pedido) && pedido]
-        .find((d) => d && fs.existsSync(path.join(d, 'index.html')));
-    if (!origem) return { ok: false, error: `não achei ${pedido}/index.html — escreva a composição do Hyperframes numa pasta com index.html e passe html:"<pasta>".` };
+    const candidatos = [path.resolve(p.pasta, pedido), args.__pasta && path.resolve(args.__pasta, pedido), path.isAbsolute(pedido) && pedido].filter(Boolean);
+    const pasta = candidatos.find((d) => fs.existsSync(path.join(d, 'index.html')));
+    if (pasta) return { origem: pasta };
+    // o caminho do próprio arquivo .html: usa a pasta dele (se não for index.html, copia como index.html)
+    const arquivo = candidatos.find((f) => /\.html?$/i.test(f) && fs.existsSync(f) && fs.statSync(f).isFile());
+    if (arquivo) {
+        if (/^index\.html?$/i.test(path.basename(arquivo))) return { origem: path.dirname(arquivo) };
+        const dir = path.join(p.pasta, 'hyperframes-entrada');
+        fs.rmSync(dir, { recursive: true, force: true });
+        fs.mkdirSync(dir, { recursive: true });
+        fs.copyFileSync(arquivo, path.join(dir, 'index.html'));
+        return { origem: dir };
+    }
+    // o HTML veio no lugar do caminho (começa com <, ou num bloco de código)
+    const cerca = /```(?:html)?\s*([\s\S]*?)```/i.exec(pedido);
+    const texto = (cerca ? cerca[1] : pedido).trim();
+    if (/^<(!doctype|html|div|section|main|body|style)/i.test(texto)) {
+        const dir = path.join(p.pasta, 'hyperframes-entrada');
+        fs.rmSync(dir, { recursive: true, force: true });
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(path.join(dir, 'index.html'), texto);
+        return { origem: dir };
+    }
+    return { erro: `não achei a composição em "${pedido.slice(0, 80)}". Salve o HTML num arquivo index.html dentro de uma pasta (write_file) e chame estudio_render de novo com html:"<pasta>".` };
+}
+
+async function renderHyperframes(p, args, ctx = {}) {
+    const achada = acharComposicao(p, args);
+    if (achada.erro) return { ok: false, error: achada.erro };
+    const origem = achada.origem;
     const destino = path.join(p.pasta, 'hyperframes');
     if (path.resolve(origem) !== path.resolve(destino)) {
         fs.rmSync(destino, { recursive: true, force: true });
         fs.cpSync(origem, destino, { recursive: true });
     }
+    try { require('./gsap-local.js').embutir(destino); } catch { /* sem o troca, o Hyperframes tenta como veio */ }   // GSAP local, nunca CDN
     const midia = path.join(destino, 'midia');
     if (!fs.existsSync(midia) && fs.existsSync(path.join(p.pasta, 'midia'))) fs.symlinkSync(path.join(p.pasta, 'midia'), midia);
     const saida = path.join(p.pasta, 'saida', `${projeto.apelidar(p.titulo)}.mp4`);
@@ -2717,7 +2770,7 @@ async function ferramentaSite(args) {
     return r;
 }
 
-module.exports = { proporcaoDoPedido,
+module.exports = { proporcaoDoPedido, acharComposicao,
     vazamentoNoComeco, variarIcones, objetosDoRoteiro,
     ferramentaProjeto, ferramentaPlano, ferramentaMidia, ferramentaAE, ferramentaMotion, ferramentaEditar, ferramentaNarrar, ferramentaCriar,
     ferramentaVideo, ferramentaRender, ferramentaSite,

package/lib/plugin/estudio/kit-ae/base.jsx

@@ -235,7 +235,7 @@ function kEstiloCamera(cam, d) {
    1) Glow (brilho do que é claro), 2) um vazamento de luz suave (a aberração cromática VR foi tirada: deixava uma faixa de 1–2% na borda direita e na base) (mancha de cor
    borrada em ADD, varrendo o quadro). A energia vem do movimento e da câmera, não de entulho. */
 function kAtmosfera(comp, P) {
-    if (KIT.fx === false) return;
+    if (KIT.fx === false || KIT.pele == 'destrava') return;   // a pele do Destrava é creme limpo: sem vazamento rosa em ADD nem glow por cima
     var W = comp.width, H = comp.height, u = Math.min(W, H) / 1080, pun = KIT.punch || [], cod = kPunchCodigo(pun), d = comp.duration;
     try {   // 3) vazamento de luz: uma mancha, sem pulso
         var lk = comp.layers.addShape(); lk.name = 'vazamento de luz';

package/lib/plugin/estudio/kit-ae/cenas.jsx

@@ -369,6 +369,8 @@ var CENAS = {
     parede_logos: cenaParedeLogos, prompt: cenaPrompt, odometro: cenaOdometro, medidor: cenaMedidor, carimbo: cenaCarimbo, leque: cenaLeque, ondas: cenaOndas,
     rolagem: cenaRolagem, estrelas: cenaEstrelas, foto: cenaFoto
 };
+// as peças do Destrava (destrava.jsx): o plano de motion marca a cena com d.dz
+var CENAS_DZ = { frase: cenaDFrase, cor: cenaDCor, foto: cenaDFoto, marca: cenaDMarca };
 
 function montar(PL) {
     var W = PL.w, H = PL.h, fps = PL.fps || 30, n = PL.cenas.length, i;
@@ -376,8 +378,9 @@ function montar(PL) {
     KIT.marca = { titulo: PL.fontes.titulo, destaque: PL.fontes.destaque, texto: PL.fontes.texto };
     KIT.tipo = PL.tipo || {};
     KIT.elementos = PL.elementos || [];
+    KIT.fotos = PL.fotos || [];
     KIT.voz = PL.voz || null;
-    KIT.paletaBase = PL.paleta || null; KIT.debugFit = !!PL.debugFit; KIT.bpm = PL.bpm || 0; KIT.batidaFase = PL.batidaFase || 0; KIT.fx = PL.fx !== false;
+    KIT.paletaBase = PL.paleta || null; KIT.pele = PL.pele || null; KIT.debugFit = !!PL.debugFit; KIT.bpm = PL.bpm || 0; KIT.batidaFase = PL.batidaFase || 0; KIT.fx = PL.fx !== false;
     // a câmera dá zoom de até ~10%: o conteúdo é montado a 90% (87% com legenda, subido 7%) para NÃO sair da área segura quando a câmera chega perto
     KIT.enq = 0.88; KIT.enqDy = 0;
     if (PL.legenda && PL.legenda.chunks && PL.legenda.chunks.length) { KIT.enq = 0.85; KIT.enqDy = H * 0.07; }
@@ -387,7 +390,7 @@ function montar(PL) {
     var main = novaComp('MAIN', W, H, total, fps);
     KIT.main = main;
     // o fundo da MAIN é a cor de destaque: se as duas cenas se afastarem numa troca (chicote, empurra), o vão é uma faixa de cor, nunca preto
-    main.layers.addSolid(kCor(PL.paleta && PL.paleta.destaque ? PL.paleta.destaque : '#FFFFFF'), 'fundo-main', W, H, 1);
+    main.layers.addSolid(kCor(PL.pele == 'destrava' && PL.paleta && PL.paleta.fundo ? PL.paleta.fundo : (PL.paleta && PL.paleta.destaque ? PL.paleta.destaque : '#FFFFFF')), 'fundo-main', W, H, 1);
     // um fundo por cena, embaixo de tudo, com a cor DA CENA: se a câmera ou a troca afastar a cena, a borda mostra a cor dela, não uma faixa de outra cor
     for (i = 0; i < n; i++) { var fb = main.layers.addSolid(kCor(PL.cenas[i].pal.bg), 'fundo-cena ' + i, W, H, 1); fb.inPoint = starts[i]; fb.outPoint = i < n - 1 ? Math.min(total, starts[i + 1] + TROCA_DUR + 0.05) : total; }
     var cam = [];
@@ -396,13 +399,13 @@ function montar(PL) {
         // a cena é montada em tempo NOMINAL (dur × f) e tocada f vezes mais rápido dentro de uma comp-embrulho: tudo entra nos primeiros ~35%
         var comp = novaComp('CENA ' + i, W, H, dur * f, fps);
         // enfeite só onde há espaço livre de verdade (nada de herói em cima de janela, prompt ou botão)
-        KIT.cenaComElemento = !!c.elemento; KIT.semAmbiente = !!c.semAmbiente || !{ cinetico: 1, gancho: 1, numero: 1, citacao: 1, particulas: 1, odometro: 1, relogio: 1, carimbo: 1 }[c.tipo];
+        KIT.cenaComElemento = !!c.elemento; KIT.semAmbiente = !!c.semAmbiente || !!c.dz || !{ cinetico: 1, gancho: 1, numero: 1, citacao: 1, particulas: 1, odometro: 1, relogio: 1, carimbo: 1 }[c.tipo];
         // (até 20/10 esta linha morava DEPOIS do comentário acima, na mesma linha: o cenaIdx, o t0, o ajuste e o f nunca eram postos)
         KIT.semRotulos = !!c.semRotulos; KIT.cenaHeroi = c.tipo == 'heroi' || c.tipo == 'revela'; KIT.titulosL = []; KIT.tituloB = null; KIT.t0 = starts[i]; KIT.cenaIdx = i; KIT.estilo = c.camera || PL.camera || 'deriva'; KIT.ajusteCena = c.ajuste || 1; KIT.tituloDesce = c.tituloDesce || 0; KIT.f = f; KIT.entMax = 0;
         var P = c.pal; KIT.pal = P;
         P.fonteTitulo = PL.fontes.titulo; P.fonteTexto = PL.fontes.texto; P.fonteDestaque = PL.fontes.destaque;
         if (!CENAS[c.tipo]) KIT.avisos.push('cena ' + i + ': tipo desconhecido ' + c.tipo);
-        (CENAS[c.tipo] || cenaGancho)(comp, P, c);
+        (c.dz && CENAS_DZ[c.dz] ? CENAS_DZ[c.dz] : (CENAS[c.tipo] || cenaGancho))(comp, P, c);
         writeLn('ENTRADA ' + JSON.stringify({ cena: i, max: Math.round(kEntradaMax(comp) * 100) / 100, f: f, dur: c.dur }));
         var alvo = comp;
         if (f > 1.001) {