primocode 11.1.0 → 11.3.0

package/lib/app-server/servidor.js

@@ -0,0 +1,805 @@
+// App-server local: JSON-RPC 2.0 que expõe o motor às telas (docs/estrutura.md, seção 3).
+// Dois transportes: stdio (uma mensagem JSON por linha) e WebSocket em 127.0.0.1
+// com token de sessão. Com `rede: true` (primocode server --ws --rede) escuta na rede local e aceita
+// também tokens de PAREAMENTO (um por celular, revogável, com poderes limitados). Node puro, sem dependência.
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const http = require('http');
+const crypto = require('crypto');
+const P = require('./protocolo');
+const WS = require('./websocket');
+const { criarPareamentos } = require('./pareamento');
+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', 'preferencias'];
+const PILOTO_MS = Number(process.env.PRIMOCODE_PILOTO_MS) || 15 * 60000;
+
+const RAIZ_TELA = path.join(__dirname, '..', '..', 'app', 'renderer');
+const TIPOS_ESTATICOS = {
+    '.html': 'text/html; charset=utf-8', '.js': 'text/javascript; charset=utf-8', '.mjs': 'text/javascript; charset=utf-8',
+    '.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. 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', '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',
+]);
+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 : '');
+
+/* Abre um arquivo ou pasta no programa do sistema. Só caminho já validado chega aqui; sem shell. */
+function abrirNoSistema(abs) {
+    // Teste de tela: PRIMOCODE_ABRIR_LOG troca o programa do sistema por uma linha no arquivo.
+    if (process.env.PRIMOCODE_ABRIR_LOG) { try { fs.appendFileSync(process.env.PRIMOCODE_ABRIR_LOG, `${abs}\n`); } catch { /* sem log */ } return; }
+    const { spawn } = require('child_process');
+    const [cmd, args] = process.platform === 'darwin' ? ['open', [abs]] : process.platform === 'win32' ? ['explorer.exe', [abs]] : ['xdg-open', [abs]];
+    try { const f = spawn(cmd, args, { detached: true, stdio: 'ignore' }); f.on('error', () => {}); f.unref(); } catch { /* sem programa para abrir */ }
+}
+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' };
+
+/* 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 } = {}) {
+    const cfg = require('../config/config');
+    const m = motor || require('../motor');
+    const base = casa || cfg.CONFIG_DIR;
+    const pastaThreads = path.join(base, 'threads');
+    const arquivoInfo = path.join(base, 'app-server.json');
+    const token = crypto.randomBytes(24).toString('hex');
+    const Pareamentos = criarPareamentos({ arquivo: path.join(base, 'pareamentos.json') });
+    let modoRede = !!rede;
+    const permitidas = (raizes || [os.homedir()]).map((r) => path.resolve(r));
+
+    const dirAgentes = path.join(base, 'agentes');
+    const arqAvisos = path.join(base, 'avisos.json');
+    const Conta = require('../config/conta');
+    const Agentes = require('../agentes-pessoais');
+    const Avisos = require('../avisos');
+    const Projetos = require('../projetos-meta');
+    const Marca = require('../plugin/marca-kit');
+    const Piloto = require('../piloto');
+    const Voz = voz || require('../motor/voz').criarVoz({ pasta: path.join(base, 'voz') });
+    let loginNavegador = null;
+    const statusConta = () => {
+        const a = Conta.atual();
+        return a ? { logado: true, email: a.email, plano: a.plano, planoAte: a.planoAte, pro: !!a.pro }
+            : { logado: false, email: null, plano: null, planoAte: null, pro: false };
+    };
+    let timerPiloto = null;
+    let pilotoRodando = false;
+
+    const pastaTela = telaDir === undefined ? RAIZ_TELA : telaDir;
+    const conexoes = new Set();
+    const threads = new Map();      // id → { dados, dono, assinantes, rodando }: dono = quem mandou por último; assinantes = todos que abriram a conversa (recebem os eventos)
+    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) {
+        try {
+            fs.mkdirSync(pastaThreads, { recursive: true, mode: 0o700 });
+            fs.writeFileSync(arquivoDe(t.dados.id), JSON.stringify(t.dados), { mode: 0o600 });
+        } catch { /* falhar em guardar não derruba o turno */ }
+    }
+    function carregar(id) {
+        if (!/^[\w-]{1,64}$/.test(String(id || ''))) throw erro(ERRO.PARAMS, 'thread inválida');
+        if (threads.has(id)) return threads.get(id);
+        let dados;
+        try { dados = JSON.parse(fs.readFileSync(arquivoDe(id), 'utf8')); } catch { throw erro(ERRO.NAO_ACHEI, `não achei a conversa ${id}`); }
+        const t = { dados, dono: null, assinantes: new Set(), rodando: false };
+        threads.set(id, t);
+        return t;
+    }
+    const resumoDe = (d) => ({
+        id: d.id, titulo: d.titulo, criada: d.criada, atualizada: d.atualizada,
+        projeto: d.projeto || null, arquivada: !!d.arquivada, mensagens: (d.historico || []).length,
+    });
+    function listarDoDisco() {
+        let nomes = [];
+        try { nomes = fs.readdirSync(pastaThreads).filter((n) => n.endsWith('.json')); } catch { /* ainda não há */ }
+        const out = [];
+        for (const n of nomes) {
+            const id = n.slice(0, -5);
+            try { out.push(resumoDe((threads.get(id) || carregar(id)).dados)); } catch { /* arquivo quebrado: pula */ }
+        }
+        return out.sort((a, b) => (b.atualizada || 0) - (a.atualizada || 0));
+    }
+
+    /* ── Avisos: gravam em avisos.json e chegam a todas as telas abertas ── */
+    const difundir = (metodo, params) => { for (const c of conexoes) { try { c.enviar(P.notificacao(metodo, params)); } catch { /* conexão caiu */ } } };
+    const contagemAvisos = () => Avisos.contagem(Avisos.ler({ arquivo: arqAvisos }));
+    function novoAviso(dados) {
+        const av = Avisos.criar(dados, { arquivo: arqAvisos });
+        difundir('notice/created', { ...av, ...contagemAvisos(), estado: av.nivel === 'erro' ? 'erro' : 'ok', aviso: av });
+        return av;
+    }
+    const pilotoLigado = () => cfg.loadConfig().piloto === true;
+    /* O emissor de um turno: o que o motor emite vai à tela dona da conversa. Com o piloto ligado
+       (ou num turno do piloto) a aprovação vira aviso pendente, em vez de cartão no compositor;
+       todo notice/created do motor é gravado em avisos.json. */
+    function emissorDe(t) {
+        return (ev) => {
+            if (ev.evento === 'notice/created') {
+                novoAviso({ tipo: 'aviso', nivel: ev.estado === 'erro' ? 'erro' : 'ok', texto: ev.texto || (ev.erro && ev.erro.message) || '', thread: t.dados.id, agente: t.agente });
+                return;
+            }
+            if (ev.evento === 'approval/requested' && (t.agente || pilotoLigado())) {
+                novoAviso({ tipo: 'aprovacao', texto: ev.texto, thread: t.dados.id, aprovacao: ev.id, agente: t.agente });
+                return;
+            }
+            // Desktop e celular acompanham o MESMO turno: todo assinante da conversa (quem fez thread/resume ou mandou) recebe.
+            const msg = P.notificacao(ev.evento, { thread: t.dados.id, ...ev });
+            const para = new Set(t.assinantes);
+            if (t.dono) para.add(t.dono);
+            for (const c of para) { try { c.enviar(msg); } catch { /* conexão caiu */ } }
+        };
+    }
+
+    /* 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));
+        if (!texto(p)) throw erro(ERRO.PARAMS, 'falta path');
+        const dentro = permitidas.some((r) => abs === r || abs.startsWith(r + path.sep));
+        if (!dentro) throw erro(ERRO.NEGADO, 'caminho fora das pastas permitidas');
+        if (BLOQUEADOS.test(abs)) throw erro(ERRO.NEGADO, 'arquivo protegido');
+        return abs;
+    }
+
+    /* ── Métodos. Cada um: (params, conn) → resultado, ou lança erro(). ── */
+    const metodos = {
+        'thread/start'(p, conn) {
+            const agora = Date.now();
+            const dados = {
+                id: crypto.randomBytes(8).toString('hex'),
+                titulo: texto(p.titulo) || 'Nova conversa',
+                criada: agora, atualizada: agora,
+                projeto: texto(p.projeto) || null, arquivada: false,
+                historico: [],
+            };
+            const t = { dados, dono: conn, assinantes: new Set(conn ? [conn] : []), rodando: false };
+            threads.set(dados.id, t);
+            salvar(t);
+            return resumoDe(dados);
+        },
+        'thread/list'(p) {
+            const todas = listarDoDisco();
+            return { threads: p.arquivadas ? todas : todas.filter((x) => !x.arquivada) };
+        },
+        'thread/resume'(p, conn) {
+            const t = carregar(p.thread);
+            if (conn) { t.assinantes.add(conn); if (!t.rodando) t.dono = conn; }
+            return { ...resumoDe(t.dados), mensagens: t.dados.historico, rodando: t.rodando };
+        },
+        'thread/rename'(p) {
+            const t = carregar(p.thread);
+            const titulo = texto(p.titulo).trim();
+            if (!titulo) throw erro(ERRO.PARAMS, 'falta titulo');
+            t.dados.titulo = titulo.slice(0, 120);
+            salvar(t);
+            return resumoDe(t.dados);
+        },
+        'thread/archive'(p) {
+            const t = carregar(p.thread);
+            t.dados.arquivada = p.arquivar !== false;
+            salvar(t);
+            return resumoDe(t.dados);
+        },
+
+        async 'turn/start'(p, conn) {
+            const pedido = texto(p.texto).trim();
+            if (!pedido) throw erro(ERRO.PARAMS, 'falta texto');
+            if (conn && conn.pareado) {
+                // O celular não lê arquivos nem escolhe pasta: só usa um projeto já registrado, sem menções nem anexos.
+                if (p.projeto && !Projetos.listar().some((x) => x.caminho === p.projeto)) throw erro(ERRO.NEGADO, 'projeto desconhecido');
+                p = { ...p, mencoes: undefined, anexos: undefined };
+            }
+            let t;
+            if (p.thread) t = carregar(p.thread);
+            else { const novo = metodos['thread/start']({ projeto: p.projeto }, conn); t = threads.get(novo.id); }
+            if (t.rodando) throw erro(ERRO.OCUPADO, 'já há um turno rodando nesta conversa; use turn/queue');
+            if (pilotoRodando) throw erro(ERRO.OCUPADO, 'o piloto automático está trabalhando; espere ou desligue-o');
+            t.dono = conn;
+            if (conn) t.assinantes.add(conn);
+            t.rodando = true;
+            const dados = t.dados;
+            const c = cfg.loadConfig();
+            const projeto = texto(p.projeto) || dados.projeto || undefined;
+            if (projeto) dados.projeto = projeto;
+            // 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 = [];
+            if (Array.isArray(p.mencoes) && p.mencoes.length && projeto) {
+                const { arquivos } = require('../mencoes').mencoes(p.mencoes.map((x) => `@"${x}"`).join(' '), projeto);
+                for (const a of arquivos) {
+                    try { partes.push(`Arquivo mencionado ${a.rel}:\n${fs.readFileSync(a.abs, 'utf8')}`); } catch { /* sumiu */ }
+                }
+            }
+            if (Array.isArray(p.anexos) && p.anexos.length) partes.push(`Anexos do pedido: ${p.anexos.map(String).join(', ')}`);
+            if (p.tipo) partes.push(require('../plugin/estudio/criar').instrucaoDoTipo(texto(p.tipo)));
+            // @agente chama na hora; os ligados vão de cardápio (a IA escolhe, não a regex).
+            const ag = Agentes.instrucao(pedido, p.agentes, { dir: dirAgentes });
+            if (ag.texto) partes.push(ag.texto);
+
+            const emitir = emissorDe(t);
+            t.portao = criarPortao({ emitir });
+            const memoria = require('../session/memoria-conversa');
+            const opts = {
+                texto: pedido, emitir, portao: t.portao,
+                autorizar: t.portao.autorizar, perguntar: t.portao.perguntar,
+                server: c.server, model: c.model, effort: texto(p.esforco) || c.effort, token: c.token,
+                history: memoria.paraEnviar(memoria.nova(), dados.historico),
+                projectDir: projeto, projectName: projeto ? path.basename(projeto) : undefined,
+                permissoes: c.permissoes, semTerminal: false,
+                instrucao: partes.join('\n\n'),
+            };
+            // O turno roda solto: o cliente recebe turn/* por notificação, não pela resposta.
+            Promise.resolve().then(() => m.iniciarTurno(opts)).then((r) => {
+                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.
+                emitir({ evento: 'notice/created', estado: 'erro', texto: e && e.message });
+            }).finally(() => {
+                t.rodando = false;
+                if (t.portao) t.portao.cancelar();
+                dados.atualizada = Date.now();
+                salvar(t);
+            });
+            return { thread: dados.id };
+        },
+        'turn/interrupt'(p) {
+            const t = p.thread ? carregar(p.thread) : null;
+            if (t && !t.rodando) return { interrompido: false };
+            // Quem espera uma resposta é solto como NÃO antes de parar o turno.
+            for (const x of t ? [t] : threads.values()) if (x.portao) x.portao.cancelar();
+            m.interromper();
+            return { interrompido: true };
+        },
+        'turn/queue'(p) {
+            const pedido = texto(p.texto).trim();
+            if (!pedido) throw erro(ERRO.PARAMS, 'falta texto');
+            return { enfileirado: !!m.mandarDuranteATarefa(pedido) };
+        },
+
+        // Respostas ao que o motor pediu (approval/requested, question/requested).
+        'approval/respond'(p) {
+            const id = texto(p.id);
+            if (!id) throw erro(ERRO.PARAMS, 'falta id');
+            if (!p.aceitar && !p.recusar && !p.sempre) throw erro(ERRO.PARAMS, 'diga aceitar, recusar ou sempre');
+            for (const t of p.thread ? [carregar(p.thread)] : threads.values()) {
+                if (t.portao && t.portao.responderAprovacao(id, p)) {
+                    Avisos.resolverAprovacao(id, p.recusar ? 'nao' : p.sempre ? 'sessao' : 'agora', { arquivo: arqAvisos });
+                    difundir('notice/changed', contagemAvisos());
+                    return { ok: true, ...contagemAvisos() };
+                }
+            }
+            throw erro(ERRO.NAO_ACHEI, `não há aprovação pendente ${id}`);
+        },
+        'question/respond'(p) {
+            const id = texto(p.id);
+            if (!id) throw erro(ERRO.PARAMS, 'falta id');
+            if (!Array.isArray(p.respostas)) throw erro(ERRO.PARAMS, 'falta respostas (lista)');
+            for (const t of p.thread ? [carregar(p.thread)] : threads.values()) {
+                if (t.portao && t.portao.responderPergunta(id, p.respostas)) return { ok: true };
+            }
+            throw erro(ERRO.NAO_ACHEI, `não há pergunta pendente ${id}`);
+        },
+
+        /* ── Projetos (pasta + ícone + cor + descrição) ── */
+        'project/list'(p) { return { projetos: Projetos.listar({ arquivados: !!p.arquivados }) }; },
+        'project/create'(p) {
+            try { const r = Projetos.criar(p); difundir('project/changed', { id: r.id }); return r; } catch (e) { throw erro(ERRO.PARAMS, e.message); }
+        },
+        'project/update'(p) {
+            try { const r = Projetos.atualizar(p.id, p); difundir('project/changed', { id: r.id }); return r; } catch (e) { throw erro(/não achei/.test(e.message) ? ERRO.NAO_ACHEI : ERRO.PARAMS, e.message); }
+        },
+        'project/delete'(p) {
+            try { const r = Projetos.arquivar(p.id); difundir('project/changed', { id: r.id }); return r; } catch (e) { throw erro(ERRO.NAO_ACHEI, e.message); }
+        },
+
+        /* ── Kit da marca (lib/marca-kit.js) ── */
+        '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, 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 }; }
+            return { kits: Marca.listar().map(vista), ativa };
+        },
+        'brand/write'(p) {
+            const nome = texto(p.nome).trim();
+            if (!nome) throw erro(ERRO.PARAMS, 'falta nome');
+            if (p.apagar) { const r = Marca.apagar(nome); if (!r.ok) throw erro(ERRO.NAO_ACHEI, r.error); return { apagado: true }; }
+            const atual = Marca.ler(nome) || {};
+            const m = { ...atual, nome };
+            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) };
+            // 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 });
+        },
+
+        /* ── Agentes ── */
+        'agent/list'() { return { agentes: Agentes.listar({ dir: dirAgentes }), piloto: pilotoEstado() }; },
+        'agent/create'(p) { return agenteOp(() => Agentes.criar(p, { dir: dirAgentes })); },
+        'agent/update'(p) { return agenteOp(() => Agentes.atualizar(p.nome, p, { dir: dirAgentes })); },
+        'agent/delete'(p) { return agenteOp(() => Agentes.apagar(p.nome, { dir: dirAgentes })); },
+        'agent/toggle'(p) { return agenteOp(() => Agentes.alternar(p.nome, typeof p.ligado === 'boolean' ? p.ligado : undefined, { dir: dirAgentes })); },
+
+        /* ── Piloto automático e avisos ── */
+        'autopilot/set'(p) {
+            const mudar = {};
+            if ('ligado' in p) mudar.piloto = p.ligado === true;
+            if ('grupo' in p) mudar.grupo = p.grupo === true;
+            if (!Object.keys(mudar).length) throw erro(ERRO.PARAMS, 'diga ligado e/ou grupo');
+            cfg.saveConfig(mudar);
+            agendarPiloto();
+            const r = pilotoEstado();
+            difundir('agent/changed', { piloto: r });
+            return r;
+        },
+        async 'autopilot/run'() {
+            if (pilotoRodando) throw erro(ERRO.OCUPADO, 'o piloto já está num ciclo');
+            return rodarCiclo();
+        },
+        'notice/list'() { return Avisos.listar({ arquivo: arqAvisos }); },
+        'notice/read'(p) {
+            if (!p.id && !p.todos) throw erro(ERRO.PARAMS, 'diga id ou todos');
+            try { const r = Avisos.marcarLido({ id: p.id, todos: !!p.todos }, { arquivo: arqAvisos }); difundir('notice/changed', contagemAvisos()); return r; } catch (e) { throw erro(ERRO.NAO_ACHEI, e.message); }
+        },
+
+        /* ── Pareamento do celular (só o computador, nunca um celular pareado) ── */
+        '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}:${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);
+            if (!Pareamentos.revogar(id)) throw erro(ERRO.NAO_ACHEI, 'não existe esse pareamento');
+            for (const c of [...conexoes]) if (c.pareado && c.pareado.id === id && c.fechar) c.fechar();
+            return { revogado: id, pareamentos: Pareamentos.listar() };
+        },
+
+        'config/read'(p, conn) {
+            const c = cfg.loadConfig();
+            const out = {};
+            for (const k of CAMPOS_CONFIG) out[k] = c[k];
+            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, conn) {
+            const mudar = {};
+            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']({}, conn);
+        },
+
+        /* ── Conta (login do app): só as funções de lib/config/conta.js. Nunca devolve token. ── */
+        'account/status'() { return statusConta(); },
+        async 'account/login'(p) {
+            const r = await Conta.entrar({ email: texto(p.email), senha: texto(p.senha) }, { buscar: contaOp.buscar });
+            if (!r.ok) return { ok: false, error: r.error };
+            difundir('account/changed', statusConta());
+            return { ok: true, ...statusConta() };
+        },
+        async 'account/login-browser'() {
+            if (loginNavegador) return { ok: true, emAndamento: true, url: loginNavegador.url };
+            let urlPronta;
+            const aUrl = new Promise((res) => { urlPronta = res; });
+            const estado = { url: null };
+            loginNavegador = estado;
+            Conta.entrarPeloNavegador({ abrir: contaOp.abrir, buscar: contaOp.buscar, aviso: (u) => { estado.url = u; urlPronta(u); } })
+                .then((r) => difundir('account/changed', { ...statusConta(), ...(r && r.ok ? {} : { erro: (r && r.error) || 'o login não concluiu.' }) }))
+                .catch((e) => difundir('account/changed', { ...statusConta(), erro: e.message }))
+                .finally(() => { loginNavegador = null; urlPronta(null); });
+            const url = await aUrl;
+            return { ok: true, iniciado: true, url };
+        },
+        'account/logout'() {
+            Conta.sair();
+            difundir('account/changed', statusConta());
+            return { ok: true, ...statusConta() };
+        },
+
+        /* ── 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(); },
+        /* 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) {
+            const r = require('../plugin/estudio/historico').historico({ busca: texto(p.busca), limite: p.limite });
+            return { ...r, tipos: Object.keys(require('../plugin/estudio/criar').QUADRADOS) };
+        },
+        'studio/open'(p) {
+            let abs = caminhoSeguro(p.path);
+            if (!fs.existsSync(abs)) throw erro(ERRO.NAO_ACHEI, 'não achei o arquivo');
+            if (p.pasta && !fs.statSync(abs).isDirectory()) abs = path.dirname(abs);
+            (abrir || abrirNoSistema)(abs);
+            return { aberto: abs };
+        },
+
+        'fs/list'(p) {
+            const abs = caminhoSeguro(p.path);
+            let itens;
+            try { itens = fs.readdirSync(abs, { withFileTypes: true }); } catch (e) { throw erro(ERRO.NAO_ACHEI, `não consegui listar: ${e.code || e.message}`); }
+            return {
+                path: abs,
+                itens: itens.filter((d) => !BLOQUEADOS.test(path.join(abs, d.name)))
+                    .map((d) => ({ nome: d.name, tipo: d.isDirectory() ? 'pasta' : 'arquivo' }))
+                    .sort((a, b) => (a.tipo === b.tipo ? a.nome.localeCompare(b.nome) : a.tipo === 'pasta' ? -1 : 1)),
+            };
+        },
+        'fs/read'(p) {
+            const abs = caminhoSeguro(p.path);
+            let st;
+            try { st = fs.statSync(abs); } catch (e) { throw erro(ERRO.NAO_ACHEI, `não achei: ${e.code || e.message}`); }
+            if (!st.isFile()) throw erro(ERRO.PARAMS, 'não é arquivo');
+            if (st.size > MAX_LEITURA) throw erro(ERRO.PARAMS, `grande demais (limite ${MAX_LEITURA / 1024} KB)`);
+            return { path: abs, bytes: st.size, conteudo: fs.readFileSync(abs, 'utf8') };
+        },
+    };
+
+
+    /* ── Agentes e piloto: helpers ── */
+    function agenteOp(fn) {
+        try { const r = fn(); difundir('agent/changed', { nome: r.nome }); return r; } catch (e) { throw erro(/não achei/.test(e.message) ? ERRO.NAO_ACHEI : ERRO.PARAMS, e.message); }
+    }
+    const pilotoEstado = () => { const c = cfg.loadConfig(); return { ligado: c.piloto === true, grupo: c.grupo === true, rodando: pilotoRodando }; };
+    const algumRodando = () => [...threads.values()].some((x) => x.rodando);
+
+    /* Um agente do piloto roda como uma conversa própria, com o ofício na frente. Aprovações viram aviso. */
+    async function executarAgente(agente, pedido) {
+        const c = cfg.loadConfig();
+        const dados = { id: `piloto-${agente.nome}-${Date.now().toString(36)}`, titulo: `@${agente.nome} (piloto)`, criada: Date.now(), atualizada: Date.now(), projeto: null, arquivada: true, historico: [] };
+        const t = { dados, dono: null, assinantes: new Set(), rodando: true, agente: agente.nome };
+        threads.set(dados.id, t);
+        const emitir = emissorDe(t);
+        t.portao = criarPortao({ emitir });
+        const proj = agente.onde && agente.onde !== 'fora' ? Projetos.pastaDe(agente.onde) : null;
+        try {
+            const r = await m.iniciarTurno({
+                texto: pedido, emitir, portao: t.portao, autorizar: t.portao.autorizar, perguntar: t.portao.perguntar,
+                server: c.server, model: c.model, effort: c.effort, token: c.token, history: [],
+                projectDir: proj || undefined, projectName: proj ? path.basename(proj) : undefined,
+                permissoes: 'perguntar', semTerminal: false,
+                instrucao: `Seu ofício:\n${agente.oficio}`,
+            });
+            return r && r.assistantMessage ? textoDe(r.assistantMessage.content) : '';
+        } finally {
+            t.rodando = false;
+            if (t.portao) t.portao.cancelar();
+            threads.delete(dados.id);
+        }
+    }
+    const textoDe = (c) => (typeof c === 'string' ? c : Array.isArray(c) ? c.map((x) => (x && x.text) || '').join('') : '');
+
+    async function rodarCiclo() {
+        pilotoRodando = true;
+        difundir('agent/changed', { piloto: pilotoEstado() });
+        try {
+            const c = cfg.loadConfig();
+            const r = await Piloto.ciclo({
+                agentes: Agentes.listar({ dir: dirAgentes }), grupo: c.grupo === true,
+                executar: executarAgente, ocupado: () => [...threads.values()].some((x) => x.rodando && !x.agente),
+                freio: opcoesPiloto.freio,
+            });
+            for (const e of r.executados) novoAviso({ tipo: 'aviso', nivel: e.ok ? 'ok' : 'erro', texto: `@${e.agente}: ${e.resumo || (e.ok ? 'terminou' : 'falhou')}`, agente: e.agente });
+            return r;
+        } finally { pilotoRodando = false; difundir('agent/changed', { piloto: pilotoEstado() }); }
+    }
+    const opcoesPiloto = { freio: undefined };
+    function agendarPiloto() {
+        if (timerPiloto) { clearInterval(timerPiloto); timerPiloto = null; }
+        if (!pilotoLigado()) return;
+        timerPiloto = setInterval(() => { if (!pilotoRodando && !algumRodando()) rodarCiclo().catch(() => {}); }, PILOTO_MS);
+        timerPiloto.unref();
+    }
+    agendarPiloto();
+
+    /* ── Despacho: uma mensagem de uma conexão ── */
+    async function tratar(linha, conn) {
+        const r = P.interpretar(linha);
+        if (r.vazio || r.resposta) return;
+        if (r.erro) { conn.enviar(r.erro); return; }
+        const { msg } = r;
+        const temId = 'id' in msg;
+        const fn = Object.prototype.hasOwnProperty.call(metodos, msg.method) ? metodos[msg.method] : null;
+        if (fn && conn.pareado && !PAREADO_PODE.has(msg.method)) {
+            if (temId) conn.enviar(P.respostaErro(msg.id, ERRO.NEGADO, `um celular pareado não pode usar ${msg.method}`));
+            return;
+        }
+        if (fn && conn.pareado) Pareamentos.marcarUso(conn.pareado.id);
+        if (!fn) { if (temId) conn.enviar(P.respostaErro(msg.id, ERRO.METODO, `método não existe: ${msg.method}`)); return; }
+        try {
+            const res = await fn(msg.params || {}, conn);
+            if (temId) conn.enviar(P.resposta(msg.id, res));
+        } catch (e) {
+            if (!temId) return;
+            if (e && e.codigo) conn.enviar(P.respostaErro(msg.id, e.codigo, e.message, e.data));
+            else conn.enviar(P.respostaErro(msg.id, ERRO.INTERNO, e && e.message));
+        }
+    }
+
+    function soltar(conn) {
+        conexoes.delete(conn);
+        for (const t of threads.values()) { if (t.dono === conn) t.dono = null; t.assinantes.delete(conn); }
+    }
+
+    /* ── Transporte stdio ── */
+    function stdio(entrada = process.stdin, saida = process.stdout) {
+        const conn = { enviar: (obj) => { try { saida.write(P.serializar(obj)); } catch { /* pipe fechou */ } } };
+        conexoes.add(conn);
+        const corta = P.cortador();
+        entrada.setEncoding && entrada.setEncoding('utf8');
+        entrada.on('data', (d) => { for (const l of corta.push(d)) tratar(l, conn); });
+        entrada.on('end', () => { const s = corta.sobra(); if (s) tratar(s, conn); soltar(conn); });
+        return conn;
+    }
+
+    /* ── Transporte WebSocket: token na URL (?token=) ou em Authorization: Bearer ──
+       O token de sessão só vale vindo do próprio computador; da rede só entra token de pareamento. */
+    const iguais = (a, b) => { const x = Buffer.from(a); const y = Buffer.from(b); return x.length === y.length && crypto.timingSafeEqual(x, y); };
+    function autenticar(req) {
+        let dado = '';
+        try { dado = new URL(req.url, 'http://127.0.0.1').searchParams.get('token') || ''; } catch { /* url torta */ }
+        const auth = String(req.headers.authorization || '');
+        if (!dado && /^Bearer /i.test(auth)) dado = auth.slice(7).trim();
+        if (!dado) return null;
+        if (iguais(dado, token)) return LOOPBACK.has(req.socket.remoteAddress) ? { tipo: 'mestre' } : null;
+        const r = Pareamentos.validar(dado);
+        return r ? { tipo: 'pareado', pareado: r } : null;
+    }
+    const tokenBate = (req) => !!autenticar(req);
+    function enderecosLocais() {
+        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) {
+        const host = String(cabecalho || '').replace(/:\d+$/, '');
+        if (host === '127.0.0.1' || host === 'localhost') return true;
+        return modoRede && /^\d{1,3}(\.\d{1,3}){3}$/.test(host) && enderecosLocais().includes(host);
+    }
+
+    /* GET / e arquivos de app/renderer: só 127.0.0.1 (Host conferido contra rebind). O token
+       continua exigido no WebSocket; a página só entrega o HTML e o JS. */
+    function estatico(req, res) {
+        const nega = (c, m) => { res.writeHead(c, { 'Content-Type': 'text/plain; charset=utf-8' }); res.end(m); };
+        if (!hostPermitido(req.headers.host)) return nega(403, 'host não permitido');
+        if (req.method !== 'GET' && req.method !== 'HEAD') return nega(426, 'use WebSocket');
+        if (/^\/midia(\?|$)/.test(req.url)) return midia(req, res, nega);
+        // O app do celular pergunta se o token ainda vale (revogado?). Só diz sim ou não ao dono do token; CORS aberto porque a página do celular é de outra origem.
+        if (/^\/pareamento\/valido(\?|$)/.test(req.url)) {
+            const q = autenticar(req);
+            res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store', 'Access-Control-Allow-Origin': '*' });
+            return res.end(JSON.stringify({ valido: !!(q && q.tipo === 'pareado') }));
+        }
+        if (!pastaTela) return nega(426, 'use WebSocket');
+        let rel;
+        try { rel = decodeURIComponent(new URL(req.url, 'http://127.0.0.1').pathname); } catch { return nega(400, 'url torta'); }
+        if (rel === '/') rel = '/index.html';
+        const abs = path.join(pastaTela, rel);
+        if (abs !== pastaTela && !abs.startsWith(pastaTela + path.sep)) return nega(403, 'fora da pasta');
+        fs.readFile(abs, (e, dados) => {
+            if (e) return nega(404, 'não achei');
+            res.writeHead(200, {
+                'Content-Type': TIPOS_ESTATICOS[path.extname(abs)] || 'application/octet-stream',
+                'Cache-Control': 'no-store', 'X-Content-Type-Options': 'nosniff', 'Referrer-Policy': 'no-referrer',
+            });
+            res.end(req.method === 'HEAD' ? undefined : dados);
+        });
+    }
+
+    /* GET /midia?path=…&token=…: a prévia do que o Estúdio gerou (vídeo, PDF, imagem). Exige o token,
+       só serve dentro das raízes permitidas e só as extensões de mídia; vídeo aceita Range. */
+    function midia(req, res, nega) {
+        if (!tokenBate(req)) return nega(401, 'sem token');
+        let abs;
+        try { abs = caminhoSeguro(new URL(req.url, 'http://127.0.0.1').searchParams.get('path')); } catch { return nega(403, 'caminho não permitido'); }
+        const tipo = MIDIAS[path.extname(abs).toLowerCase()];
+        if (!tipo) return nega(403, 'tipo não permitido');
+        let st; try { st = fs.statSync(abs); if (!st.isFile()) throw new Error('x'); } catch { return nega(404, 'não achei'); }
+        const cab = { 'Content-Type': tipo, 'Accept-Ranges': 'bytes', 'Cache-Control': 'no-store', 'X-Content-Type-Options': 'nosniff' };
+        const m = /^bytes=(\d*)-(\d*)$/.exec(String(req.headers.range || ''));
+        let ini = 0; let fim = st.size - 1; let codigo = 200;
+        if (m && (m[1] || m[2])) {
+            if (m[1]) { ini = Number(m[1]); if (m[2]) fim = Math.min(fim, Number(m[2])); } else { ini = Math.max(0, st.size - Number(m[2])); }
+            if (ini > fim || ini >= st.size) { res.writeHead(416, { 'Content-Range': `bytes */${st.size}` }); return res.end(); }
+            codigo = 206; cab['Content-Range'] = `bytes ${ini}-${fim}/${st.size}`;
+        }
+        cab['Content-Length'] = st.size ? fim - ini + 1 : 0;
+        res.writeHead(codigo, cab);
+        if (req.method === 'HEAD' || !st.size) return res.end();
+        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_ = criarHttp();
+            http_.on('error', reject);
+            http_.listen(pedida, modoRede ? '0.0.0.0' : '127.0.0.1', () => {
+                porta = http_.address().port;
+                try {
+                    fs.mkdirSync(base, { recursive: true });
+                    fs.writeFileSync(arquivoInfo, JSON.stringify({ porta, token, pid: process.pid, rede: modoRede }), { mode: 0o600 });
+                    fs.chmodSync(arquivoInfo, 0o600);
+                } catch { /* sem gravar, o cliente ainda recebe porta e token pelo retorno */ }
+                resolve({ porta, token });
+            });
+        });
+    }
+
+    /* 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();
+        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(); });
+    }
+
+    return { stdio, ws, fechar, tratar, metodos: Object.keys(metodos), token, arquivoInfo, pastaThreads, opcoesPiloto };
+}
+
+module.exports = { criarServidor };