primocode 11.2.0 → 11.3.1

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v11.2.0
+# PrimoCode v11.3.1
 
 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.2.0
+ ▐▛███▜▌   Primo Code v11.3.1
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/lib/agentes-pessoais.js

@@ -7,7 +7,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 
-const ICONES = ['workflow', 'film', 'palette', 'pen', 'folder', 'shield', 'bell', 'sliders', 'home'];
+const ICONES = ['workflow', 'film', 'palette', 'pen', 'folder', 'shield', 'bell', 'sliders', 'home', 'scan-search', 'flask-conical', 'git-branch', 'pen-line', 'scissors', 'captions', 'trending-up', 'send', 'sparkles'];
 const hexOk = (h) => /^#[0-9a-f]{6}$/i.test(String(h || ''));
 const pasta = (dir) => dir || process.env.PRIMOCODE_AGENTES || path.join(os.homedir(), '.primocode', 'agentes');
 
@@ -44,7 +44,10 @@ function gravar(a, dir) {
 function listar({ dir } = {}) {
     let nomes = [];
     try { nomes = fs.readdirSync(pasta(dir)).filter((n) => n.endsWith('.md')); } catch { /* ainda não há */ }
-    return nomes.map((n) => ler(n.slice(0, -3), { dir })).filter(Boolean).sort((a, b) => a.nome.localeCompare(b.nome));
+    /* Na ordem em que foram criados (o arquivo mais antigo primeiro); empate por nome. */
+    const nasc = (n) => { try { return fs.statSync(path.join(pasta(dir), n)).birthtimeMs; } catch { return 0; } };
+    return nomes.map((n) => ({ n, t: nasc(n) })).sort((a, b) => a.t - b.t || a.n.localeCompare(b.n))
+        .map(({ n }) => ler(n.slice(0, -3), { dir })).filter(Boolean);
 }
 
 function validar(c, atual) {

package/lib/app-server/cli.js

@@ -39,7 +39,13 @@ async function main(args) {
     const falso = process.env.PRIMOCODE_MOTOR_FALSO;
     // PRIMOCODE_CONTA_FALSA=<arquivo.js>: { buscar, abrir } de mentira para o login (sem rede, sem navegador). Só para teste.
     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/enderecos.js

@@ -0,0 +1,43 @@
+// Endereços do computador para o pareamento do celular, na ordem em que valem a pena tentar.
+// Achado (02/11): com VPN (Tailscale, 100.64.0.0/10) a lista vinha com o IP da VPN primeiro, o QR levava só ele e o celular
+// no Wi-Fi não alcançava. Agora a rede local (192.168/16, 10/8, 172.16/12) vem antes, a VPN e os túneis por último,
+// e o código do QR leva TODOS (o app do celular tenta um por um).
+'use strict';
+
+const partes = (ip) => String(ip).split('.').map(Number);
+
+/* 0 = LAN doméstica/escritório (melhor), 1 = outro endereço roteável, 2 = VPN/túnel/link-local (último recurso). */
+function classe(ip, nome = '') {
+    const [a, b] = partes(ip);
+    if (/^(utun|tun|tap|ppp|ipsec|wg|tailscale|zt|vpn)/i.test(String(nome)) || /tailscale|zerotier|wireguard/i.test(String(nome))) return 2;
+    if (a === 100 && b >= 64 && b <= 127) return 2;      // CGNAT 100.64.0.0/10: Tailscale e afins
+    if (a === 169 && b === 254) return 2;                // link-local
+    if (a === 192 && b === 168) return 0;
+    if (a === 10) return 0;
+    if (a === 172 && b >= 16 && b <= 31) return 0;
+    return 1;
+}
+const peso = (ip) => { const [a, b] = partes(ip); return a === 192 && b === 168 ? 0 : a === 10 ? 1 : a === 172 ? 2 : 3; };
+
+/* `itens`: [{ ip, nome? }] ou ['ip', ...]. Estável e sem repetição. */
+function ordenar(itens) {
+    const lista = [];
+    const vistos = new Set();
+    for (const x of itens || []) {
+        const ip = typeof x === 'string' ? x : x && x.ip;
+        if (!ip || vistos.has(ip) || !/^\d{1,3}(\.\d{1,3}){3}$/.test(ip)) continue;
+        vistos.add(ip);
+        lista.push({ ip, nome: typeof x === 'string' ? '' : x.nome || '', i: lista.length });
+    }
+    lista.sort((p, q) => (classe(p.ip, p.nome) - classe(q.ip, q.nome)) || (peso(p.ip) - peso(q.ip)) || (p.i - q.i));
+    return lista.map((x) => x.ip);
+}
+
+/* Os IPv4 externos das interfaces, já ordenados. */
+function locais(interfaces) {
+    const itens = [];
+    for (const [nome, lista] of Object.entries(interfaces || {})) for (const i of lista || []) if (i.family === 'IPv4' && !i.internal) itens.push({ ip: i.address, nome });
+    return ordenar(itens);
+}
+
+module.exports = { ordenar, locais, classe };

package/lib/app-server/servidor.js

@@ -17,7 +17,7 @@ const { criarPortao } = require('../motor/aprovacao');
 const { ERRO, erro } = P;
 const MAX_LEITURA = 1024 * 1024;
 const BLOQUEADOS = /(^|[\\/])(\.ssh|\.aws|\.gnupg|\.env[^\\/]*|app-server\.json|pareamentos\.json|config\.json)$/;
-const CAMPOS_CONFIG = ['effort', 'model', 'mode', 'permissoes', 'userName', 'mascot', 'reacoes', 'theme', 'autoApply', 'piloto', 'grupo', 'inicioFeito'];
+const CAMPOS_CONFIG = ['effort', 'model', 'mode', 'permissoes', 'userName', 'mascot', 'reacoes', 'theme', 'autoApply', 'piloto', 'grupo', 'inicioFeito', 'preferencias'];
 const PILOTO_MS = Number(process.env.PRIMOCODE_PILOTO_MS) || 15 * 60000;
 
 const RAIZ_TELA = path.join(__dirname, '..', '..', 'app', 'renderer');
@@ -26,13 +26,20 @@ const TIPOS_ESTATICOS = {
     '.css': 'text/css; charset=utf-8', '.svg': 'image/svg+xml', '.png': 'image/png', '.json': 'application/json', '.ico': 'image/x-icon', '.woff2': 'font/woff2',
 };
 
-/* O que um celular pareado pode pedir ao motor: acompanhar, aprovar, mandar pedido, ver entrega e histórico.
-   Fica de fora: arquivos, configuração, projetos e agentes (escrita), terminal, abrir coisas no computador. */
+/* O que um celular pareado pode pedir ao motor. Desde 02/11 o app do celular tem TODAS as telas do desktop (Início, Studio, Projetos,
+   Agentes, Kit da marca, Avisos, Configurações, busca, voz), então as telas ganharam os pedidos delas, com limites:
+   config/write só nos campos de preferência (nunca permissões, piloto, modelo ou servidor), voice/start sem texto (não gera fala no
+   computador), fs/list e fs/read continuam de fora (arquivo do computador não vai para o celular).
+   Fica de fora: arquivos, permissões, piloto automático, abrir coisas no computador, conta (entrar/sair), pareamento, telas do Estúdio. */
 const PAREADO_PODE = new Set([
-    'thread/start', 'thread/list', 'thread/resume', 'thread/rename', 'turn/start', 'turn/interrupt', 'turn/queue',
+    'thread/start', 'thread/list', 'thread/resume', 'thread/rename', 'thread/archive', 'turn/start', 'turn/interrupt', 'turn/queue',
     'approval/respond', 'question/respond', 'notice/list', 'notice/read', 'studio/history', 'project/list', 'agent/list', 'config/read',
     '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']);
 
 const texto = (v) => (typeof v === 'string' ? v : '');
@@ -47,7 +54,16 @@ function abrirNoSistema(abs) {
 }
 const MIDIAS = { '.mp4': 'video/mp4', '.webm': 'video/webm', '.mov': 'video/quicktime', '.pdf': 'application/pdf', '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.webp': 'image/webp', '.gif': 'image/gif' };
 
-function criarServidor({ motor, casa, raizes, telaDir, abrir, voz, rede = false, enderecos, conta: contaOp = {} } = {}) {
+/* O login do GitHub, lido do hosts.yml do `gh` (sem rodar o gh). Devolve o usuário ou null. */
+function githubConectado() {
+    try {
+        const t = fs.readFileSync(path.join(os.homedir(), '.config', 'gh', 'hosts.yml'), 'utf8');
+        const m = /^\s+user:\s*(\S+)/m.exec(t);
+        return m ? m[1] : null;
+    } catch { return null; }
+}
+
+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;
@@ -67,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();
@@ -82,6 +100,24 @@ function criarServidor({ motor, casa, raizes, telaDir, abrir, voz, rede = false,
     let http_ = null;
     let porta = null;
 
+    /* A linha `primocode:abrir-gosto <url>` que o motor escreve no stderr (só com PRIMOCODE_APP=1, que o app liga) vira screen/open
+       para as telas do computador. O resto do stderr passa igual. */
+    let restoDoStderr = '';
+    const escreverStderr = process.stderr.write.bind(process.stderr);
+    const olharStderr = process.env.PRIMOCODE_APP === '1' && !process.env.PRIMOCODE_SEM_TELA_NO_APP;
+    function filtrarStderr(chunk) {
+        restoDoStderr = (restoDoStderr + String(chunk)).slice(-4000);
+        const linhas = restoDoStderr.split('\n');
+        restoDoStderr = linhas.pop();
+        for (const l of linhas) {
+            const url = require('../plugin/estudio/gosto').urlDaLinha(l);
+            if (url) for (const c of conexoes) { if (!c.pareado) { try { c.enviar(P.notificacao('screen/open', { url })); } catch { /* caiu */ } } }
+        }
+    }
+    if (olharStderr) {
+        process.stderr.write = (chunk, ...resto) => { try { filtrarStderr(chunk); } catch { /* nunca quebra o log */ } return escreverStderr(chunk, ...resto); };
+    }
+
     /* ── Conversas: um JSON por thread em ~/.primocode/threads ── */
     const arquivoDe = (id) => path.join(pastaThreads, `${id}.json`);
     function salvar(t) {
@@ -144,6 +180,27 @@ function criarServidor({ motor, casa, raizes, telaDir, abrir, voz, rede = false,
         };
     }
 
+    /* Título da conversa (bug 2): depois do primeiro turno de uma conversa nova, quem leu a troca escreve o título
+       (lib/session/titulo-conversa.js) e a tela recebe thread/renamed. Falha ou demora: fica o provisório. */
+    function perguntarTitulo(prompt) {
+        if (typeof m.titular === 'function') return m.titular(prompt);
+        const c = cfg.loadConfig();
+        let resposta = '';
+        return require('../provider/api').requestChat(c.server, { prompt, history: [], model: c.model, token: c.token }, (evt) => { if (evt.delta) resposta += evt.delta; }).then(() => resposta);
+    }
+    function batizar(t, pedido, resposta) {
+        const provisorio = t.provisorio;
+        if (!provisorio) return;
+        t.provisorio = null;
+        const texto_ = typeof resposta === 'string' ? resposta : Array.isArray(resposta) ? resposta.map((x) => (x && x.text) || '').join('') : '';
+        require('../session/titulo-conversa').escolher({ pedido, resposta: texto_, perguntar: perguntarTitulo }).then((titulo) => {
+            if (!titulo || t.dados.titulo !== provisorio) return;   // veio lixo, ou a pessoa já renomeou
+            t.dados.titulo = titulo.slice(0, 120);
+            salvar(t);
+            difundir('thread/renamed', { thread: t.dados.id, titulo: t.dados.titulo });
+        }).catch(() => { /* fica o provisório */ });
+    }
+
     /* ── Caminhos: só dentro das raízes permitidas, sem segredos ── */
     function caminhoSeguro(p) {
         const abs = path.resolve(texto(p));
@@ -214,7 +271,8 @@ function criarServidor({ motor, casa, raizes, telaDir, abrir, voz, rede = false,
             const c = cfg.loadConfig();
             const projeto = texto(p.projeto) || dados.projeto || undefined;
             if (projeto) dados.projeto = projeto;
-            if (dados.titulo === 'Nova conversa' && !dados.historico.length) dados.titulo = pedido.replace(/\s+/g, ' ').slice(0, 60);
+            // O título provisório é o começo do pedido; quando o primeiro turno termina, o modelo escreve o de verdade (batizar).
+            if (dados.titulo === 'Nova conversa' && !dados.historico.length) { dados.titulo = pedido.replace(/\s+/g, ' ').slice(0, 60); t.provisorio = dados.titulo; }
 
             // Menções (@arquivo) e anexos entram como instrução: não viram a fala da pessoa.
             const partes = [];
@@ -247,6 +305,7 @@ function criarServidor({ motor, casa, raizes, telaDir, abrir, voz, rede = false,
                 if (r && r.userMessage && !r.parado) {
                     dados.historico.push(r.userMessage);
                     if (r.assistantMessage) dados.historico.push(r.assistantMessage);
+                    batizar(t, pedido, r.assistantMessage && r.assistantMessage.content);
                 }
             }).catch((e) => {
                 // O motor já emite turn/interrupted com o erro; aqui só garante que a tela saiba.
@@ -313,7 +372,7 @@ function criarServidor({ motor, casa, raizes, telaDir, abrir, voz, rede = false,
         'brand/read'(p) {
             const vista = (k) => ({
                 nome: k.nome, cores: k.cores || {}, fontes: k.fontes || {}, tom: k.tom || '', slogan: k.slogan || '',
-                site: k.site || '', redes: k.redes || '', temLogo: !!k.logo, contraste: Marca.validarContraste(k.cores || {}),
+                site: k.site || '', redes: k.redes || '', temLogo: !!k.logo, logo: k.logo || null, contraste: Marca.validarContraste(k.cores || {}),
             });
             const ativa = (() => { try { return fs.readFileSync(path.join(Marca.raiz(), '.ativa'), 'utf8').trim() || null; } catch { return null; } })();
             if (p.nome) { const k = Marca.ler(p.nome); if (!k) throw erro(ERRO.NAO_ACHEI, `não há kit "${p.nome}"`); return { kit: vista(k), ativa }; }
@@ -328,7 +387,18 @@ function criarServidor({ motor, casa, raizes, telaDir, abrir, voz, rede = false,
             for (const k of ['tom', 'slogan', 'site', 'redes']) if (k in p) m[k] = texto(p[k]).slice(0, 300);
             if (p.cores && typeof p.cores === 'object') m.cores = { ...(atual.cores || {}), ...Object.fromEntries(Object.entries(p.cores).map(([k, v]) => [k, Marca.normHex(v) || v])) };
             if (p.fontes && typeof p.fontes === 'object') m.fontes = { ...(atual.fontes || {}), titulo: texto(p.fontes.titulo || (atual.fontes || {}).titulo), texto: texto(p.fontes.texto || (atual.fontes || {}).texto) };
-            const r = Marca.salvar(m);
+            // Logo vindo da tela: um data URL png ou svg de até 1 MB, gravado num arquivo temporário e copiado para o kit.
+            let logoArquivo = null;
+            if (p.logo && typeof p.logo.dataUrl === 'string') {
+                const mm = /^data:image\/(png|svg\+xml);base64,([A-Za-z0-9+/=]+)$/.exec(p.logo.dataUrl);
+                if (!mm) throw erro(ERRO.PARAMS, 'o logo tem que ser png ou svg');
+                const bytes = Buffer.from(mm[2], 'base64');
+                if (bytes.length > 1048576) throw erro(ERRO.PARAMS, 'o logo passa de 1 MB');
+                logoArquivo = path.join(os.tmpdir(), `primo-logo-${process.pid}-${Date.now()}.${mm[1] === 'png' ? 'png' : 'svg'}`);
+                fs.writeFileSync(logoArquivo, bytes, { mode: 0o600 });
+            }
+            let r;
+            try { r = Marca.salvar(m, { logoArquivo }); } finally { if (logoArquivo) { try { fs.unlinkSync(logoArquivo); } catch { /* já saiu */ } } }
             if (!r.ok) throw erro(ERRO.PARAMS, r.error);
             if (p.ativar) Marca.usar(nome);
             return metodos['brand/read']({ nome });
@@ -364,18 +434,38 @@ function criarServidor({ motor, casa, raizes, telaDir, abrir, voz, rede = false,
         },
 
         /* ── Pareamento do celular (só o computador, nunca um celular pareado) ── */
-        'pairing/info'() { return { rede: modoRede, porta, enderecos: modoRede ? enderecosLocais() : [], pareamentos: Pareamentos.listar() }; },
+        'pairing/info'() { return { rede: modoRede, porta: portaRede || porta, enderecos: modoRede ? enderecosLocais() : [], pareamentos: Pareamentos.listar() }; },
         'pairing/create'(p) {
             if (!modoRede) throw erro(ERRO.NEGADO, 'o servidor está só em 127.0.0.1. Suba com `primocode server --ws --rede` para parear um celular');
             const ips = enderecosLocais();
             if (!ips.length) throw erro(ERRO.NEGADO, 'não achei um endereço de rede local neste computador');
             const r = Pareamentos.criar(p.nome);
-            const urls = ips.map((ip) => `ws://${ip}:${porta}`);
-            const codigo = `${urls[0]}/?token=${r.token}`;
+            const urls = ips.map((ip) => `ws://${ip}:${portaRede || porta}`);
+            // O código leva TODOS os endereços: o primeiro vai no ws://, os outros em `&h=` (mesma porta). O app do celular tenta um por um.
+            const codigo = `${urls[0]}/?token=${r.token}${ips.length > 1 ? `&h=${ips.slice(1).join(',')}` : ''}`;
             const q = require('../qr').gerarQR(codigo, { ecc: 'M' });
             // A tela desenha o QR com estas linhas ('1' = módulo escuro); nenhum HTML vem do motor.
             return { ...r, urls, codigo, qr: { tamanho: q.tamanho, linhas: q.modulos.map((l) => l.map((b) => (b ? '1' : '0')).join('')) } };
         },
+        /* Telas do Estúdio dentro do app (estilos e gosto): o motor escreve a linha de protocolo no stderr (lib/plugin/estudio/gosto.js),
+           o servidor a vira `screen/open` e a tela mostra a página num quadro. `screen/dismiss` fecha pelo botão Fechar do quadro. */
+        async 'screen/dismiss'(p, conn) {
+            if (conn && conn.pareado) throw erro(ERRO.NEGADO, 'só o computador');
+            const url = require('../plugin/estudio/gosto').urlDaLinha(`primocode:abrir-gosto ${texto(p.url)}`);
+            if (!url) throw erro(ERRO.PARAMS, 'url inválida');
+            const u = new URL(url);
+            await new Promise((ok) => {
+                const rq = http.request({ host: '127.0.0.1', port: u.port, path: '/fechar', method: 'POST', headers: { 'x-gosto-token': u.searchParams.get('t'), 'content-length': 0 } }, (r) => { r.resume(); r.on('end', ok); });
+                rq.on('error', ok); rq.setTimeout(3000, () => { rq.destroy(); ok(); }); rq.end();
+            });
+            return { ok: true };
+        },
+        /* Liga/desliga o modo rede sem reiniciar (botão "Conectar celular"). Só o computador. */
+        async 'pairing/enable'(p, conn) {
+            if (conn && conn.pareado) throw erro(ERRO.NEGADO, 'só o computador');
+            const r = await mudarRede(p.ligar !== false);
+            return { ...r, enderecos: modoRede ? enderecosLocais() : [] };
+        },
         'pairing/list'() { return { pareamentos: Pareamentos.listar() }; },
         'pairing/revoke'(p) {
             const id = texto(p.id);
@@ -391,15 +481,18 @@ function criarServidor({ motor, casa, raizes, telaDir, abrir, voz, rede = false,
             out.servidor = c.server;
             out.temToken = !!c.token;
             out.projetoAtual = c.currentProject;
+            out.github = githubConectado();
             if (conn && conn.pareado) out.pareado = true;
             return out;
         },
-        'config/write'(p) {
+        'config/write'(p, conn) {
             const mudar = {};
-            for (const k of CAMPOS_CONFIG) if (k in p) mudar[k] = p[k];
+            const campos = conn && conn.pareado ? CAMPOS_CONFIG_PAREADO : CAMPOS_CONFIG;
+            for (const k of campos) if (k in p) mudar[k] = p[k];
+            if (conn && conn.pareado && !Object.keys(mudar).length && CAMPOS_CONFIG.some((k) => k in p)) throw erro(ERRO.NEGADO, 'o celular só muda as preferências; o resto é do computador');
             if (!Object.keys(mudar).length) throw erro(ERRO.PARAMS, `nada para gravar (campos: ${CAMPOS_CONFIG.join(', ')})`);
             cfg.saveConfig(mudar);
-            return metodos['config/read']();
+            return metodos['config/read']({}, conn);
         },
 
         /* ── Conta (login do app): só as funções de lib/config/conta.js. Nunca devolve token. ── */
@@ -430,8 +523,33 @@ 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) { return Voz.iniciar({ texto: p && p.texto }); },
+        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');
+            const r = await T.transcreverBase64(p && p.audio, { pasta: path.join(base, 'voz'), ...(transcritor ? { transcritor } : {}) });
+            if (!r.ok) return { ok: false, error: r.error, comoResolver: r.comoResolver };
+            return { ok: true, texto: r.texto };
+        },
 
         /* ── Studio: histórico do que o Estúdio gerou e abrir no sistema ── */
         'studio/history'(p) {
@@ -579,10 +697,8 @@ function criarServidor({ motor, casa, raizes, telaDir, abrir, voz, rede = false,
     }
     const tokenBate = (req) => !!autenticar(req);
     function enderecosLocais() {
-        if (enderecos) return enderecos();   // teste: endereços de mentira
-        const out = [];
-        for (const lista of Object.values(os.networkInterfaces())) for (const i of lista || []) if (i.family === 'IPv4' && !i.internal) out.push(i.address);
-        return out;
+        if (enderecos) return require('./enderecos').ordenar(enderecos());   // teste: endereços de mentira
+        return require('./enderecos').locais(os.networkInterfaces());   // LAN primeiro, VPN (100.64/10, utun) por último
     }
     /* Anti-rebind: no padrão só 127.0.0.1/localhost; com --rede também o IP (literal) de uma interface do computador. Nome de host nunca. */
     function hostPermitido(cabecalho) {
@@ -643,21 +759,27 @@ function criarServidor({ motor, casa, raizes, telaDir, abrir, voz, rede = false,
         fs.createReadStream(abs, { start: ini, end: fim }).on('error', () => res.destroy()).pipe(res);
     }
 
+    /* Um servidor HTTP+WebSocket com as regras do motor. Um só em 127.0.0.1; com a rede ligada, um segundo em 0.0.0.0 (porta própria). */
+    function criarHttp() {
+        const srv = http.createServer(estatico);
+        srv.on('upgrade', (req, socket) => {
+            const recusar = (codigo, frase) => { socket.write(`HTTP/1.1 ${codigo} ${frase}\r\nConnection: close\r\n\r\n`); socket.destroy(); };
+            const quem = autenticar(req);
+            if (!quem) return recusar(401, 'Unauthorized');
+            if (String(req.headers.upgrade || '').toLowerCase() !== 'websocket' || !req.headers['sec-websocket-key']) return recusar(400, 'Bad Request');
+            const conn = quem.pareado ? { pareado: quem.pareado } : {};
+            const sock = WS.aceitar(req, socket, { aoTexto: (t) => tratar(t, conn), aoFechar: () => soltar(conn) });
+            conn.enviar = (obj) => sock.enviar(JSON.stringify(obj, (k, v) => (v instanceof Error ? { mensagem: v.message, nome: v.name } : v)));
+            conn.fechar = sock.fechar;
+            conexoes.add(conn);
+        });
+        return srv;
+    }
+
     function ws({ porta: pedida = 0, rede: pedirRede } = {}) {
         if (pedirRede !== undefined) modoRede = !!pedirRede;
         return new Promise((resolve, reject) => {
-            http_ = http.createServer(estatico);
-            http_.on('upgrade', (req, socket) => {
-                const recusar = (codigo, frase) => { socket.write(`HTTP/1.1 ${codigo} ${frase}\r\nConnection: close\r\n\r\n`); socket.destroy(); };
-                const quem = autenticar(req);
-                if (!quem) return recusar(401, 'Unauthorized');
-                if (String(req.headers.upgrade || '').toLowerCase() !== 'websocket' || !req.headers['sec-websocket-key']) return recusar(400, 'Bad Request');
-                const conn = quem.pareado ? { pareado: quem.pareado } : {};
-                const sock = WS.aceitar(req, socket, { aoTexto: (t) => tratar(t, conn), aoFechar: () => soltar(conn) });
-                conn.enviar = (obj) => sock.enviar(JSON.stringify(obj, (k, v) => (v instanceof Error ? { mensagem: v.message, nome: v.name } : v)));
-                conn.fechar = sock.fechar;
-                conexoes.add(conn);
-            });
+            http_ = criarHttp();
             http_.on('error', reject);
             http_.listen(pedida, modoRede ? '0.0.0.0' : '127.0.0.1', () => {
                 porta = http_.address().port;
@@ -671,11 +793,32 @@ function criarServidor({ motor, casa, raizes, telaDir, abrir, voz, rede = false,
         });
     }
 
+    /* Liga ou desliga o modo rede em tempo de execução (o mesmo do --rede), sem reiniciar o app: sobe um segundo servidor em 0.0.0.0
+       (porta própria, a do QR). O de 127.0.0.1 não muda. Desligar derruba os celulares conectados. */
+    let redeSrv = null;
+    let portaRede = null;
+    async function mudarRede(ligar) {
+        if (ligar && !modoRede) {
+            if (!http_) throw erro(ERRO.NEGADO, 'o servidor ainda não está no ar');
+            await new Promise((ok, falha) => { const s2 = criarHttp(); s2.once('error', falha); s2.listen(0, '0.0.0.0', () => { redeSrv = s2; portaRede = s2.address().port; ok(); }); });
+            modoRede = true;
+        } else if (!ligar && modoRede && redeSrv) {
+            for (const c of [...conexoes]) if (c.pareado && c.fechar) c.fechar();
+            const s2 = redeSrv; redeSrv = null; portaRede = null; modoRede = false;
+            await new Promise((ok) => { s2.close(() => ok()); if (s2.closeAllConnections) s2.closeAllConnections(); setTimeout(ok, 500); });
+        }
+        return { rede: modoRede, porta: portaRede || porta };
+    }
+
     function fechar() {
+        if (olharStderr) process.stderr.write = escreverStderr;
         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/avisos.js

@@ -27,6 +27,7 @@ function criar(dados, { arquivo: a } = {}) {
         estado: aprov ? 'pendente' : 'novo',
         nivel: dados.nivel === 'erro' ? 'erro' : 'ok',
         texto: String(dados.texto || '').slice(0, 600),
+        detalhe: dados.detalhe ? String(dados.detalhe).slice(0, 300) : null,
         agente: dados.agente || null, thread: dados.thread || null, aprovacao: dados.aprovacao || null,
         criado: Date.now(),
     };