primocode 11.2.0 → 11.3.1

package/lib/cli/sessao.js

@@ -13,6 +13,7 @@ const os = require('os');
 
 const pkg = require('../../package.json');
 const ui = require('../tui/ui');
+const tela = require('../tui/tela.js');
 const entrada = require('../tui/entrada');
 const { c, welcomeBox, Spinner } = ui;
 const { escolherModo } = require('../modo.js');
@@ -444,9 +445,10 @@ function barraDeStatus() {
     direita.push(...SL.partes({ modelo: SL.modelo(), ctxPct: uso.pct, tokensHoje: SL.tokensDeHoje(), c }));
     const aprovar = require('../cli-nova.js').praAprovar();
     if (aprovar) direita.push(c.warn(`${aprovar} pra aprovar`));
-    direita.push(state.trabalhando && rl && rl.ocupado
+    const atalhos = state.trabalhando && rl && rl.ocupado
         ? c.warn('trabalhando') + c.dim(' · ') + c.white('esc esc') + c.dim(' para')
-        : c.white('tab') + c.dim(' modos  ') + c.white('ctrl+p') + c.dim(' comandos'));
+        : c.white('tab') + c.dim(' modos  ') + c.white('ctrl+p') + c.dim(' comandos');
+    direita.push(atalhos);
 
     /* O modo DENTRO do painel. No auto, depois do primeiro pedido, ele diz
        qual modo acabou respondendo — senão você nunca sabe quem respondeu. */
@@ -455,9 +457,12 @@ function barraDeStatus() {
     if (state.mode === 'auto' && state.modoEfetivo) {
         modo += c.dim(' → ') + c.muted(NOME_MODO[state.modoEfetivo] || state.modoEfetivo);
     }
-    modo += c.dim(' · ') + c.white(effort.normalizar(state.config.effort)) + ' ' + c.dim('PrimoCode');
+    /* "Build · Primo Max · esforço alto": o modo, o plano da conta ("Primo Max") e o esforço. */
+    let planoNome = '';
+    try { const eu = conta.atual(); if (eu && eu.plano && eu.plano !== 'free') planoNome = ' ' + String(eu.plano).replace(/^./, (x) => x.toUpperCase()); } catch { /* sem conta */ }
+    modo += c.dim(' · ') + c.white('Primo' + planoNome) + c.dim(' · esforço ') + c.white(effort.normalizar(state.config.effort));
 
-    return { modo, cor, esquerda: partes.join(c.dim(' · ')), direita: direita.join(c.dim('   ')) };
+    return { modo, cor, esquerda: partes.join(c.dim(' · ')), direita: direita.join(c.dim('   ')), atalhos };
 }
 
 /* A barra da direita da tela cheia, como a do OpenCode: o contexto (quantos
@@ -468,20 +473,61 @@ function barraLateral() {
     const dir = state.workDir || process.cwd();
     const ramo = ramoDoGit(dir);
     const m = state.mode === 'auto' && state.modoEfetivo ? state.modoEfetivo : state.mode;
-    const secoes = [
-        { titulo: 'Contexto', linhas: [
-            c.muted(`${uso.tokens.toLocaleString('pt-BR')} tokens`),
-            (uso.pct >= 100 ? c.err : uso.pct >= 70 ? c.warn : c.muted)(`${uso.pct}% usado`),
-        ] },
-        { titulo: 'Modo', linhas: [
-            `${COR_MODO[m] || COR_MODO.auto}${NOME_MODO[m] || m}${c.reset}` + c.muted(` · esforço ${effort.normalizar(state.config.effort)}`),
-        ] },
-    ];
+    const larg = 22;
+    const secoes = [];
+
+    // Contexto: quanto da conversa já foi gasto, com a barra.
+    secoes.push({ titulo: 'Contexto', linhas: [
+        c.muted(`${uso.tokens.toLocaleString('pt-BR')} tokens · ${uso.pct}%`),
+        tela.barraDe(uso.pct, larg, uso.pct >= 100 ? c.err : uso.pct >= 70 ? c.warn : c.brand),
+    ] });
+
+    /* Plano: o plano da CONTA (o que o login confirmou) e o gasto de hoje contra o limite que a
+       pessoa ensinou (/usage limite). O servidor não informa o limite da semana, então ele não é inventado. */
+    try {
+        const eu = conta.atual();
+        const L = require('../config/limite.js');
+        const hoje = L.usoDeHoje().tokens;
+        const lim = L.limiteConhecido();
+        const linhas = [];
+        if (eu && eu.plano) linhas.push(c.muted(`Plano ${String(eu.plano).replace(/^./, (x) => x.toUpperCase())}`));
+        if (lim) {
+            const pct = Math.round((hoje / lim) * 100);
+            linhas.push(c.muted(`${pct}% do limite de hoje`), tela.barraDe(pct, larg, pct >= 100 ? c.err : pct >= 70 ? c.warn : c.brand));
+        } else linhas.push(c.dim(`${hoje.toLocaleString('pt-BR')} tokens hoje`));
+        secoes.push({ titulo: 'Plano', linhas });
+    } catch { /* o plano nunca derruba a tela */ }
+
+    secoes.push({ titulo: 'Modo', linhas: [
+        `${COR_MODO[m] || COR_MODO.auto}${NOME_MODO[m] || m}${c.reset}` + c.muted(` · esforço ${effort.normalizar(state.config.effort)}`),
+    ] });
+
+    // Tarefas: o write_todos do agente.
+    const todos = ui.estadoSessao.todos || [];
+    if (todos.length) {
+        const marca = { completed: c.ok('✓'), in_progress: c.brand('●'), pending: c.dim('○') };
+        secoes.push({ titulo: 'Tarefas', linhas: todos.slice(0, 8).map((t) => `${marca[t.status] || c.dim('○')} ` + (t.status === 'completed' ? c.dim(t.content) : t.status === 'in_progress' ? c.white(t.content) : c.muted(t.content))) });
+    }
+
+    // Arquivos alterados, com +N −M.
+    if (ui.estadoSessao.arquivos.size) {
+        const arqs = [...ui.estadoSessao.arquivos.entries()].slice(-8);
+        secoes.push({ titulo: 'Arquivos alterados', linhas: arqs.map(([f, k]) =>
+            c.muted(path.basename(f)) + '  ' + (k.mais ? c.ok('+' + k.mais) : '') + (k.menos ? ' ' + c.err('−' + k.menos) : '')) });
+    }
+
+    // MCP: os servidores configurados (o padrão, o do usuário, o do projeto).
+    try {
+        const nomes = Object.keys(require('../mcp/mcp.js').servidores(dir));
+        if (nomes.length) secoes.push({ titulo: 'MCP', linhas: nomes.slice(0, 5).map((n) => c.ok('●') + ' ' + c.muted(n)) });
+    } catch { /* sem MCP, sem seção */ }
+
     if (state.attachedFiles.length) {
         secoes.push({ titulo: 'Anexos', linhas: state.attachedFiles.map((f) => c.muted(path.basename(f.path))) });
     }
     if (state.controle && state.controle.liberado) secoes.push({ titulo: 'Controle do PC', linhas: [c.warn('liberado até fechar')] });
     return {
+        subtitulo: state.currentProject ? state.currentProject : undefined,
         secoes,
         rodape: [
             c.muted(shortPath(dir)) + (ramo ? c.white(':' + ramo) : ''),
@@ -490,6 +536,83 @@ function barraLateral() {
     };
 }
 
+/* ── A PALETA (ctrl+p) E OS DIÁLOGOS ─────────────────────────────────────
+ * O desenho é do OpenCode: uma lista com busca no meio da tela. O conteúdo é
+ * o que já existe aqui: os comandos de barra, os modos, os agentes da pessoa,
+ * as conversas salvas e os temas. Escolher um item roda o comando de sempre. */
+const ATALHOS_DO_LIDER = { '/clear': 'ctrl+x n', '/projects': 'ctrl+x p', '/estudio': 'ctrl+x s' };
+
+function paletaDeComandos() {
+    const itens = [
+        { secao: 'Sugeridos', nome: 'Nova conversa', cmd: '/clear', tecla: 'ctrl+x n' },
+        { secao: 'Sugeridos', nome: 'Trocar o modo e o esforço', desc: 'auto · primo code · chat', tecla: 'ctrl+x m', acao: (r) => r.abrirDialogo(dialogoModelo()) },
+        { secao: 'Sugeridos', nome: 'Agentes', desc: 'ligar e desligar', tecla: 'ctrl+x a', acao: (r) => r.abrirDialogo(dialogoAgentes()) },
+        { secao: 'Sugeridos', nome: 'Conversas salvas', tecla: 'ctrl+x l', acao: (r) => dialogoSessoes().then((d) => d && r.abrirDialogo(d)) },
+        { secao: 'Sugeridos', nome: 'Tema', desc: 'cor de destaque', tecla: 'ctrl+x t', acao: (r) => r.abrirDialogo(dialogoTema()) },
+        { secao: 'Sugeridos', nome: 'Mostrar ou esconder a barra da direita', tecla: 'ctrl+x b', acao: (r) => { r.lateralOculta = !r.lateralOculta; r._quadroAnterior = null; r._pintar(); } },
+    ];
+    for (const [nome, desc] of comandosDoMenu()) {
+        if (/^(\/uninstall|!comando|\/voice )/.test(nome) || nome.includes(' ') || nome === '/clear') continue;
+        itens.push({ secao: 'Comandos', nome, desc, cmd: nome, tecla: ATALHOS_DO_LIDER[nome] || '', preencher: /\s<|<.*>/.test(desc) && /^\/(dir|worktree|rule|lock|attach|read|run|open|history|howto)$/.test(nome) });
+    }
+    return itens;
+}
+
+function dialogoModelo() {
+    const atual = state.mode;
+    const esforco = effort.normalizar(state.config.effort);
+    const itens = [
+        ['auto', 'Auto', 'o PrimoCode escolhe entre fazer e conversar'],
+        ['primocode', 'Primo Code', 'o agente que cria e edita arquivos'],
+        ['chat', 'Chat', 'só conversa, sem mexer em nada'],
+    ].map(([id, nome, desc]) => ({ secao: 'Modo', nome: (atual === id ? '● ' : '  ') + nome, desc, id }));
+    for (const e of ['low', 'medium', 'high', 'ultracode']) itens.push({ secao: 'Esforço', nome: (esforco === effort.normalizar(e) ? '● ' : '  ') + effort.normalizar(e), desc: e === 'ultracode' ? 'o máximo' : '', esforco: e });
+    return {
+        titulo: 'Modo e esforço', itens,
+        aoEscolher: (it, r) => {
+            if (it.id) { state.mode = it.id; state.modoEfetivo = null; cfg.saveConfig({ mode: it.id }); r.toast(`Modo: ${NOME_MODO[it.id]}`, 'ok'); }
+            else { cfg.saveConfig({ effort: it.esforco }); state.config.effort = it.esforco; r.toast(`Esforço: ${effort.normalizar(it.esforco)}`, 'ok'); }
+            refreshPrompt();
+        },
+    };
+}
+
+function dialogoAgentes() {
+    let lista = [];
+    try { lista = require('../agentes-pessoais').listar({ dir: state.workDir }); } catch { lista = []; }
+    return {
+        titulo: 'Agentes',
+        vazio: 'Nenhum agente. /agentes criar <nome> | <o que faz> | <ofício>',
+        itens: lista.map((a) => ({ nome: (a.ligado ? '● ' : '○ ') + '@' + a.nome, desc: a.descricao || a.oficio || '', agente: a })),
+        aoEscolher: (it, r) => {
+            try {
+                const a = require('../agentes-pessoais').alternar(it.agente.nome, !it.agente.ligado, { dir: state.workDir });
+                r.toast(`@${a.nome} ${a.ligado ? 'ligado' : 'desligado'}`, 'ok');
+            } catch (e) { r.toast(e.message, 'erro'); }
+        },
+    };
+}
+
+async function dialogoSessoes() {
+    if (!conta.atual()) { if (rl) rl.toast('Entre na conta (/login) para ver as conversas salvas', 'aviso'); return null; }
+    const l = await nuvem.listarConversas({ limite: 30 });
+    if (!l.ok || !l.conversas.length) { if (rl) rl.toast(l.ok ? 'Nenhuma conversa salva ainda' : l.error, 'aviso'); return null; }
+    return {
+        titulo: 'Conversas',
+        itens: l.conversas.map((x, i) => ({ nome: x.titulo.slice(0, 44), desc: `${x.mensagens} msg`, tecla: x.atualizada ? new Date(x.atualizada).toLocaleDateString('pt-BR') : '', n: i + 1 })),
+        aoEscolher: (it, r) => { r.line = '/resume ' + it.n; r.cursor = r.line.length; r._enviar(); },
+    };
+}
+
+function dialogoTema() {
+    const atual = ui.temaDoMomento();
+    return {
+        titulo: 'Tema',
+        itens: Object.entries(ui.TEMAS).map(([id, t]) => ({ nome: (atual === id ? '● ' : '  ') + t.nome, id })),
+        aoEscolher: (it, r) => { ui.definirTema(it.id); cfg.saveConfig({ tema: it.id }); r._quadroAnterior = null; r._pintar(); r.toast(`Tema: ${ui.TEMAS[it.id].nome}`, 'ok'); },
+    };
+}
+
 /* O Tab com a caixa vazia gira o modo, como o "tab agents" do OpenCode:
    auto → primo code → chat → auto. A escolha fica salva, como a do /mode. */
 function trocarModo() {
@@ -507,6 +630,7 @@ function refreshPrompt() { if (rl) rl.prompt(); }
 // Enquanto uma pergunta está no ar, a próxima linha digitada é a RESPOSTA dela
 // — não um novo comando. Sem isso o "s" de confirmação virava prompt para a IA.
 let pendingAsk = null;
+let permissaoPendente = null;      // resolve a pergunta de permissão quando a pessoa aperta Esc
 
 /* ── O QUE A PESSOA ADIANTA ──────────────────────────────────────────────
  * Enquanto a abertura corre — e ela demora, porque confere o plano no
@@ -922,6 +1046,30 @@ async function prepararPasta(userText) {
  * entregar o mouse e o teclado.
  */
 async function autorizarControle(oQueVaiFazer, { primeira, tipo } = {}) {
+    /* NA TELA CHEIA a pergunta é um PAINEL AMARELO no meio da conversa (o de permissão do OpenCode):
+       "enter sim · a sempre · esc não". Só o /perms perguntar tem Enter = sim, porque a pessoa pediu para
+       ser perguntada naquele projeto. O primeiro pedido de controle do computador e o que "não tem volta"
+       mantêm o Enter = NÃO (o padrão de quem apertou Enter sem ler não entrega o mouse). */
+    if (rl && rl.cheia) {
+        const enterSim = !!tipo && tipo !== 'perigo';
+        const titulo = tipo === 'perigo' ? 'Isto não tem volta' : primeira ? 'O Primo quer usar o seu computador' : 'Permissão';
+        const w = Math.max(30, (process.stdout.columns || 80) - 2);
+        const teclas = enterSim
+            ? c.white('enter') + c.dim(' sim   ') + c.white('a') + c.dim(' sempre   ') + c.white('esc') + c.dim(' não')
+            : c.white('1') + c.dim(' sim, agora   ') + c.white('a') + c.dim(' sempre   ') + c.white('enter') + c.dim('/') + c.white('esc') + c.dim(' não');
+        console.log('');
+        console.log(tela.painelCor([c.warn(titulo) + '  ' + c.white(oQueVaiFazer), teclas], 'warn', w).join('\n'));
+        const dito = String(await Promise.race([
+            ask(''),
+            new Promise((res) => { permissaoPendente = () => res('esc'); }),
+        ])).trim().toLowerCase().replace(/[.!?,;:…]+/g, ' ').replace(/\s+/g, ' ').trim();
+        permissaoPendente = null;
+        if (dito === 'esc') { pendingAsk = null; console.log('  ' + c.muted('Não autorizado.') + c.dim(' Ele vai resolver por outro caminho.')); return 'nao'; }
+        if (dito === 'a' || /sess|sempre|tudo|todas|^2$/.test(dito)) { console.log('  ' + c.ok('✓ autorizado') + c.dim(' — esta sessão inteira. Fechar o PrimoCode esquece.')); return 'sessao'; }
+        if (dito === '1' || /^(s|sim|ok|pode|agora|y|yes|claro|vai)\b/.test(dito) || (dito === '' && enterSim)) { console.log('  ' + c.ok('✓ autorizado') + c.dim(' — só esta ação')); return 'agora'; }
+        console.log('  ' + c.muted('Não autorizado.') + c.dim(' Ele vai resolver por outro caminho.'));
+        return 'nao';
+    }
     /* O mesmo portão serve ao /permissoes (lib/permission/perigo.js): a pergunta muda de
        cabeçalho, as três respostas são as mesmas. */
     if (tipo) {
@@ -3009,7 +3157,10 @@ async function handleSlash(text) {
         }
 
         case 'clear': state.history = []; state.memoria = memoria.nova();
-            state.gravador.zerar(); console.log(c.ok('Conversa limpa.')); break;
+            state.gravador.zerar();
+            ui.estadoSessao.todos = []; ui.estadoSessao.arquivos.clear();
+            if (rl && rl.cheia) { rl.novaConversa(); rl.toast('Conversa nova', 'ok'); } else console.log(c.ok('Conversa limpa.'));
+            break;
         case 'cls': process.stdout.write('\x1Bc'); break;
 
         /* O /status olha só o servidor. O /doctor olha tudo o que costuma
@@ -3925,6 +4076,7 @@ async function main() {
        contexto, e sem conversa a home põe o logo e a caixa no meio da tela.
        PRIMOCODE_TELA=linha (ou "tela": "linha" no config) volta ao jeito
        antigo, que escreve em linha pelo terminal. */
+    if (state.config.tema) ui.definirTema(state.config.tema);
     const telaCheia = process.stdout.isTTY && process.stdout.rows >= 16
         && (process.env.PRIMOCODE_TELA || state.config.tela || 'cheia') !== 'linha';
     if (!telaCheia) {
@@ -3946,7 +4098,11 @@ async function main() {
         logoAnimado: (quadro, trabalhando) => ui.logoAnimado(state.config.mascot, quadro, trabalhando),
         agora: () => (ui.agora.texto && Date.now() - ui.agora.desde < 10 * 60 * 1000 ? ui.agora.texto : ''),
         versao: VERSION,
-        logo: ui.logoComMascote(state.config.mascot),
+        logo: [...ui.mascot(state.config.mascot), '', ...ui.logoBloco()],
+        logoSimples: ui.logoBloco(),
+        plano: () => { try { const eu = conta.atual(); return eu && eu.plano ? 'Plano ' + String(eu.plano).replace(/^./, (x) => x.toUpperCase()) : ''; } catch { return ''; } },
+        paleta: paletaDeComandos,
+        dialogos: { modelo: dialogoModelo, agente: dialogoAgentes, sessoes: dialogoSessoes, tema: dialogoTema },
         pasta: () => {
             const dir = state.workDir || process.cwd();
             const ramo = ramoDoGit(dir);
@@ -3954,7 +4110,8 @@ async function main() {
         },
     });
     if (telaCheia && state.workDirOrigem === 'padrao') {
-        console.log(c.warn(`  pasta padrão: ${shortPath(state.workDir)}`) + c.dim('  · /dir <pasta> para trabalhar numa sua'));
+        // Um aviso no canto, não uma linha na conversa: a home continua limpa.
+        rl.toast(`pasta padrão: ${shortPath(state.workDir)} · /dir <pasta> para trabalhar numa sua`, 'aviso', 7000);
     }
     /* A última conversa desta pasta, em uma linha (lib/passagem.js). Uma vez por abertura, só aqui (o -p já saiu
        antes) e só se a pessoa não abriu já retomando (-c / --resume). */
@@ -3987,6 +4144,7 @@ async function main() {
      * ela é desenhada pela própria caixa (ver lib/tui/entrada.js). */
     let ultimoEsc = 0;
     rl.on('escape', () => {
+        if (permissaoPendente) { permissaoPendente(); return; }     // Esc na pergunta de permissão = não
         if (!busy) { ultimoEsc = 0; return; }
         const agora = Date.now();
         if (agora - ultimoEsc < 2000) {

package/lib/config/config.js

@@ -343,6 +343,8 @@ function loadConfig() {
         // Piloto automático e agentes em grupo (docs/estrutura.md, seção 9). Desligados por padrão.
         piloto: file.piloto === true,
         grupo: file.grupo === true,
+        // Preferências da tela Configurações (legenda, silêncios, efeitos, voz, formato, idioma, testes).
+        preferencias: preferenciasValidas(file.preferencias),
         // A tela de primeira execução do app (docs/estrutura.md, 16.7): some depois de feita ou pulada.
         inicioFeito: file.inicioFeito === true,
         rootDir: ROOT_DIR,
@@ -350,12 +352,25 @@ function loadConfig() {
     };
 }
 
+/* Preferências da tela Configurações: só estas chaves, cada uma com o seu tipo. O resto é descartado. */
+const PREFERENCIAS = { legenda: 'b', silencio: 'b', sfx: 'b', testes: 'b', voz: 's', formato: 's', idioma: 's' };
+function preferenciasValidas(o) {
+    const out = {};
+    if (!o || typeof o !== 'object') return out;
+    for (const [k, t] of Object.entries(PREFERENCIAS)) {
+        if (t === 'b' && typeof o[k] === 'boolean') out[k] = o[k];
+        else if (t === 's' && typeof o[k] === 'string' && o[k].length <= 40) out[k] = o[k];
+    }
+    return out;
+}
+
 function saveConfig(partial) {
     ensureDir(CONFIG_DIR);
     const cur = (() => { try { return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')); } catch { return {}; } })();
     // Só persiste o que faz sentido guardar — nada de campos derivados.
     const { server, model, effort, token, autoApply, currentProject, userName, mascot, reacoes, theme, mode, permissoes, team, piloto, grupo, inicioFeito } = { ...cur, ...partial };
-    const next = { server, model, effort, token, autoApply, currentProject, userName, mascot, reacoes, theme, mode, permissoes, team, piloto, grupo, inicioFeito };
+    const preferencias = preferenciasValidas({ ...(cur.preferencias || {}), ...(partial.preferencias || {}) });
+    const next = { server, model, effort, token, autoApply, currentProject, userName, mascot, reacoes, theme, mode, permissoes, team, piloto, grupo, inicioFeito, preferencias };
     fs.writeFileSync(CONFIG_FILE, JSON.stringify(next, null, 2), 'utf8');
     return next;
 }

package/lib/diff.js

@@ -134,6 +134,8 @@ function desenhar(antes, depois, { prefixo = '', max = MAX_MOSTRADAS } = {}) {
     const out = [];
     let desenhadas = 0;
     let cortou = false;
+    let larguraFaixa = 20;
+    for (const bloco of blocos) for (const o of bloco) larguraFaixa = Math.max(larguraFaixa, 4 + 1 + 2 + Math.min(o.texto.length, 120) + 1);
 
     for (const bloco of blocos) {
         if (desenhadas >= max) { cortou = true; break; }
@@ -143,8 +145,16 @@ function desenhar(antes, depois, { prefixo = '', max = MAX_MOSTRADAS } = {}) {
             // removidas, o do antes. Sem número, "+ const x = 1" não diz onde.
             const n = String(o.b || o.a || '').padStart(4);
             const texto = o.texto.length > 120 ? o.texto.slice(0, 119) + '…' : o.texto;
-            if (o.tipo === '+') out.push(prefixo + c.dim(n) + ' ' + c.ok('+ ' + texto));
-            else if (o.tipo === '-') out.push(prefixo + c.dim(n) + ' ' + c.err('- ' + texto));
+            /* As linhas que entraram e saíram levam um FUNDO verde e vermelho até o fim
+               (o diff do OpenCode); as que ficaram, só o texto apagado. O fundo vale
+               a largura da linha mais comprida do bloco, para a faixa ficar reta. */
+            const faixa = (cor, fundo, sinal) => {
+                const corpo = `${n} ${sinal} ${texto}`;
+                return prefixo + fundo + c.dim(n) + fundo + ' ' + cor + sinal + ' ' + texto
+                    + ' '.repeat(Math.max(0, larguraFaixa - corpo.length)) + '\x1b[0m';
+            };
+            if (o.tipo === '+') out.push(faixa('\x1b[38;5;78m', '\x1b[48;5;22m', '+'));
+            else if (o.tipo === '-') out.push(faixa('\x1b[38;5;204m', '\x1b[48;5;52m', '-'));
             else out.push(prefixo + c.dim(n) + ' ' + c.dim('  ' + texto));
             desenhadas++;
         }

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

@@ -0,0 +1,81 @@
+// Transcrição da fala do app (bug 3, 02/11): o renderer grava com MediaRecorder e manda o WAV; aqui ele vira texto
+// com o Whisper local que o produto já tem (voz/primo_voz/transcrever.py, no voz-venv). Sem provedor pago, sem rede.
+// Nunca toca som: só lê um arquivo.
+'use strict';
+
+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)
+const TEMPO_MS = 120000;
+
+/** O que falta para transcrever aqui, ou null se está tudo pronto. `py` vem de lib/plugin/voz.js (o venv do Primo ganha). */
+function faltaAlgo(py) {
+    if (!py) return { error: 'o modo voz precisa do Python 3, e não achei nenhum nesta máquina.', comoResolver: 'instale o Python 3 e rode `primocode doutor`' };
+    try { execFileSync(py, ['-c', 'import faster_whisper'], { stdio: ['ignore', 'pipe', 'pipe'], timeout: 20000 }); return null; } catch {
+        return { error: 'falta o Whisper local (faster-whisper), que transforma a sua fala em texto.', comoResolver: 'rode `primocode doutor` (ou abra o /voice no terminal uma vez, que ele instala)' };
+    }
+}
+
+/** `transcrever(wav, { python })` → { ok, texto } | { ok:false, error, comoResolver? }. Nunca rejeita. */
+function transcrever(wav, { python: py, idioma = 'pt', tempoMs = TEMPO_MS } = {}) {
+    py = py || require('../plugin/voz').python();
+    const falta = faltaAlgo(py);
+    if (falta) return Promise.resolve({ ok: false, ...falta });
+    return new Promise((resolve) => {
+        const p = spawn(py, ['-m', 'primo_voz.transcrever', 'arquivo', wav, idioma], { cwd: PASTA_VOZ, env: { ...process.env, PYTHONPATH: PASTA_VOZ } });
+        let fora = '', erro = '';
+        const t = setTimeout(() => { try { p.kill('SIGKILL'); } catch { /* já saiu */ } resolve({ ok: false, error: 'a transcrição demorou demais' }); }, tempoMs);
+        p.stdout.on('data', (d) => { fora += d; });
+        p.stderr.on('data', (d) => { erro += d; });
+        p.on('error', (e) => { clearTimeout(t); resolve({ ok: false, error: e.message }); });
+        p.on('close', () => {
+            clearTimeout(t);
+            try { const r = JSON.parse(fora.trim().split('\n').pop()); resolve(r.ok ? { ok: true, texto: String(r.texto || '') } : { ok: false, error: r.error || 'não consegui transcrever' }); }
+            catch { resolve({ ok: false, error: erro.trim().split('\n').pop() || 'o transcritor não respondeu' }); }
+        });
+    });
+}
+
+/* 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 = 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' };
+    if (bytes.length > TETO_BYTES) return { ok: false, error: 'áudio grande demais (máximo ~5 minutos)' };
+    if (bytes.subarray(0, 4).toString('latin1') !== 'RIFF') return { ok: false, error: 'o áudio precisa ser WAV' };
+    const dir = pasta || path.join(os.tmpdir(), 'primocode-voz');
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const arq = path.join(dir, `fala-${Date.now()}-${process.pid}.wav`);
+    fs.writeFileSync(arq, bytes, { mode: 0o600 });
+    try { return await transcritor(arq); } finally { try { fs.rmSync(arq, { force: true }); } catch { /* sem arquivo */ } }
+}
+
+module.exports = { transcrever, transcreverVivo, transcreverBase64, aquecer, parar, faltaAlgo, TETO_BYTES };

package/lib/plugin/entregaveis/nucleo.js

@@ -103,7 +103,7 @@ function acharNavegador(env = process.env, existe = require('fs').existsSync) {
 function htmlParaPdf(htmlPath, pdfPath, { navegador = acharNavegador() } = {}) {
     if (!navegador) return { ok: false, erro: 'Chrome/Chromium não encontrado (defina PRIMO_CHROME)' };
     const { spawnSync } = require('child_process');
-    const r = spawnSync(navegador, ['--headless=new', '--disable-gpu', '--no-pdf-header-footer',
+    const r = spawnSync(navegador, ['--headless=new', '--use-mock-keychain', '--password-store=basic', '--disable-gpu', '--no-pdf-header-footer',
         `--print-to-pdf=${pdfPath}`, 'file://' + htmlPath], { encoding: 'utf8', timeout: 90000 });
     return require('fs').existsSync(pdfPath) ? { ok: true } : { ok: false, erro: (r.stderr || '').slice(-300) || 'PDF não saiu' };
 }
@@ -180,7 +180,7 @@ function htmlParaPngs(htmlPath, baseSemExt, n, w, h, { escala = 1, navegador = a
         const tmp = `${baseSemExt}.tmp-${i}.html`;
         const alvo = `${baseSemExt}-${String(i).padStart(2, '0')}.png`;
         fs.writeFileSync(tmp, html.replace('</head>', `<style>section:not(:nth-of-type(${i})){display:none!important}html,body{height:${h}px;overflow:hidden}</style></head>`));
-        spawnSync(navegador, ['--headless=new', '--disable-gpu', '--hide-scrollbars', `--force-device-scale-factor=${escala}`,
+        spawnSync(navegador, ['--headless=new', '--use-mock-keychain', '--password-store=basic', '--disable-gpu', '--hide-scrollbars', `--force-device-scale-factor=${escala}`,
             `--window-size=${w},${h}`, `--screenshot=${alvo}`, 'file://' + tmp], { encoding: 'utf8', timeout: 90000 });
         try { fs.unlinkSync(tmp); } catch {}
         if (fs.existsSync(alvo)) arquivos.push(alvo); else erro = `PNG ${i} não saiu`;

package/lib/plugin/estudio/gosto.js

@@ -519,6 +519,9 @@ function abrirTela({ home, abrir, timeoutMs = 10 * 60 * 1000, porta = 0, inicio
         const token = crypto.randomBytes(16).toString('hex');
         let html;
         try { html = fs.readFileSync(path.join(__dirname, 'gosto', 'tela.html'), 'utf8'); } catch { return resolve({ ok: false, motivo: 'sem_tela' }); }
+        // No app do PrimoCode a tela abre num quadro (iframe) e o "Finalizar" (window.close) não faz nada ali: avisa a janela de fora
+        // para fechar o quadro. Entra na hora de servir, porque o gosto/tela.html é guardado sem mudança (test/kits-tela.test.js confere o sha1).
+        html = html.replace('</body>', "<script>document.addEventListener('click',function(e){var b=e.target.closest&&e.target.closest('#finalizar');if(b&&window.parent!==window)window.parent.postMessage('primocode:tela-fim','*');},true);</script></body>");
         // os vídeos que já estão no gosto: quem abre o /referencias de novo vê o que já trouxe (só o nome)
         const jaTem = ((ler(home) || {}).referencias || []).map((r) => String(r.nome || 'vídeo').slice(0, 80));
         const dados = JSON.stringify({ ESTILOS, GOSTEI, NAO_QUERO, INICIO: inicio === 'referencias' ? 'referencias' : 'carrossel', JA_TEM: jaTem }).replace(/</g, '\\u003c');

package/lib/plugin/estudio/kits/tela.html

@@ -380,9 +380,11 @@ function mandar(rota, corpo) {
 }
 function erro(msg) { const e = $('#erro'); e.hidden = !msg; e.textContent = msg || ''; }
 
+/* No app do PrimoCode a tela abre dentro de um quadro (iframe): avisa a janela de fora que acabou, pra ela fechar o quadro. */
+function avisarApp() { try { if (window.parent !== window) setTimeout(() => window.parent.postMessage('primocode:tela-fim', '*'), 1200); } catch { /* aberta solta no navegador */ } }
 function mostrar(n) {
   [1, 4].forEach((i) => { $('#passo' + i).hidden = i !== n; });
-  if (n === 4) { $('#titulo').textContent = 'Pronto. O PrimoCode já sabe o estilo.'; $('#sub').hidden = true; }
+  if (n === 4) { $('#titulo').textContent = 'Pronto. O PrimoCode já sabe o estilo.'; $('#sub').hidden = true; avisarApp(); }
   window.scrollTo({ top: 0, behavior: parar ? 'auto' : 'smooth' });
 }