primocode 11.3.0 → 11.3.2

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v11.3.0
+# PrimoCode v11.3.2
 
 Agente de engenharia brasileiro para o terminal, no estilo Claude Code.
 Cria arquivos de verdade, roda comandos, **controla o navegador e o desktop** —
@@ -9,7 +9,7 @@ OpenRouter, e cada apelido (`top`/`main`/`fast`) é uma **corrente**: se um mode
 está no limite de pedidos, o próximo atende. Você não vê o erro, e não paga nada.
 
 ```
- ▐▛███▜▌   Primo Code v11.3.0
+ ▐▛███▜▌   Primo Code v11.3.2
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/lib/app-server/cli.js

@@ -41,7 +41,10 @@ async function main(args) {
     const contaFalsa = process.env.PRIMOCODE_CONTA_FALSA;
     // PRIMOCODE_TRANSCRITOR_FALSO=<arquivo.js>: async (wav) => ({ ok, texto }) no lugar do Whisper local. Só para teste de tela.
     const transcritorFalso = process.env.PRIMOCODE_TRANSCRITOR_FALSO;
+    // PRIMOCODE_FALA_FALSA=<arquivo.js>: { falar(texto) -> {ok,arquivo,mime}, aquecer(), disponivel() } no lugar da voz local. Só para teste.
+    const falaFalsa = process.env.PRIMOCODE_FALA_FALSA;
     const srv = criarServidor({
+        ...(falaFalsa ? { falaViva: require(require('path').resolve(falaFalsa)) } : {}),
         ...(transcritorFalso ? { transcritor: require(require('path').resolve(transcritorFalso)) } : {}),
         ...(falso ? { motor: require(require('path').resolve(falso)) } : {}),
         ...(contaFalsa ? { conta: require(require('path').resolve(contaFalsa)) } : {}),

package/lib/app-server/servidor.js

@@ -37,6 +37,7 @@ const PAREADO_PODE = new Set([
     'account/status',   // só ver se há conta; entrar, sair e o login pelo navegador são do computador
     'project/create', 'project/update', 'project/delete', 'agent/create', 'agent/update', 'agent/delete', 'agent/toggle',
     'brand/read', 'brand/write', 'config/write', 'voice/start', 'voice/stop', 'voice/transcribe',
+    'voice/warm', 'voice/frases', 'voice/speak',   // modo voz ao vivo do celular: só gera áudio e devolve ao celular, nunca toca no computador
 ]);
 const CAMPOS_CONFIG_PAREADO = ['effort', 'userName', 'mascot', 'reacoes', 'theme', 'preferencias'];
 const LOOPBACK = new Set(['127.0.0.1', '::1', '::ffff:127.0.0.1']);
@@ -62,7 +63,7 @@ function githubConectado() {
     } catch { return null; }
 }
 
-function criarServidor({ motor, casa, raizes, telaDir, abrir, voz, rede = false, enderecos, conta: contaOp = {}, transcritor } = {}) {
+function criarServidor({ motor, casa, raizes, telaDir, abrir, voz, rede = false, enderecos, conta: contaOp = {}, transcritor, falaViva } = {}) {
     const cfg = require('../config/config');
     const m = motor || require('../motor');
     const base = casa || cfg.CONFIG_DIR;
@@ -82,6 +83,8 @@ function criarServidor({ motor, casa, raizes, telaDir, abrir, voz, rede = false,
     const Marca = require('../plugin/marca-kit');
     const Piloto = require('../piloto');
     const Voz = voz || require('../motor/voz').criarVoz({ pasta: path.join(base, 'voz') });
+    let Fala = falaViva || null;   // a boca do modo voz ao vivo (lib/motor/fala-viva.js), criada só quando alguém fala
+    const falaDoModoVoz = () => (Fala = Fala || require('../motor/fala-viva').criarFalaViva({ pasta: path.join(base, 'voz') }));
     let loginNavegador = null;
     const statusConta = () => {
         const a = Conta.atual();
@@ -522,6 +525,24 @@ function criarServidor({ motor, casa, raizes, telaDir, abrir, voz, rede = false,
         /* ── Voz (6.9): provedor trocável em lib/motor/voz.js; só gera arquivo, nunca toca ── */
         async 'voice/start'(p, conn) { return Voz.iniciar({ texto: conn && conn.pareado ? undefined : p && p.texto }); },   // o celular não manda o computador falar
         'voice/stop'() { return Voz.parar(); },
+        /* Modo voz ao vivo: abrir a tela sobe o Whisper e o Kokoro em segundo plano (modelo carregado antes da primeira fala). */
+        'voice/warm'() {
+            if (!transcritor) require('../motor/transcricao').aquecer().catch(() => {});
+            falaDoModoVoz().aquecer().catch(() => {});
+            return { ok: true, fala: falaDoModoVoz().disponivel() };
+        },
+        /* A resposta do Primo em frases curtas para falar (sem markdown, código, caminho nem link). */
+        'voice/frases'(p) { return { frases: require('../motor/fala-viva').frasesParaFalar(p && p.texto, { max: 6 }) }; },
+        /* Uma frase vira áudio (arquivo gerado e devolvido em base64). Nunca toca: quem toca é a tela. */
+        async 'voice/speak'(p) {
+            const f = falaDoModoVoz();
+            const r = await f.falar(p && p.texto);
+            if (!r.ok) return { ok: false, error: r.error };
+            let audio;
+            try { audio = fs.readFileSync(r.arquivo).toString('base64'); } catch (e) { return { ok: false, error: `não li o áudio: ${e.message}` }; }
+            try { fs.rmSync(r.arquivo, { force: true }); } catch { /* sem arquivo */ }
+            return { ok: true, audio, mime: r.mime || 'audio/wav', provedor: r.provedor, ms: r.ms };
+        },
         /* Escuta (bug 3): o renderer grava (MediaRecorder), manda o WAV em base64 e recebe o texto. Whisper local; sem rede. */
         async 'voice/transcribe'(p) {
             const T = require('../motor/transcricao');
@@ -794,6 +815,8 @@ function criarServidor({ motor, casa, raizes, telaDir, abrir, voz, rede = false,
         if (timerPiloto) { clearInterval(timerPiloto); timerPiloto = null; }
         for (const c of [...conexoes]) if (c.fechar) c.fechar();
         conexoes.clear();
+        if (!transcritor) { try { require('../motor/transcricao').parar(); } catch { /* sem whisper vivo */ } }
+        if (Fala && Fala.parar) { try { Fala.parar(); } catch { /* sem voz viva */ } }
         try { if (porta && JSON.parse(fs.readFileSync(arquivoInfo, 'utf8')).token === token) fs.rmSync(arquivoInfo, { force: true }); } catch { /* nada a limpar */ }
         if (redeSrv) { try { redeSrv.close(); redeSrv.closeAllConnections && redeSrv.closeAllConnections(); } catch { /* já fechou */ } redeSrv = null; }
         return new Promise((res) => { if (http_) { http_.close(() => res()); http_.closeAllConnections && http_.closeAllConnections(); } else res(); });

package/lib/motor/fala-viva.js

@@ -0,0 +1,77 @@
+// A boca do modo voz ao vivo: o texto de uma frase vira um arquivo de áudio (WAV/AIFF). NUNCA toca som: devolve o arquivo,
+// e quem toca é a tela (que, no teste, desvia o player). Cadeia: Kokoro local em processo vivo (modelo carregado uma vez, sem
+// provedor pago) -> `say` do macOS -> espeak-ng. Só entra o que a máquina tem.
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync, spawn } = require('child_process');
+const { criarProcessoVivo } = require('./processo-vivo');
+const K = require('../plugin/estudio/kokoro');
+
+const SCRIPT_VIVO = path.join(__dirname, '..', '..', 'studio', 'voz_kokoro_vivo.py');
+const TETO_FRASE = 500;
+
+const achar = (nome) => { try { return execFileSync('which', [nome], { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim() || null; } catch { return null; } };
+
+/** Frases que vão pro ouvido: sem markdown, código, caminho nem link; no máximo `max` frases curtas. */
+function frasesParaFalar(texto, { max = 6 } = {}) {
+    const { paraFalar } = require('../plugin/voz');
+    const limpo = paraFalar(texto, { frases: max, teto: 900 });
+    const partes = limpo.match(/[^.!?…]+[.!?…]*/g) || [];
+    const out = [];
+    for (const p of partes) { const t = p.replace(/\s+/g, ' ').trim(); if (t.length > 1) out.push(t.slice(0, TETO_FRASE)); }
+    return out;
+}
+
+function criarFalaViva({ pasta, uv, voz = 'pf_dora', provedores } = {}) {
+    const dir = pasta || path.join(os.tmpdir(), 'primocode-voz');
+    let n = 0;
+    const arq = (ext) => { fs.mkdirSync(dir, { recursive: true, mode: 0o700 }); return path.join(dir, `frase-${Date.now()}-${++n}.${ext}`); };
+
+    let kokoro = null;
+    const kokoroVivo = () => {
+        if (kokoro) return kokoro;
+        const u = uv || achar('uv') || (fs.existsSync(path.join(os.homedir(), '.local', 'bin', 'uv')) ? path.join(os.homedir(), '.local', 'bin', 'uv') : null);
+        const esp = K.acharEspeak();
+        if (!u || !esp || !fs.existsSync(SCRIPT_VIVO)) return null;
+        const args = ['run', '--quiet', '--python', '3.11'];
+        for (const d of K.DEPS) args.push('--with', d);
+        args.push('python', SCRIPT_VIVO);
+        kokoro = criarProcessoVivo({ cmd: u, args, env: { ...process.env, ESPEAK_DATA_PATH: esp.dados, PHONEMIZER_ESPEAK_LIBRARY: esp.lib }, tempoPronto: 15 * 60000, tempoPedido: 60000 });
+        return kokoro;
+    };
+
+    const cadeia = provedores || [
+        { nome: 'kokoro', disponivel: () => !!kokoroVivo() && process.env.PRIMOCODE_VOZ !== 'say',
+            async falar(texto) { const o = arq('wav'); const r = await kokoroVivo().pedir({ texto, saida: o, voz }); return r.ok ? { ok: true, arquivo: o, mime: 'audio/wav' } : { ok: false, error: r.error }; } },
+        { nome: 'say', disponivel: () => process.platform === 'darwin' && !!achar('say'),
+            falar: (texto) => new Promise((res) => { const o = arq('aiff'); const p = spawn('say', ['-v', 'Luciana', '-o', o, texto]); p.on('error', (e) => res({ ok: false, error: e.message })); p.on('close', (c) => res(c === 0 && fs.existsSync(o) ? { ok: true, arquivo: o, mime: 'audio/aiff' } : { ok: false, error: 'o say não gerou o áudio' })); }) },
+        { nome: 'espeak-ng', disponivel: () => !!achar('espeak-ng'),
+            falar: (texto) => new Promise((res) => { const o = arq('wav'); const p = spawn('espeak-ng', ['-v', 'pt-br', '-w', o, texto]); p.on('error', (e) => res({ ok: false, error: e.message })); p.on('close', (c) => res(c === 0 && fs.existsSync(o) ? { ok: true, arquivo: o, mime: 'audio/wav' } : { ok: false, error: 'o espeak-ng não gerou o áudio' })); }) },
+    ];
+
+    return {
+        /** Sobe o Kokoro em segundo plano (modelo carregado antes da primeira frase). */
+        aquecer() { const k = cadeia[0].nome === 'kokoro' && cadeia[0].disponivel() ? kokoroVivo() : null; return k ? k.aquecer() : Promise.resolve({ ok: false }); },
+        disponivel() { return cadeia.find((p) => p.disponivel()) ? { ok: true, provedor: cadeia.find((p) => p.disponivel()).nome } : { ok: false, motivo: 'sem voz local: instale o uv e o espeak-ng (brew install uv espeak-ng) e rode `primocode doutor`' }; },
+        /** Uma frase vira áudio. Devolve {ok, arquivo, mime, provedor, ms} (nunca rejeita). */
+        async falar(texto) {
+            const t0 = Date.now();
+            const frase = String(texto || '').trim().slice(0, TETO_FRASE);
+            if (!frase) return { ok: false, error: 'falta texto' };
+            let ultimo = 'sem voz local: instale o uv e o espeak-ng (brew install uv espeak-ng) e rode `primocode doutor`';
+            for (const p of cadeia) {
+                if (!p.disponivel()) continue;
+                const r = await p.falar(K.pronuncia(frase));
+                if (r.ok) return { ...r, provedor: p.nome, ms: Date.now() - t0 };
+                ultimo = r.error || ultimo;
+            }
+            return { ok: false, error: ultimo };
+        },
+        parar() { if (kokoro) { kokoro.parar(); kokoro = null; } },
+    };
+}
+
+module.exports = { criarFalaViva, frasesParaFalar };

package/lib/motor/processo-vivo.js

@@ -0,0 +1,66 @@
+// Um processo filho que fica VIVO e conversa por linhas de JSON (uma linha entra, uma linha sai, casadas pelo `id`).
+// Serve ao modo voz ao vivo: o Whisper e o Kokoro carregam o modelo uma vez e respondem de pé, sem subir um processo por trecho.
+// Nunca toca som. Sobe na primeira chamada; `pronto` espera a linha {"pronto":true}; se o filho cai, o próximo pedido sobe outro.
+'use strict';
+
+const { spawn } = require('child_process');
+
+function criarProcessoVivo({ cmd, args = [], env, cwd, tempoPronto = 180000, tempoPedido = 120000 } = {}) {
+    let filho = null, pronto = null, buf = '', id = 0;
+    const pend = new Map();
+
+    function soltarTudo(erro) { for (const p of pend.values()) { clearTimeout(p.t); p.res({ ok: false, error: erro }); } pend.clear(); }
+
+    function subir() {
+        if (filho && pronto) return pronto;
+        buf = '';
+        filho = spawn(cmd, args, { env: env || process.env, cwd, stdio: ['pipe', 'pipe', 'pipe'] });
+        const meu = filho;
+        let erro = '';
+        meu.stderr.on('data', (d) => { erro = (erro + d).slice(-600); });
+        pronto = new Promise((resolve) => {
+            const t = setTimeout(() => resolve({ ok: false, error: 'o processo de voz demorou demais para ficar pronto' }), tempoPronto);
+            meu.stdout.on('data', (d) => {
+                buf += d;
+                let i;
+                while ((i = buf.indexOf('\n')) >= 0) {
+                    const linha = buf.slice(0, i).trim(); buf = buf.slice(i + 1);
+                    if (!linha) continue;
+                    let m; try { m = JSON.parse(linha); } catch { continue; }
+                    if (m.pronto) { clearTimeout(t); resolve({ ok: true }); continue; }
+                    if (m.id === undefined || m.id === null) { if (m.ok === false) { clearTimeout(t); resolve({ ok: false, error: m.error || 'o processo de voz não subiu' }); } continue; }
+                    const p = pend.get(m.id);
+                    if (p) { pend.delete(m.id); clearTimeout(p.t); p.res(m); }
+                }
+            });
+            meu.on('error', (e) => { clearTimeout(t); resolve({ ok: false, error: e.message }); });
+            meu.on('close', () => {
+                clearTimeout(t);
+                const era = filho === meu;
+                if (era) { filho = null; pronto = null; }
+                resolve({ ok: false, error: erro.trim().split('\n').pop() || 'o processo de voz saiu' });
+                soltarTudo('o processo de voz saiu');
+            });
+        });
+        return pronto;
+    }
+
+    return {
+        /** Sobe (se preciso) e espera ficar pronto. Devolve {ok} ou {ok:false,error}. */
+        async aquecer() { const r = await subir(); if (!r.ok) { this.parar(); } return r; },
+        async pedir(dados) {
+            const r = await subir();
+            if (!r.ok) { this.parar(); return r; }
+            return new Promise((res) => {
+                const n = ++id;
+                const t = setTimeout(() => { pend.delete(n); res({ ok: false, error: 'a voz demorou demais' }); }, tempoPedido);
+                pend.set(n, { res, t });
+                try { filho.stdin.write(`${JSON.stringify({ ...dados, id: n })}\n`); } catch (e) { pend.delete(n); clearTimeout(t); res({ ok: false, error: e.message }); }
+            });
+        },
+        parar() { const f = filho; filho = null; pronto = null; if (f) { try { f.kill('SIGTERM'); } catch { /* já saiu */ } } soltarTudo('parado'); },
+        vivo: () => !!filho,
+    };
+}
+
+module.exports = { criarProcessoVivo };

package/lib/motor/transcricao.js

@@ -7,6 +7,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { spawn, execFileSync } = require('child_process');
+const { criarProcessoVivo } = require('./processo-vivo');
 
 const PASTA_VOZ = path.join(__dirname, '..', '..', 'voz');
 const TETO_BYTES = 11 * 1024 * 1024;     // ~5 min de WAV 16 kHz mono (em base64 cabe no teto de 16 MB do WebSocket)
@@ -40,8 +41,31 @@ function transcrever(wav, { python: py, idioma = 'pt', tempoMs = TEMPO_MS } = {}
     });
 }
 
+/* O Whisper VIVO (modo voz ao vivo): um processo Python que carrega o modelo uma vez e transcreve arquivo por arquivo. */
+let vivo = null;
+function whisperVivo(py) {
+    if (!vivo) vivo = criarProcessoVivo({ cmd: py, args: ['-m', 'primo_voz.transcrever', 'servir', 'pt'], cwd: PASTA_VOZ, env: { ...process.env, PYTHONPATH: PASTA_VOZ } });
+    return vivo;
+}
+/** Sobe o Whisper em segundo plano (o modelo carrega antes da primeira fala). Nunca rejeita. */
+function aquecer({ python: py } = {}) {
+    py = py || require('../plugin/voz').python();
+    if (faltaAlgo(py)) return Promise.resolve({ ok: false });
+    return whisperVivo(py).aquecer();
+}
+function parar() { if (vivo) { vivo.parar(); vivo = null; } }
+/** Igual a `transcrever`, mas no processo vivo; se ele não sobe, cai no processo avulso. */
+async function transcreverVivo(wav, opts = {}) {
+    const py = opts.python || require('../plugin/voz').python();
+    const falta = faltaAlgo(py);
+    if (falta) return { ok: false, ...falta };
+    const r = await whisperVivo(py).pedir({ arquivo: wav });
+    if (r.ok) return { ok: true, texto: String(r.texto || '') };
+    return transcrever(wav, { python: py });
+}
+
 /** Grava o áudio (base64, WAV) num arquivo temporário, transcreve e apaga. `transcritor` troca o Whisper (teste). */
-async function transcreverBase64(audio, { pasta, transcritor = transcrever } = {}) {
+async function transcreverBase64(audio, { pasta, transcritor = transcreverVivo } = {}) {
     if (typeof audio !== 'string' || !audio) return { ok: false, error: 'falta o áudio' };
     const bytes = Buffer.from(audio, 'base64');
     if (!bytes.length) return { ok: false, error: 'áudio vazio' };
@@ -54,4 +78,4 @@ async function transcreverBase64(audio, { pasta, transcritor = transcrever } = {
     try { return await transcritor(arq); } finally { try { fs.rmSync(arq, { force: true }); } catch { /* sem arquivo */ } }
 }
 
-module.exports = { transcrever, transcreverBase64, faltaAlgo, TETO_BYTES };
+module.exports = { transcrever, transcreverVivo, transcreverBase64, aquecer, parar, faltaAlgo, TETO_BYTES };

package/lib/plugin/estudio/criar.js

@@ -7,13 +7,13 @@
 
 const path = require('path');
 
-/* tipo → receita. `via`: 'roteiro' (plano pelo roteirista + render) ou 'motion' (a máquina de motion). */
+/* tipo → receita. `via`: 'roteiro' (plano pelo roteirista + render) ou 'kit' (motion pelos estilos: os 50 kits ou um estilo próprio, lib/plugin/kits.js). */
 const TIPOS = Object.freeze({
     slides:   { rotulo: 'Slides', via: 'roteiro', formato: '16:9', projeto: 'slides' },
     video:    { rotulo: 'Vídeo curto', via: 'roteiro', formato: '9:16', projeto: 'video', duracao: [15, 60, 30] },
-    motion:   { rotulo: 'Motion', via: 'motion', formato: '9:16', duracao: [6, 60, 15] },
-    anuncio:  { rotulo: 'Anúncio', via: 'motion', formato: '9:16', duracao: [10, 30, 15], prefixo: 'Anúncio para chamar pra comprar: ' },
-    abertura: { rotulo: 'Abertura de canal', via: 'motion', formato: '16:9', duracao: [5, 5, 5], prefixo: 'Abertura de canal com a marca: ' },
+    motion:   { rotulo: 'Motion', via: 'kit', formato: '9:16', duracao: [6, 60, 15] },
+    anuncio:  { rotulo: 'Anúncio', via: 'kit', formato: '9:16', duracao: [10, 30, 15], prefixo: 'Anúncio para chamar pra comprar: ' },
+    abertura: { rotulo: 'Abertura de canal', via: 'kit', formato: '16:9', duracao: [5, 5, 5], prefixo: 'Abertura de canal com a marca: ' },
 });
 const FORMATOS = ['9:16', '16:9', '1:1'];
 
@@ -28,7 +28,10 @@ function normalizar(args = {}) {
     if (briefing.length < 3) return { ok: false, error: 'falta o briefing: diga em uma frase o que criar.' };
     const formato = FORMATOS.includes(String(args.formato)) ? String(args.formato) : receita.formato;
     const duracao = receita.duracao ? limitar(args.duracao, receita.duracao) : undefined;
-    return { ok: true, tipo, receita, briefing: briefing.slice(0, 600), formato, duracao };
+    const estilo = String(args.estilo || '').trim().slice(0, 60) || undefined;
+    const en = args.estilo_novo && typeof args.estilo_novo === 'object' ? args.estilo_novo : null;
+    const estiloNovo = en && String(en.nome || '').trim() ? { nome: String(en.nome).trim().slice(0, 40), descricao: String(en.descricao || '').slice(0, 300), base: en.base ? String(en.base).slice(0, 60) : undefined } : undefined;
+    return { ok: true, tipo, receita, briefing: briefing.slice(0, 600), formato, duracao, estilo, estiloNovo };
 }
 
 /** Os arquivos entregues, com o tipo que a tela sabe abrir. */
@@ -52,12 +55,12 @@ function tipoDoArquivo(c) {
 
 /**
  * @param {object} args    { tipo, briefing, duracao?, formato? }
- * @param {object} deps    { projeto, plano(args), motion(args), render(args), progresso(pct, etapa) }
+ * @param {object} deps    { projeto, kit(args), plano(args), render(args), progresso(pct, etapa) }
  */
 async function criar(args, deps) {
     const n = normalizar(args);
     if (!n.ok) return n;
-    const { tipo, receita, briefing, formato, duracao } = n;
+    const { tipo, receita, briefing, formato, duracao, estilo, estiloNovo } = n;
     const progresso = deps.progresso || (() => {});
     const falha = (error, extra) => ({ ok: false, error, ...extra });
 
@@ -69,12 +72,16 @@ async function criar(args, deps) {
     const id = proj.id;
     const base = { tipo, id, pasta: proj.pasta, formato, duracao, titulo };
 
-    if (receita.via === 'motion') {
-        progresso(15, 'Montando as cenas de motion');
-        const m = await deps.motion({ id, assunto: pedido, formato, duracao });
-        if (!m || m.ok === false) return falha((m && m.error) || 'o motion não saiu.', base);
-        progresso(100, 'Pronto');
-        return { ok: true, ...base, duracao: m.duracao || duracao, arquivo: m.video, arquivos: arquivosDe(m), resumo: `${receita.rotulo} de ${m.duracao || duracao} s.` };
+    if (receita.via === 'kit') {
+        /* Motion SEMPRE pelos kits (11.1): escolhe o estilo (um dos 50, um criado, ou o da tela de estilos) e monta a pasta
+           do vídeo com as peças desmontadas dele. A cena a IA compõe com as peças e renderiza com `primocode kit pecas`.
+           Nunca cai no gerador antigo (estudio_motion): quem quiser esse caminho chama a ferramenta dele. */
+        progresso(15, 'Escolhendo o estilo e montando as pastas');
+        const k = await (deps.kit || ((a) => require('./kit-projeto.js').montar(a)))({ pasta: proj.pasta, pedido, formato, duracao, estilo, estiloNovo });
+        if (!k || k.ok === false) return falha((k && k.error) || 'não consegui montar o projeto do estilo.', { ...base, ...(k && k.precisa ? { precisa: k.precisa } : {}), ...(k && k.menu ? { menu: k.menu } : {}) });
+        progresso(40, 'Pastas do estilo prontas');
+        return { ok: true, ...base, kit: k.slug, estilo: k.nome, pastaKit: k.pasta, pecas: k.pecas, categorias: k.categorias, etapa: 'cena', proximo: k.proximo,
+            resumo: `${receita.rotulo} no estilo ${k.nome}: pastas montadas, falta compor a cena e renderizar.` };
     }
 
     progresso(15, 'Escrevendo o roteiro');
@@ -99,9 +106,9 @@ module.exports = { criar, normalizar, TIPOS, FORMATOS, tipoDoArquivo, arquivosDe
 const QUADRADOS = Object.freeze({
     slides:  'Tipo escolhido na tela: Apresentação de slides. Use estudio_criar com tipo "slides" e o briefing do pedido (a skill slides-que-prendem ajuda no conteúdo).',
     video:   'Tipo escolhido na tela: Vídeo curto vertical. Use estudio_criar com tipo "video" e o briefing do pedido.',
-    motion:  'Tipo escolhido na tela: Motion. Use estudio_criar com tipo "motion" e o briefing do pedido.',
-    anuncio: 'Tipo escolhido na tela: Anúncio de 15 s. Use estudio_criar com tipo "anuncio" e o briefing do pedido.',
-    abertura: 'Tipo escolhido na tela: Abertura de canal de 5 s. Use estudio_criar com tipo "abertura" e o briefing do pedido.',
+    motion:  'Tipo escolhido na tela: Motion (pelos estilos/kits). Use estudio_criar com tipo "motion", o briefing e o estilo (um dos kits do menu, ou estilo_novo; sem estilo vale o da tela de estilos). Depois siga o caminho "primocode kit pecas <estilo>" que a ferramenta devolve.',
+    anuncio: 'Tipo escolhido na tela: Anúncio de 15 s em motion (pelos estilos/kits). Use estudio_criar com tipo "anuncio", o briefing e o estilo (um dos kits do menu, ou estilo_novo). Depois siga o caminho "primocode kit pecas <estilo>" que a ferramenta devolve.',
+    abertura: 'Tipo escolhido na tela: Abertura de canal de 5 s em motion (pelos estilos/kits). Use estudio_criar com tipo "abertura", o briefing e o estilo (um dos kits do menu, ou estilo_novo). Depois siga o caminho "primocode kit pecas <estilo>" que a ferramenta devolve.',
     pagina:  'Tipo escolhido na tela: Página ou app. Construa com write_file na pasta do projeto, confira abrindo no navegador e entregue o arquivo principal. Não use o Estúdio.',
     bug:     'Tipo escolhido na tela: Corrigir um bug. Ache a causa lendo o código do projeto (read_file, grep), corrija com edit_file e crie um teste que pegue o caso; rode os testes e conte o que mudou. Não use o Estúdio.',
     pr:      'Tipo escolhido na tela: Revisar um PR. Leia o diff do PR (o número ou o link que a pessoa der; gh ou git diff), aponte os riscos do mais grave ao menos grave e sugira a correção. Não use o Estúdio.',

package/lib/plugin/estudio/historico.js

@@ -7,7 +7,7 @@ const path = require('path');
 const { tipoDoArquivo } = require('./criar');
 const Miniatura = require('./miniatura');
 
-const PULAR = new Set(['node_modules', 'remotion', 'midia', 'entrada', 'versoes', '.git']);
+const PULAR = new Set(['node_modules', 'remotion', 'midia', 'entrada', 'versoes', '.git', 'pecas']);
 const SAIDAS = new Set(['video', 'pdf', 'imagem']);
 
 /* Procura as saídas em até 2 níveis; imagem solta (quadro de conferência) serve de miniatura, não de entrega. */

package/lib/plugin/estudio/index.js

@@ -750,12 +750,12 @@ async function renderMotion(args, p, receita) {
 
 // ── estudio_criar ────────────────────────────────────────────────────────
 
-/** A porta simples (criar.js): escolhe a receita e chama as ferramentas de cima. `ctx.progresso(pct, etapa)` alimenta o item da tela. */
+/** A porta simples (criar.js): escolhe a receita e chama as ferramentas de cima (motion vai pelos kits: kit-projeto.js). `ctx.progresso(pct, etapa)` alimenta o item da tela. */
 async function ferramentaCriar(args, ctx = {}) {
     return require('./criar.js').criar(args, {
         projeto,
         plano: (a) => ferramentaPlano({ ...a, __pasta: ctx.projectDir }),
-        motion: (a) => ferramentaMotion(a),
+        kit: (a) => require('./kit-projeto.js').montar({ ...a, projectDir: ctx.projectDir }, { aoFalar: ctx.aoFalar }),
         render: (a) => ferramentaRender({ ...a, __pasta: ctx.projectDir }, ctx),
         progresso: ctx.progresso,
     });

package/lib/plugin/estudio/kit-projeto.js

@@ -0,0 +1,69 @@
+// O motion pelo sistema de estilos (kits): o `estudio_criar` dos tipos motion, anuncio e abertura passa por aqui.
+// Resolve o estilo (um dos 50, um que a pessoa criou, ou a escolha dela na tela de estilos) e monta a pasta do vídeo
+// com as peças desmontadas do estilo (formas, texturas, transições, tipografia, câmera, sons, trilha, cores, fontes,
+// regras). A cena em si a IA compõe do zero com essas peças e renderiza com `primocode kit pecas` (lib/plugin/kits.js).
+// Nada de gerador antigo aqui: é a 11.1 de kits, só que com a porta simples na frente. Node puro.
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const semReferencia = (src) => !/[\\/]referencia([\\/]|$)/.test(src);
+
+/**
+ * @param {object} a   { pasta (do projeto), pedido, formato, duracao, estilo?, estiloNovo?: {nome, descricao, base, ref?}, home?, projectDir? }
+ * @param {object} d   { K (lib/plugin/kits.js), MAT (materiais.js), T (kits-tela.js), aoFalar }
+ */
+async function montar(a, d = {}) {
+    const K = d.K || require('../kits.js');
+    const MAT = d.MAT || require('./materiais.js');
+    const op = { home: a.home, projectDir: a.projectDir || a.pasta, env: d.env, aoFalar: d.aoFalar };
+    let slug = null, nome = null, origem = null;
+
+    // 1) estilo novo, pedido pela IA: copia as peças de um estilo base e devolve o slug
+    if (a.estiloNovo && a.estiloNovo.nome) {
+        const e = a.estiloNovo;
+        const argv = ['criar', '--nome', String(e.nome), '--descricao', String(e.descricao || e.nome)];
+        if (e.base) argv.push('--base', String(e.base));
+        if (e.ref) argv.push('--ref', String(e.ref));
+        const r = await K.main(argv, op);
+        if (!r.ok || !r.slug) return { ok: false, error: r.texto || 'não consegui criar o estilo.' };
+        slug = r.slug; origem = 'criado';
+    }
+    // 2) estilo nomeado (slug ou nome) entre os 50 e os da pessoa
+    if (!slug && a.estilo) {
+        const k = K.achar(a.estilo, op);
+        if (!k) return { ok: false, error: `o estilo "${a.estilo}" não existe. Escolha um do menu ou crie um novo (estilo_novo).`, menu: K.menuParaIA(op) };
+        slug = k.slug; nome = k.nome; origem = 'escolhido';
+    }
+    // 3) a escolha dela na tela de estilos (no primeiro motion a tela abre e a escolha volta)
+    if (!slug) {
+        const m = await K.main(['menu'], op);
+        if (m && m.escolha) { slug = m.escolha; origem = 'tela'; }
+        else return { ok: false, precisa: 'estilo', error: 'falta escolher o estilo: chame de novo com estilo=<slug> (um do menu) ou estilo_novo={nome, descricao, base}.', menu: m && m.texto ? m.texto : K.menuParaIA(op) };
+    }
+    if (!MAT.migrado(slug)) return { ok: false, error: `o estilo ${slug} não tem as peças soltas (materiais/${slug}).` };
+    if (!nome) { const k = K.achar(slug, op); nome = k ? k.nome : slug; }
+
+    // a pasta do vídeo: motion/pecas/<categorias> + kit.json + LEIA.md
+    const raiz = path.join(a.pasta, 'motion');
+    const pecas = path.join(raiz, 'pecas');
+    fs.rmSync(pecas, { recursive: true, force: true });
+    fs.mkdirSync(raiz, { recursive: true });
+    fs.cpSync(MAT.pastaDe(slug), pecas, { recursive: true, filter: semReferencia });
+    const pastas = fs.readdirSync(pecas, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+    const arquivos = fs.readdirSync(pecas, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name).sort();
+    const kit = { slug, nome, origem, formato: a.formato, duracao: a.duracao || null, pedido: a.pedido, pecas: path.relative(a.pasta, pecas), criado: new Date().toISOString() };
+    fs.writeFileSync(path.join(raiz, 'kit.json'), JSON.stringify(kit, null, 2) + '\n');
+    const proximo = [
+        `Estilo ${nome} (${slug}): as peças estão em ${pecas} (${pastas.join(', ')}).`,
+        `1) primocode kit pecas ${slug} regras  (identidade e densidade mínima)`,
+        `2) primocode kit pecas ${slug} ver <peça>  (código e params das peças que vai usar)`,
+        `3) escreva a cena nova em TSX com o conteúdo do pedido e grave: primocode kit pecas ${slug} escrever <nome> --arquivo cena.tsx --pasta ${a.pasta}`,
+        `4) renderize: primocode kit pecas ${slug} renderizar <nome> --pasta ${a.pasta}  (o vídeo sai em ${path.join(a.pasta, 'saida')})`,
+    ].join('\n');
+    fs.writeFileSync(path.join(raiz, 'LEIA.md'), `# ${nome}\n\nPedido: ${a.pedido}\n\n${proximo}\n`);
+    return { ok: true, slug, nome, origem, pasta: raiz, pecas, categorias: pastas, arquivos, proximo };
+}
+
+module.exports = { montar };

package/lib/plugin/kits.js

@@ -460,8 +460,9 @@ async function cmdPecas(a, op) {
     const [estilo, sub, alvo] = a._;
     if (!estilo) return { ok: true, texto: `Estilos com peças soltas: ${MATERIAIS.estilos().join(', ') || 'nenhum'}. Uso: primocode kit pecas <estilo> [ver <peça> | regras | escrever <nome> --arquivo <cena.tsx> | conferir <cena.tsx> | renderizar <nome>]` };
     if (!MATERIAIS.migrado(estilo)) return { ok: false, texto: `O estilo "${estilo}" ainda não tem peças soltas (migrados: ${MATERIAIS.estilos().join(', ') || 'nenhum'}).` };
-    const pasta = op.projectDir || process.cwd();
-    const lerArq = (f) => fs.readFileSync(path.resolve(pasta, String(f)), 'utf8');
+    // --pasta <projeto>: a pasta do vídeo que o estudio_criar montou (motion/ e saida/ ficam nela)
+    const pasta = a.pasta ? path.resolve(String(a.pasta)) : (op.projectDir || process.cwd());
+    const lerArq = (f) => { const aqui = path.resolve(op.projectDir || process.cwd(), String(f)); return fs.readFileSync(fs.existsSync(aqui) ? aqui : path.resolve(pasta, String(f)), 'utf8'); };
     try {
         switch (sub) {
             case undefined: case 'listar': return MATERIAIS.listar(estilo);
@@ -477,7 +478,7 @@ async function cmdPecas(a, op) {
                 const dir = path.join(pasta, 'motion', `.render-${alvo}`);
                 MATERIAIS.prepararRender(estilo, dir, arq, { duracao: a.quadros ? Number(a.quadros) : undefined });
                 ligarModulos(dir, est.modulos);
-                const saida = path.resolve(pasta, String(a.saida || path.join('motion', `${alvo}.mp4`)));
+                const saida = path.resolve(pasta, String(a.saida || (a.pasta ? path.join('saida', `${alvo}.mp4`) : path.join('motion', `${alvo}.mp4`))));
                 const CQ = require('./estudio/conferir-quadros.js');
                 const cenas = CQ.cenasDe(fs.readFileSync(arq, 'utf8'));
                 const r = await rodarRender(dir, saida, { escala: Number(a.escala) || 1, quadros: cenas.map((c) => c.meio), aoFalar: op.aoFalar || (() => {}) });
@@ -506,7 +507,7 @@ function opcoes(args) {
 const AJUDA = `primocode kit — os estilos de motion (peças soltas)
   menu                      o menu dos estilos (no primeiro motion abre a tela de estilos)
   ver <slug>                as peças e as regras do estilo (igual a pecas <slug>)
-  pecas <estilo> [ver <peça>|regras|escrever <nome> --arquivo <tsx>|conferir <tsx>|renderizar <nome>]
+  pecas <estilo> [ver <peça>|regras|escrever <nome> --arquivo <tsx>|conferir <tsx>|renderizar <nome>] [--pasta <projeto>]
                             a IA compõe a cena do zero com as peças; o conferir cobra a densidade
   referencia                abre a tela de referências e devolve o que mediu
   criar --nome "<nome>" --descricao "<como é>" [--base <slug>] [--ref <vídeo>] [--quando "a; b; c"] [--familia "<família>"]

package/lib/session/runner/act.js

@@ -1200,7 +1200,8 @@ async function runActInterno(userPrompt, opts) {
         try {
             const kits = require('../../plugin/kits.js');
             kits.novoTurno();
-            const cabeca = kits.cabecaDoPedido(userPrompt, { projectDir });
+            // a instrução do quadrado (Motion, Anúncio, Abertura) também conta: o pedido sozinho ("bolo de pote") não parece motion
+            const cabeca = kits.cabecaDoPedido(instrucao ? `${userPrompt}\n${instrucao}` : userPrompt, { projectDir });
             // o vídeo esperando o sim vai colado na resposta da pessoa (é dela que a IA decide); o menu, na frente
             if (cabeca && /^\[VÍDEO (ESPERANDO|SENDO MONTADO)/.test(cabeca) && pedido.endsWith(userPrompt)) pedido = `${pedido.slice(0, pedido.length - userPrompt.length)}${cabeca}\n\nRESPOSTA DA PESSOA: ${userPrompt}`;
             else if (cabeca) pedido = `${cabeca}\n\n${pedido}`;

package/lib/skill/catalogo.js

@@ -82,8 +82,8 @@ const GRUPOS = [
         nome: 'Estúdio',
         resumo: 'vídeo, motion, slides e arte — a IA faz, e no fim abre o resultado pronto',
         itens: [
-            { tool: 'estudio_criar', escreve: true, faz: 'a porta simples: cria slides, vídeo, motion, anúncio ou abertura do pedido ao arquivo, e abre o resultado',
-              args: 'tipo (slides|video|motion|anuncio|abertura). briefing (uma frase). duracao (s, opcional). formato (9:16|16:9|1:1, opcional). Para controle fino use as outras estudio_*.' },
+            { tool: 'estudio_criar', escreve: true, faz: 'a porta simples: slides e vídeo vão do pedido ao arquivo; motion, anúncio e abertura escolhem um dos 50 estilos (kits) e montam as pastas do vídeo',
+              args: 'tipo (slides|video|motion|anuncio|abertura). briefing. duracao (s). formato (9:16|16:9|1:1). Motion: estilo (slug do kit) ou estilo_novo {nome, descricao, base}; depois, primocode kit pecas.' },
             { tool: 'estudio_projeto', escreve: true, faz: 'abre, acha e lista os projetos do estúdio — cada peça é uma pasta que não some',
               args: 'acao: criar | abrir | procurar | listar | anotar | editar | assinatura. '
                 + 'assinatura: quando o usuário diz o que achou de um vídeo ("adorei a virada", "texto demais"), grave com texto (e o id) — o próximo vídeo parte disso; sem texto, lê as faixas e as notas. '

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "11.3.0",
+  "version": "11.3.2",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Requer conta Conecta Primo AI (Premium ou Super). Cria arquivos, roda comandos, controla navegador e desktop: abre apps, clica em botões e ícones pelo nome, digita e usa atalhos.",
   "main": "bin/primocode.js",
   "bin": {
@@ -11,7 +11,7 @@
     "postinstall": "node lib/preparar.js || true",
     "test:server": "cd server && npm test",
     "test": "node scripts/testes.js",
-    "test:app": "node test/app-fluxo.test.mjs && node test/app-primeira.test.mjs && node test/app-entrar.test.mjs && node test/app-tela-estudio.test.mjs && node test/app-celular-telas.test.mjs",
+    "test:app": "node test/app-fluxo.test.mjs && node test/app-primeira.test.mjs && node test/app-entrar.test.mjs && node test/app-tela-estudio.test.mjs && node test/app-celular-telas.test.mjs && node test/app-compositor-voz.test.mjs",
     "app:build": "cd app && npm run dist",
     "app:dev": "cd app && npm start",
     "mobile:build": "cd mobile && npm run build"

package/studio/voz_kokoro_vivo.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+"""voz_kokoro_vivo.py - a voz local do modo voz ao vivo: o Kokoro-82M fica CARREGADO e fala frase por frase.
+
+Entrada (uma linha de JSON por pedido): {"id": 1, "texto": "Oi.", "saida": "/tmp/x.wav", "voz": "pf_dora"}
+Saída (uma linha por resposta):          {"id": 1, "ok": true, "arquivo": "/tmp/x.wav", "segundos": 1.2}
+Primeira linha de saída: {"pronto": true}. Só GERA arquivo WAV; nunca toca som. Roda pelo uv (lib/motor/fala-viva.js monta o comando).
+"""
+import json
+import re
+import sys
+
+
+def main():
+    import numpy as np
+    import soundfile as sf
+    from kokoro import KPipeline
+
+    pipe = KPipeline(lang_code="p")
+    # uma passada curta aquece o modelo: a primeira frase de verdade já não paga a carga
+    try:
+        for _ in pipe("Oi.", voice="pf_dora"):
+            pass
+    except Exception:
+        pass
+    print(json.dumps({"pronto": True}), flush=True)
+    for linha in sys.stdin:
+        linha = linha.strip()
+        if not linha:
+            continue
+        pedido = {}
+        try:
+            pedido = json.loads(linha)
+            texto = re.sub(r"\s+", " ", str(pedido.get("texto") or "")).strip()
+            if not texto:
+                print(json.dumps({"id": pedido.get("id"), "ok": False, "error": "texto vazio"}), flush=True)
+                continue
+            partes = [np.asarray(a, dtype=np.float32) for _, _, a in pipe(texto, voice=pedido.get("voz") or "pf_dora")]
+            audio = np.concatenate(partes)
+            sf.write(str(pedido["saida"]), audio, 24000)
+            print(json.dumps({"id": pedido.get("id"), "ok": True, "arquivo": pedido["saida"], "segundos": round(len(audio) / 24000, 3)}), flush=True)
+        except Exception as e:
+            print(json.dumps({"id": pedido.get("id"), "ok": False, "error": str(e)[:300]}), flush=True)
+
+
+if __name__ == "__main__":
+    main()

package/voz/primo_voz/transcrever.py

@@ -200,6 +200,31 @@ def main() -> int:
             return 1
         print(json.dumps({"ok": True, "palavras": ws}, ensure_ascii=False))
         return 0
+    if acao == "servir":
+        # `... servir [idioma]`: processo vivo do app (modo voz ao vivo). O modelo carrega UMA vez; cada linha de entrada é
+        # {"id":N,"arquivo":"x.wav"} e cada linha de saída é {"id":N,"ok":true,"texto":"..."}. Primeira linha: {"pronto":true}.
+        if not disponivel():
+            print(json.dumps({"ok": False, "error": "o faster-whisper não está instalado"}), flush=True)
+            return 1
+        idioma = sys.argv[2] if len(sys.argv) > 2 else "pt"
+        try:
+            carregar()
+        except Exception as e:
+            print(json.dumps({"ok": False, "error": str(e)}), flush=True)
+            return 1
+        print(json.dumps({"pronto": True, "modelo": MODELO}), flush=True)
+        for linha in sys.stdin:
+            linha = linha.strip()
+            if not linha:
+                continue
+            pedido = {}
+            try:
+                pedido = json.loads(linha)
+                texto = transcrever(Path(pedido["arquivo"]), idioma)
+                print(json.dumps({"id": pedido.get("id"), "ok": True, "texto": texto}, ensure_ascii=False), flush=True)
+            except Exception as e:
+                print(json.dumps({"id": pedido.get("id"), "ok": False, "error": str(e)}), flush=True)
+        return 0
     if acao == "arquivo":
         # `... arquivo <wav> [idioma]`: a fala de um arquivo vira texto (o app desktop grava no microfone e manda para cá).
         if not disponivel():