primocode 9.8.0-beta.0 → 9.8.0-beta.10

package/bin/primocode.js

@@ -21,6 +21,7 @@ const api = require('../lib/api');
 const tools = require('../lib/tools');
 const cfg = require('../lib/config');
 const nomeProjeto = require('../lib/nome-projeto');
+const provedorLocal = require('../lib/local/provedor');
 const { runAct, interromper, ehTetoDeToken, ehTransitorio, esperaDoErro } = require('../lib/act');
 const fala = require('../lib/fala');
 const boasVindas = require('../lib/boas-vindas');
@@ -30,13 +31,29 @@ const effort = require('../lib/effort');
 const memoria = require('../lib/memoria-conversa');
 const registro = require('../lib/registro');
 const permissao = require('../lib/permissao');
+const perigo = require('../lib/perigo');
 const skills = require('../lib/skills');
+const checkpoint = require('../lib/checkpoint');
+const comandosLib = require('../lib/comandos');
 const marketplace = require('../lib/marketplace');
 const vozModo = require('../lib/voz');
 const appLib = require('../lib/app');
 const conta = require('../lib/conta');
 const nuvem = require('../lib/nuvem');
 const compat = require('../lib/compatibilidade');
+const mencoesLib = require('../lib/mencoes');
+const extra = require('../lib/comandos-extra');
+const offline = require('../lib/offline');
+
+/* O /custo: toda conversa com o modelo passa pelo lib/api.js, e o contador
+   embrulha as funções dele uma vez, aqui. Quem atende é o provedor do /api
+   quando há um, senão o servidor — é por eles que o /custo separa. */
+const contadorDaSessao = extra.novoContador();
+extra.instalarContador(api, contadorDaSessao, () => {
+    const p = provedorLocal.atual();
+    return p ? p.nome : 'Servidor PrimoCode';
+});
+const tempos = require('../lib/tempos');
 
 // Rede de segurança de último recurso: sem isto, uma exceção fora de um
 // try/catch (ex.: dentro de um callback de socket, como o parser de SSE) não
@@ -91,27 +108,90 @@ const state = {
 // existe para a frente em vez de subir outro servidor ao lado.
 let janelaAberta = null;
 
+/* O que o /rc, o /ide e o `primo --app` passam ao lib/app.js. Uma função
+   só porque os três sobem a MESMA janela: se cada um montasse a sua, o /ide
+   aberto depois do /rc acharia um servidor sem a pasta do projeto — e o
+   painel da prévia nasceria vazio. */
+function opcoesDaJanela(extra) {
+    return Object.assign({
+        versao: VERSION,
+        enviar: (t) => sendPrompt(t),
+        barra: (t) => handleSlash(t),
+        interromper,
+        estado: () => ({
+            pasta: state.workDir ? shortPath(state.workDir) : null,
+            projeto: state.currentProject,
+            modo: state.mode,
+            esforco: state.config.effort,
+            permissoes: perigo.normalizarModo(state.config.permissoes),
+            voz: !!vozEmEspera,
+            usuario: state.config.userName || null,
+            mascote: state.config.mascot || 'primo',
+            anexos: state.attachedFiles.map((f) => f.path),
+        }),
+        // Lida na hora, não guardada: o /dir e o /project trocam a pasta
+        // com a janela aberta, e o painel tem de acompanhar.
+        pastaProjeto: () => projectDir(),
+        /* As ações da janela passam pelos MESMOS caminhos dos comandos — o
+           /projetos, o /clear, o /permissoes, o /effort, o /attach — para a
+           janela e o terminal nunca discordarem sobre onde se está. */
+        entrarProjeto: (dir) => {
+            entrarNoProjeto(dir, 'projeto');
+            console.log(c.ok(`  Trabalhando em ${state.currentProject}`) + c.muted(`  (${shortPath(dir)})`));
+            refreshPrompt();
+        },
+        novoChat: () => handleSlash('/clear'),
+        mudarPermissoes: (m) => handleSlash('/permissoes ' + m),
+        mudarEsforco: (n) => aplicarEffort(n),
+        anexar: (f) => {
+            state.attachedFiles.push(f);
+            console.log(c.ok(`Anexado: ${f.path} (${tools.fmtBytes(f.content.length)})`) + c.muted('  pela janela'));
+            refreshPrompt();
+        },
+        desanexar: (nome) => {
+            state.attachedFiles = nome ? state.attachedFiles.filter((f) => f.path !== nome) : [];
+            refreshPrompt();
+        },
+        voz: (ligar) => handleSlash(ligar ? '/voice' : '/voice parar'),
+        continuarConversa: (alvo) => abrirConversa(alvo),
+    }, extra || {});
+}
+
 const HELP = `
 ${c.bold('Comandos')}
   ${c.brand('/dir')} <caminho>      trabalha numa pasta que já existe (onde você quiser)
   ${c.brand('/project')}            lista projetos ou cria em ~/primocode: /project <nome>
+  ${c.brand('/projetos')} [n]       projetos do mais recente, com tamanho · /projetos 2 entra
+  ${c.brand('/novo')} <descrição>   começa um projeto NOVO do zero, em pasta própria
   ${c.brand('/mode')}               /mode primocode|chat|auto
   ${c.brand('/effort')}             esforço do agente — do rápido ao mais esperto
+  ${c.brand('/permissoes')}         quando ele pergunta antes de agir: auto|perguntar|livre
   ${c.brand('/compact')}            resume a conversa e devolve o contexto
-  ${c.brand('/attach')} <arquivo>   anexa arquivo ao próximo pedido
+  ${c.brand('/init')}               estuda o projeto e escreve o PRIMO.md
+  ${c.brand('/attach')} <arquivo>   anexa arquivo ao próximo pedido · ou @arquivo no pedido
   ${c.brand('/files')}              lista anexos   ${c.brand('/detach')} remove
   ${c.brand('/all')}                lista tudo que ele sabe fazer
+  ${c.brand('/desfazer')} [lista|N]  desfaz o que o último pedido (ou os N últimos) mudou
   ${c.brand('/tree')} [n]           árvore do projeto
   ${c.brand('/read')} <arquivo>     mostra um arquivo
   ${c.brand('/run')} <comando>      executa no shell do projeto
   ${c.brand('/open')} <arq|url>     abre no navegador
+  ${c.brand('/abrir')}              abre o projeto: o servidor de pé, ou a index.html
+  ${c.brand('/copiar')}             copia a última resposta
+  ${c.brand('/historico')} [termo]  procura nos seus pedidos antigos
   ${c.brand('/rc')}                 abre a janela do PrimoCode (chat, sem terminal)
+  ${c.brand('/ide')}                abre a janela com a prévia do site e os arquivos ao lado
   ${c.brand('/login')}              entra na sua conta · ${c.brand('/account')} mostra o plano
   ${c.brand('/chats')} [n]          suas conversas — as mesmas do app e do celular
   ${c.brand('/logout')}             desconecta este computador da conta
+  ${c.brand('/comandos')}           seus comandos (/revisar, /explicar…) · /comandos novo <nome>
   ${c.brand('/status')}             checa o servidor
+  ${c.brand('/offline')}            roda o servidor no seu computador (temporário) · /offline off volta
+  ${c.brand('/doctor')}             confere tudo (servidor, /api, Chrome, disco…) e diz como consertar
+  ${c.brand('/custo')}              tokens e pedidos desta sessão, por provedor
+  ${c.brand('/atalhos')}            as teclas que ajudam
   ${c.brand('/name')} <nome>        como o Primo te chama
-  ${c.brand('/mascot')} <estilo>    mascote: primo|fox|cat
+  ${c.brand('/mascot')} [nome|n]    galeria dos mascotes · /mascot reacoes on|off
   ${c.brand('/config')}             mostra suas preferências
   ${c.brand('/clear')}              limpa a conversa   ${c.brand('/cls')} limpa a tela
   ${c.brand('/uninstall')}          remove o PrimoCode
@@ -137,19 +217,28 @@ ${c.bold('Onde ele trabalha')}
 const SLASH_COMANDOS = [
     ['/help', 'todos os comandos'],
     ['/project', 'lista/cria projetos em ~/primocode'],
+    ['/projetos', 'projetos do mais recente, com tamanho · /projetos 2 entra'],
+    ['/novo', 'começa um projeto novo do zero: /novo site da padaria'],
     ['/dir', 'trabalhar numa pasta sua'],
     ['/mode', 'primocode | chat | auto'],
     ['/effort', 'esforço: low → ultracode (←/→ para ajustar)'],
+    ['/permissoes', 'auto | perguntar | livre — quando ele pede licença'],
     ['/compact', 'resume a conversa e devolve o contexto'],
+    ['/init', 'estuda o projeto e escreve o PRIMO.md (as instruções dele)'],
     ['/attach', 'anexa arquivo ao pedido'],
     ['/detach', 'remove os anexos'],
     ['/files', 'lista os anexos'],
     ['/all', 'tudo que ele sabe fazer'],
+    ['/desfazer', 'desfaz o que o último pedido mudou nos arquivos (lista · N)'],
     ['/tree', 'árvore do projeto'],
     ['/read', 'mostra um arquivo'],
     ['/run', 'roda um comando'],
     ['/open', 'abre no navegador'],
+    ['/abrir', 'abre o projeto atual: o servidor de pé, ou a index.html'],
+    ['/copiar', 'copia a última resposta'],
+    ['/historico', 'procura nos seus pedidos antigos: /historico login'],
     ['/rc', 'abre a janela do PrimoCode'],
+    ['/ide', 'abre a janela com a prévia do site e os arquivos ao lado'],
     ['/login', 'entra na sua conta Conecta Primo'],
     ['/account', 'sua conta, plano e computadores conectados'],
     ['/chats', 'suas conversas salvas, as mesmas do app e do celular'],
@@ -160,10 +249,16 @@ const SLASH_COMANDOS = [
     ['/skills', 'o que ele sabe fazer bem — ligue e desligue'],
     ['/marketplace', 'a tela das skills: navegue, ligue, crie'],
     ['/install-skill', 'instala uma skill de um arquivo'],
+    ['/comandos', 'seus comandos: um .md vira /nome · /comandos novo <nome>'],
+    ['/api', 'usa a SUA chave (Gemini, ChatGPT, Claude…) direto daqui, sem o limite do servidor'],
     ['/status', 'checa o servidor'],
+    ['/offline', 'roda o servidor aqui no seu computador, com as chaves do Render'],
+    ['/doctor', 'confere se está tudo certo e diz como consertar'],
+    ['/custo', 'tokens e pedidos desta sessão, por provedor'],
+    ['/atalhos', 'as teclas que ajudam'],
     ['/connectors', 'quem está atendendo os seus pedidos'],
     ['/name', 'como ele te chama'],
-    ['/mascot', 'primo | fox | cat'],
+    ['/mascot', 'galeria dos mascotes · escolha por nome ou número'],
     ['/config', 'suas preferências'],
     ['/clear', 'limpa a conversa'],
     ['/cls', 'limpa a tela'],
@@ -172,6 +267,69 @@ const SLASH_COMANDOS = [
     ['/exit', 'sair'],
 ];
 
+/* ── /api: a chave da própria pessoa ──────────────────────────────
+ *   "Fica batendo no limite. Coloca um /provider onde você seleciona se é
+ *    Gemini, ChatGPT etc., cola a key e ela roda local." (23/09/2026)
+ * Com provedor, o agente fala direto com a API da pessoa (lib/local/motor.js);
+ * sem, tudo segue pelo servidor como sempre. */
+async function comandoApi(rest) {
+    const P = provedorLocal.PROVEDORES;
+    const ids = Object.keys(P);
+    const arg = String(rest || '').trim();
+    const atual = provedorLocal.atual();
+
+    if (/^(off|desliga[r]?|servidor|nenhum|sair)$/i.test(arg)) {
+        provedorLocal.desligar();
+        console.log(c.ok('  De volta ao servidor do PrimoCode.') + c.muted('  (a chave foi apagada desta máquina)'));
+        return;
+    }
+    const trocaModelo = arg.match(/^(modelo|model)\s+(\S+)$/i);
+    if (trocaModelo) {
+        if (!atual) { console.log(c.warn('  Nenhum provedor configurado. Rode /api primeiro.')); return; }
+        provedorLocal.trocarModelo(trocaModelo[2]);
+        console.log(c.ok(`  ${atual.nome} · modelo ${trocaModelo[2]}`));
+        return;
+    }
+
+    const apelido = { claude: 'claude-code', gpt: 'chatgpt', openai: 'chatgpt' }[arg.toLowerCase()];
+    let id = apelido || ids.find((k) => k === arg.toLowerCase() || P[k].nome.toLowerCase().startsWith(arg.toLowerCase()) && arg);
+    if (!id) {
+        console.log('');
+        console.log('  ' + c.bold('Com qual IA você quer rodar?') + c.muted('  a sua chave ou a sua assinatura, sem o limite do servidor'));
+        if (atual) console.log('  ' + c.muted('agora: ') + c.white(atual.cli ? atual.nome : `${atual.nome} · ${atual.modelo} · chave ${provedorLocal.mascarar(atual.chave)}`));
+        ids.forEach((k, i) => console.log(`  ${c.brand(String(i + 1))}  ${c.white(P[k].nome.padEnd(24))}${c.dim(P[k].dica)}`));
+        console.log(`  ${c.brand('0')}  ${c.white('Servidor do PrimoCode'.padEnd(24))}${c.dim('sem chave, com o limite do plano')}`);
+        const escolha = String(await ask(`  ${c.brand('?')} Número: `)).trim();
+        if (escolha === '0') return comandoApi('off');
+        id = ids[Number(escolha) - 1];
+        if (!id) { console.log(c.muted('  Nada mudou.')); return; }
+    }
+
+    const p = P[id];
+    // Claude Code e Codex não pedem chave: basta a ferramenta estar instalada
+    // e logada. Quem pensa é ela; quem executa é o PrimoCode.
+    if (p.cli) {
+        if (!require('../lib/local/motor-cli').instalado(id)) {
+            console.log(c.warn(`  O ${p.nome} não está instalado nesta máquina.`) + c.muted(`  Veja ${p.onde}`));
+            return;
+        }
+        const salvo = provedorLocal.salvar({ provedor: id, modelo: p.modelos[0] });
+        console.log(c.ok(`  Pronto: ${salvo.nome}`) + c.muted('  · usa a sua assinatura, sem chave'));
+        console.log(c.dim(`  O ${p.nome} decide, o PrimoCode executa. /api off volta ao servidor`));
+        return;
+    }
+    console.log(c.muted(`  Pegue a chave em `) + c.white(p.onde));
+    const chave = String(await askSecret(`  ${c.brand('?')} Cole a chave do ${p.nome} (não aparece na tela): `)).trim();
+    if (!chave) { console.log(c.muted('  Nada mudou.')); return; }
+    const sp = new Spinner('conferindo a chave').start();
+    const r = await provedorLocal.conferir(id, chave);
+    sp.stop();
+    if (!r.ok) { console.log(c.warn(`  ${r.error}`)); return; }
+    const salvo = provedorLocal.salvar({ provedor: id, chave, modelo: r.modelo });
+    console.log(c.ok(`  Pronto: ${salvo.nome} · ${salvo.modelo}`) + c.muted(`  · chave ${provedorLocal.mascarar(chave)}`));
+    console.log(c.dim('  Agora os pedidos vão direto daqui, com a sua cota. /api modelo <nome> troca o modelo · /api off volta ao servidor'));
+}
+
 // ── /effort: o slider de esforço (estilo Claude Code) ──────────────────
 // Régua com os níveis, o marcador ▲ embaixo do escolhido, "Faster" à
 // esquerda e "Smarter" à direita. ←/→ move, Enter confirma, Esc cancela.
@@ -247,9 +405,34 @@ function aplicarEffort(nome) {
 // Enquanto o slider está no ar, o fantasma do autocompletar não desenha.
 let sliderAtivo = false;
 
+/* Os comandos da pessoa (lib/comandos.js), com o do projeto atual por cima.
+   A caixa de digitar pede a lista a cada tecla para desenhar o fantasma; um
+   cache de dois segundos poupa ler três pastas por letra digitada, e ainda
+   pega na hora um arquivo que a pessoa acabou de salvar. */
+let cacheComandos = { em: 0, dir: null, lista: [] };
+function comandosDaPessoa() {
+    const agora = Date.now();
+    if (agora - cacheComandos.em > 2000 || cacheComandos.dir !== state.workDir) {
+        let lista = [];
+        try { lista = comandosLib.carregar({ projectDir: state.workDir }); } catch { /* disco estranho não trava a caixa */ }
+        cacheComandos = { em: agora, dir: state.workDir, lista };
+    }
+    return cacheComandos.lista;
+}
+
+/* O menu e o fantasma enxergam os dois tipos. O embutido vem primeiro e,
+   com o mesmo nome, o da pessoa nem aparece: quem ganha é sempre o embutido. */
+function comandosDoMenu() {
+    const embutidos = new Set(SLASH_COMANDOS.map(([n]) => n));
+    const deles = comandosDaPessoa()
+        .filter((x) => !embutidos.has('/' + x.nome))
+        .map((x) => ['/' + x.nome, x.descricao || `seu comando (${x.origem})`]);
+    return SLASH_COMANDOS.concat(deles);
+}
+
 function mostrarMenuSlash() {
     console.log('');
-    for (const [nome, desc] of SLASH_COMANDOS) {
+    for (const [nome, desc] of comandosDoMenu()) {
         console.log(`  ${c.brand(ui.padRight(nome, 12))}${c.muted(desc)}`);
     }
     console.log(c.dim('\n  Tab completa · metade do comando já serve: /eff vira /effort'));
@@ -489,14 +672,18 @@ const RE_PROJETO_NOVO = /\b(novo projeto|projeto novo|outro projeto|do zero|come
 const RE_CRIAR_UM = /\b(crie|cria|criar|fa[cç]a|faz|fazer|monte|monta|montar|gere|gera|desenvolva|construa|programe|quero|preciso de)\s+(um|uma|outro|outra|novo|nova)\b/;
 const RE_REFERE_ATUAL = /\b(isso|isto|esse|essa|este|esta|nele|nela|dele|dela|no projeto|nesse|nessa|neste|nesta|continua|continue|edita|edite|muda|mude|melhora|melhore|adiciona|adicione|coloca|coloque|p[oõ]e|corrige|corrija|arruma|arrume|ajusta|ajuste)\b/;
 
+/* "crie uma nova seção", "cria um botão", "faz uma tela de login": é um
+   PEDAÇO do projeto em que se está, não outro projeto. */
+const RE_PEDACO = /\b(um|uma|outro|outra|novo|nova)\s+(nov[ao]\s+)?(secao|secoes|parte|botao|botoes|tela|aba|menu|rodape|cabecalho|formulario|fase|funcao|funcionalidade|campo|imagem|animacao|efeito|cor|fonte|pagina interna|area|bloco|card|modal|link)\b/;
+
 function pedeProjetoNovo(texto) {
     const t = semAcento(texto);
     if (RE_PROJETO_NOVO.test(t)) return true;
-    if (!RE_CRIAR_UM.test(t) || RE_REFERE_ATUAL.test(t)) return false;
+    if (!RE_CRIAR_UM.test(t) || RE_REFERE_ATUAL.test(t) || RE_PEDACO.test(t)) return false;
     // Mesmo assunto do projeto atual ("crie uma fase nova pro jogo de carro")
     // é continuação, não projeto novo.
-    const atual = new Set(cfg.slugify(state.currentProject || '').split('-').filter((x) => x.length > 2));
-    const pedido = cfg.slugify(deriveProjectName(texto)).split('-').filter((x) => x.length > 2);
+    const atual = new Set(cfg.tokensDoAssunto(state.currentProject || ''));
+    const pedido = cfg.tokensDoAssunto(deriveProjectName(texto));
     return !pedido.some((x) => atual.has(x));
 }
 
@@ -547,6 +734,8 @@ function ehSoEstudio(texto) {
 }
 
 function planWorkDir(userText) {
+    // O /novo já criou a pasta e entrou nela: nenhuma heurística decide outra.
+    if (state.projetoFixo) return { dir: state.workDir, pending: false, name: state.currentProject };
     const escolhida = ['/dir', 'detectada', 'projeto'].includes(state.workDirOrigem);
     // Pasta escolhida a dedo (/dir, ou dita no pedido) manda sempre. Projeto
     // em andamento manda também — a menos que o pedido abra outra coisa.
@@ -568,16 +757,17 @@ function planWorkDir(userText) {
    paralelo com o trabalho: a pasta só nasce na primeira escrita, e até lá a
    resposta já chegou. Só pergunta quando o pedido é de CRIAR algo — pedir
    para abrir o Chrome não gasta chamada com nome de pasta. */
+async function perguntarNome(texto) {
+    let resposta = '';
+    await api.requestChat(state.config.server, {
+        prompt: texto, history: [], model: state.config.model, token: state.config.token,
+    }, (evt) => { if (evt.delta) resposta += evt.delta; });
+    return resposta;
+}
+
 function batizarDepois(plan, userText) {
     if (!plan.pending || !(RE_CRIAR_UM.test(semAcento(userText)) || PEDIDO_DE_CODIGO.test(userText))) return;
-    const perguntar = async (texto) => {
-        let resposta = '';
-        await api.requestChat(state.config.server, {
-            prompt: texto, history: [], model: state.config.model, token: state.config.token,
-        }, (evt) => { if (evt.delta) resposta += evt.delta; });
-        return resposta;
-    };
-    nomeProjeto.escolher({ pedido: userText, nomes: cfg.listProjects(), perguntar })
+    plan.batizando = nomeProjeto.escolher({ pedido: userText, nomes: cfg.listProjects(), perguntar: perguntarNome })
         .then((nome) => { if (nome) plan.nomeEscolhido = nome; });
 }
 
@@ -661,8 +851,15 @@ function prepararPasta(userText) {
  * Enter sozinho é NÃO. O padrão de quem apertou Enter sem ler não pode ser
  * entregar o mouse e o teclado.
  */
-async function autorizarControle(oQueVaiFazer, { primeira } = {}) {
-    if (primeira) {
+async function autorizarControle(oQueVaiFazer, { primeira, tipo } = {}) {
+    /* O mesmo portão serve ao /permissoes (lib/perigo.js): a pergunta muda de
+       cabeçalho, as três respostas são as mesmas. */
+    if (tipo) {
+        console.log('');
+        console.log('  ' + c.warn('▸▸') + ' ' + c.bold(c.white(tipo === 'perigo'
+            ? 'Isto não tem volta. O Primo quer:'
+            : 'O Primo quer (você escolheu /permissoes perguntar):')));
+    } else if (primeira) {
         console.log('');
         console.log('  ' + c.warn('▸▸') + ' ' + c.bold(c.white('O Primo quer usar o seu computador.')));
         console.log('  ' + c.muted('Ele vai mexer no mouse e no teclado de verdade, no programa que'));
@@ -693,7 +890,15 @@ async function autorizarControle(oQueVaiFazer, { primeira } = {}) {
  * simplesmente travava. Abrir o /voice e PEDIR em voz para ele mexer no
  * computador já é a autorização — é o produto funcionando como o Jarvis. Fica
  * dito no terminal, a cada ação, o que ele fez; e fechar o PrimoCode esquece. */
-async function autorizarPorVoz(oQueVaiFazer, { primeira } = {}) {
+async function autorizarPorVoz(oQueVaiFazer, { primeira, tipo } = {}) {
+    /* Pedir em voz é autorizar o que foi pedido — mas não o que não tem volta.
+       Ninguém está lendo o terminal para ver um `rm -rf` passar: o perigoso
+       é recusado, e o agente conta em voz o que ficou por fazer. */
+    if (tipo === 'perigo') {
+        console.log('  ' + c.warn('▸▸ recusado no modo voz: ') + c.muted(oQueVaiFazer));
+        return 'nao';
+    }
+    if (tipo) return 'agora';
     if (primeira) {
         console.log('  ' + c.warn('▸▸') + ' ' + c.muted('Modo voz: o Primo vai usar o mouse e o teclado. Você vê o cursor dele na tela.'));
     }
@@ -870,9 +1075,23 @@ async function sendPrompt(userText) {
         return;
     }
 
+    // PRIMOCODE_TEMPOS=1: uma linha no fim com o custo de cada fase.
+    tempos.comecar();
+    try { await enviarPedido(userText); }
+    finally {
+        const linha = tempos.relatorio();
+        if (linha) console.log(c.dim(`  ⏱ ${linha}`));
+    }
+}
+
+async function enviarPedido(userText) {
     let prompt = userText;
-    if (state.attachedFiles.length) {
-        const parts = state.attachedFiles.map((f) => `Arquivo: ${f.path}\n\`\`\`\n${f.content}\n\`\`\``);
+    // "@index.html" no pedido é um /attach só deste pedido: vai junto dos
+    // anexos, mas não fica em state.attachedFiles para o próximo.
+    const citados = mencoesDoPedido(userText);
+    const anexos = [...state.attachedFiles, ...citados];
+    if (anexos.length) {
+        const parts = anexos.map((f) => `Arquivo: ${f.path}\n\`\`\`\n${f.content}\n\`\`\``);
         prompt = parts.join('\n\n') + '\n\n' + userText;
     }
 
@@ -902,15 +1121,22 @@ async function sendPrompt(userText) {
 
         // O resumo da rodada anterior é feito em segundo plano logo depois
         // dela; aqui só se espera ele terminar, para não sair com memória velha.
-        await esperarResumo();
-
+        //
         // O pedido passa por uma cabeça antes de virar trabalho: conserta o
         // que está torto, diz qual é o entregável e o que conta como pronto.
         // UMA chamada faz as duas coisas: arruma o pedido torto e, se fizer
         // sentido, divide em passos. Eram duas idas ao modelo por pedido, e
         // num plano limitado por REQUISIÇÕES (o grátis da Groq são 30 por
         // minuto) cada chamada extra custa tanto quanto token.
-        const passos = await dividirTarefa(prompt);
+        //
+        // As duas esperas correm JUNTAS. Uma não lê o que a outra escreve: o
+        // plano só olha o texto do pedido, e o resumo só a conversa de antes.
+        // Em fila, o pedido de duas fases pagava o resumo e DEPOIS o plano —
+        // duas idas ao modelo em série antes da primeira rodada.
+        const [, passos] = await Promise.all([
+            tempos.medir('espera do resumo', () => esperarResumo()),
+            tempos.medir('plano', () => dividirTarefa(prompt)),
+        ]);
 
         let r = null;
         let jaFeito = '';
@@ -919,6 +1145,10 @@ async function sendPrompt(userText) {
            interessa é o do pedido inteiro: quem pediu um vídeo não quer três
            balanços, quer saber o que existe no disco quando ele terminar. */
         const livro = registro.novo();
+        // Um checkpoint por PEDIDO (não por passo): é o que o /desfazer volta.
+        // Com a pasta: a foto do projeto inteiro sai AGORA, antes de qualquer
+        // tool — é ela que dá volta ao `rm`/`mv` que o run_shell fizer.
+        checkpoint.iniciar(userText, projectDir());
         for (let i = 0; i < passos.length; i++) {
             if (i > 0) console.log(c.dim(`  ⎿ ${passos[i].titulo}`));
             // Só fato de passo CONCLUÍDO entra aqui. Num pedido real o passo de
@@ -948,8 +1178,11 @@ async function sendPrompt(userText) {
                 ensureWorkDir: plan.pending ? () => createPendingProject(plan) : null,
                 // O portão do computador: quem pergunta é o terminal, quem
                 // lembra da resposta é a sessão.
-                autorizar: autorizarControle,
+                // No pedido único (`primo "…"`) não há ninguém para responder:
+                // sem `autorizar`, o que pede licença é recusado (lib/perigo.js).
+                autorizar: state.semTerminal ? undefined : autorizarControle,
                 controle: state.controle,
+                permissoes: state.config.permissoes,
                 // Pedido de mexer no computador leva a dica que libera as
                 // ferramentas desktop_* no servidor (ver DICA_COMPUTADOR).
                 instrucao: i === 0 && querComputador(userText) ? vozModo.DICA_COMPUTADOR : '',
@@ -993,12 +1226,19 @@ async function sendPrompt(userText) {
                 : '';
             if (r.parado) break;   // Esc Esc no meio do plano para o plano inteiro
         }
+        checkpoint.encerrar();
 
         /* O balanço, depois da resposta. Depois, e não antes, de propósito: o
            que a pessoa quer ler primeiro é o que ele TEM A DIZER; a lista de
            arquivos é a conferência, e conferência se lê por último. */
         const balanco = registro.resumo(livro, { colunas: process.stdout.columns || 80 });
         if (balanco) console.log(balanco);
+        // O rostinho do mascote, por último e numa linha só. O humor sai do
+        // que aconteceu, não de adivinhar pelo texto da resposta.
+        if (state.config.reacoes !== false && r) {
+            const humor = r.parado ? 'parado' : r.concluiu === false ? 'preocupado' : 'feliz';
+            console.log(ui.reacao(state.config.mascot, humor));
+        }
         state.history.push({ role: 'user', content: userText });
         state.history.push({ role: 'assistant', content: r.assistantMessage.content });
         resumirDepois();
@@ -1009,8 +1249,8 @@ async function sendPrompt(userText) {
         state.gravador.turno(userText, r.assistantMessage.content,
             { modo: 'primocode', projeto: state.currentProject || null });
     } else {
-        await esperarResumo();
-        await runChat(prompt, userText);
+        await tempos.medir('espera do resumo', () => esperarResumo());
+        await tempos.medir('chat', () => runChat(prompt, userText));
     }
 
     state.attachedFiles = [];
@@ -1186,6 +1426,31 @@ async function esperarResumo(tetoMs = 15000) {
 /* A linha que vai junto do resumo: em que projeto se está. É o que faz
    "continua o jogo" e "muda a cor" caírem no mesmo projeto em vez de inventar
    outro. */
+function mencoesDoPedido(userText) {
+    const { arquivos, ignorados } = mencoesLib.mencoes(userText, projectDir());
+    const lidos = [];
+    for (const a of arquivos) {
+        try {
+            lidos.push({ path: a.rel, content: fs.readFileSync(a.abs, 'utf-8') });
+            console.log(c.dim(`  ⎿ anexado: ${a.rel} (${tools.fmtBytes(a.bytes)})`));
+        } catch { console.log(c.dim(`  ⎿ não consegui ler: ${a.rel}`)); }
+    }
+    for (const i of ignorados) console.log(c.dim(`  ⎿ não anexei ${i.rel}: ${i.motivo}`));
+    return lidos;
+}
+
+/* O pedido do /init. Passa pelo MESMO caminho de um pedido digitado
+   (sendPrompt → runAct), então usa as ferramentas e o provedor de agora — um
+   /init que falasse direto com o modelo não enxergaria os arquivos. */
+const PEDIDO_INIT = 'Estude este projeto (a pasta atual) e escreva um arquivo PRIMO.md na raiz dela. '
+    + 'Primeiro olhe de verdade: liste os arquivos, leia o README, o package.json (ou o equivalente) e os arquivos principais. '
+    + 'Depois escreva o PRIMO.md em português, curto (menos de 60 linhas), com estas seções: '
+    + 'o que é o projeto (2 ou 3 frases); como rodar (os comandos exatos que você viu, de instalar, rodar e testar); '
+    + 'a stack (linguagem, frameworks, banco); as convenções que o código segue (nomes, estilo, onde ficam os testes); '
+    + 'e onde está cada coisa (as pastas e arquivos que importam, uma linha cada). '
+    + 'Só escreva o que você conferiu nos arquivos — nada de inventar comando ou dependência. '
+    + 'Esse arquivo vai ser lido no começo de todo pedido neste projeto, então cada linha precisa valer o espaço.';
+
 function contextoDoProjeto() {
     if (!state.currentProject) return '';
     return `Projeto atual: ${state.currentProject} (pasta ${shortPath(projectDir())}). `
@@ -1193,6 +1458,14 @@ function contextoDoProjeto() {
         + 'trabalhe nos arquivos que já existem lá, não crie outro projeto.';
 }
 
+/* O chat não passa pelo runAct, e é no runAct (buildMemoryContext) que as
+   instruções do projeto entram. Sem isto o PRIMO.md valeria para o agente e
+   seria ignorado quando o modo auto manda o pedido para a conversa. */
+function comInstrucoes(history) {
+    const texto = mencoesLib.instrucoesDoProjeto(state.currentProject || state.workDir ? projectDir() : null);
+    return texto ? [{ role: 'system', content: texto }, ...history] : history;
+}
+
 // O chat também precisa parar no Esc Esc. Sem isto o texto continuava saindo
 // na tela depois de o usuário ter mandado parar.
 let chatEmVoo = null;
@@ -1219,7 +1492,7 @@ async function runChat(promptForModel, userTextForMemory) {
         try {
             await api.requestChat(state.config.server, {
                 prompt: promptForModel,
-                history: memoria.paraEnviar(state.memoria, state.history, contextoDoProjeto()),
+                history: comInstrucoes(memoria.paraEnviar(state.memoria, state.history, contextoDoProjeto())),
                 model: state.config.model,
                 token: state.config.token,
                 sinal: chatEmVoo.signal,
@@ -1339,13 +1612,59 @@ const RENOMEADOS = {
     conta: 'account',
     sair: 'exit',        // sair é SAIR; desconectar a conta é /logout
     // o histórico
-    conversas: 'chats', historico: 'chats', histórico: 'chats',
+    // /historico deixou de ser apelido do /chats: agora procura nos pedidos
+    // guardados nesta máquina (lib/comandos-extra.js). /chats segue sendo a
+    // conversa inteira, da conta.
+    conversas: 'chats',
     // o resto
     pasta: 'dir',
     esforco: 'effort', esforço: 'effort',
     tudo: 'all', capacidades: 'all',
 };
 
+/* Abrir uma conversa salva e seguir dela. Uma função só, para o /chats n e o
+   `primo -c` carregarem a conversa do MESMO jeito: dois caminhos divergiriam
+   no primeiro detalhe (a memória, o gravador) e um deles gravaria errado. */
+async function abrirConversa(alvo) {
+    const sp = new Spinner('abrindo').start();
+    const conv = await nuvem.lerConversa(alvo.id);
+    sp.stop();
+    if (!conv.ok) return conv;
+    // A memória entra ZERADA: o resumo antigo não veio junto, e um
+    // resumo de outra conversa colado aqui faria o modelo responder
+    // sobre coisa que não foi dita nesta.
+    state.history = conv.mensagens.map((m) => ({
+        role: m.papel, content: m.texto,
+    }));
+    state.memoria = memoria.nova();
+    state.gravador.retomar(alvo.id, alvo.titulo, conv.mensagens.length);
+    return conv;
+}
+
+/* `primo --continue` / `primo -c`: volta na última conversa, sem passar pelo
+   /chats. A lista do servidor já vem da mais recente para a mais antiga, então
+   a última é a primeira. Sem conta ou sem conversa, começa do zero e diz. */
+async function continuarUltima() {
+    if (!conta.atual()) {
+        console.log(c.dim('  ⎿ sem conta conectada, não há conversa para continuar — começando do zero'));
+        return false;
+    }
+    const l = await nuvem.listarConversas({ limite: 1 });
+    const alvo = l.ok && l.conversas[0];
+    if (!alvo) {
+        console.log(c.dim('  ⎿ nenhuma conversa salva ainda — começando do zero'));
+        return false;
+    }
+    const conv = await abrirConversa(alvo);
+    if (!conv.ok) {
+        console.log(c.dim(`  ⎿ não consegui abrir a última conversa (${conv.error}) — começando do zero`));
+        return false;
+    }
+    const quando = alvo.atualizada ? new Date(alvo.atualizada).toLocaleString('pt-BR') : 'data desconhecida';
+    console.log(c.dim(`  ⎿ continuando: ${alvo.titulo.slice(0, 60)} (${quando})`));
+    return true;
+}
+
 async function handleSlash(text) {
     const [cmd] = text.trim().slice(1).split(/\s+/);
     const rest = text.trim().slice(1 + cmd.length).trim();
@@ -1360,16 +1679,33 @@ async function handleSlash(text) {
     switch (nome) {
         case 'help': console.log(HELP); break;
 
-        case 'project': {
-            if (!rest) {
-                const projects = cfg.listProjects();
-                if (!projects.length) { console.log(c.muted('  Nenhum projeto ainda. Peça algo e eu crio o primeiro.')); break; }
-                console.log('');
-                for (const p of projects) {
-                    const mark = p === state.currentProject ? c.brand(' ●') : '  ';
-                    console.log(`${mark} ${p === state.currentProject ? c.brand(p) : c.white(p)}`);
+        /* /projetos e /project sem nome são a MESMA lista: antes o /project só
+           listava os nomes, em ordem alfabética, e quem procurava "o de ontem"
+           tinha de abrir pasta por pasta. Agora vem do mais recente, com
+           quando mexeu e o tamanho, e um número para entrar. */
+        case 'projetos': case 'project': {
+            const lista = extra.listarProjetos(cfg.ROOT_DIR);
+            const numero = /^\d+$/.test(rest) ? Number(rest) : 0;
+            if (!rest || (numero && nome === 'projetos') || (numero && numero <= lista.length)) {
+                if (!lista.length) { console.log(c.muted('  Nenhum projeto ainda. Peça algo e eu crio o primeiro.')); break; }
+                if (numero) {
+                    const alvo = lista[numero - 1];
+                    if (!alvo) { console.log(c.err(`  Não há projeto ${numero}. São ${lista.length}.`)); break; }
+                    entrarNoProjeto(alvo.dir, 'projeto');
+                    console.log(c.ok(`  Trabalhando em ${alvo.nome}`) + c.muted(`  (${shortPath(alvo.dir)})`));
+                    refreshPrompt();
+                    break;
                 }
-                console.log(c.muted(`\n  ${cfg.ROOT_DIR}`));
+                console.log('');
+                const largura = Math.min(34, Math.max(...lista.map((x) => x.nome.length)));
+                lista.forEach((x, i) => {
+                    const aqui = x.nome === state.currentProject;
+                    const nomeCol = ui.padRight(ui.truncate(aqui ? c.brand(x.nome) : c.white(x.nome), largura), largura);
+                    console.log(`  ${aqui ? c.brand('●') : ' '} ${c.dim(String(i + 1).padStart(2))}  ${nomeCol}  `
+                        + c.muted(ui.padRight(extra.quandoFoi(x.modificado), 11))
+                        + c.dim(`${extra.fmtTamanho(x.bytes)}${x.cortado ? '+' : ''} · ${x.arquivos} arq.`));
+                });
+                console.log(c.dim(`\n  ${shortPath(cfg.ROOT_DIR)} · /projetos 1 entra no primeiro · /novo <descrição> começa outro`));
                 break;
             }
             const dir = cfg.createProjectDir(rest);
@@ -1431,6 +1767,38 @@ async function handleSlash(text) {
             break;
         }
 
+        /* Quando ele pergunta antes de agir. Os três modos e o porquê de cada
+           um estão em lib/perigo.js. */
+        case 'permissoes':
+        case 'permissions': {
+            const DIZ = {
+                auto: 'roda tudo, mas pergunta antes do que não tem volta (apagar fora do projeto, push --force, sudo…)',
+                perguntar: 'pergunta antes de todo comando e de toda escrita de arquivo',
+                livre: 'nunca pergunta — nem antes do que não tem volta',
+            };
+            const atual = perigo.normalizarModo(state.config.permissoes);
+            if (!rest) {
+                console.log(c.muted('  Agora: ') + c.brand(atual) + c.muted(' — ' + DIZ[atual]));
+                for (const m of perigo.MODOS) console.log(`  ${m === atual ? c.brand('● ' + m) : c.muted('○ ' + m)}  ${c.dim(DIZ[m])}`);
+                console.log(c.dim('  Use /permissoes auto|perguntar|livre'));
+                break;
+            }
+            const pedido = rest.toLowerCase();
+            if (!perigo.MODOS.includes(perigo.normalizarModo(pedido)) || (perigo.normalizarModo(pedido) === 'auto' && pedido !== 'auto')) {
+                console.log(c.err('Uso: /permissoes auto|perguntar|livre'));
+                break;
+            }
+            const m = perigo.normalizarModo(pedido);
+            state.config.permissoes = m;
+            cfg.saveConfig({ permissoes: m });
+            console.log(c.ok(`  Permissões: ${m}`) + c.muted(' — ' + DIZ[m]));
+            if (m === 'livre') {
+                console.log('  ' + c.warn('▸▸ Atenção: ele vai apagar, forçar push e usar sudo sem te perguntar.'));
+                console.log('  ' + c.warn('   O que der errado pode não ter volta. /permissoes auto desfaz.'));
+            }
+            break;
+        }
+
         case 'mode': {
             const m = rest.toLowerCase();
             if (['primocode', 'chat', 'auto'].includes(m)) {
@@ -1491,6 +1859,20 @@ async function handleSlash(text) {
             break;
         }
 
+        case 'init': {
+            const alvo = path.join(projectDir(), 'PRIMO.md');
+            if (fs.existsSync(alvo) && !(await confirm(`Já existe um PRIMO.md em ${shortPath(projectDir())}. Escrever outro por cima?`))) {
+                console.log(c.muted('  Deixei o PRIMO.md como estava.'));
+                break;
+            }
+            // Escrever arquivo pede o agente: no modo chat (ou num auto que
+            // achasse que é conversa) o /init só responderia um texto.
+            const modoAntes = state.mode;
+            state.mode = 'primocode';
+            try { await sendPrompt(PEDIDO_INIT); } finally { state.mode = modoAntes; }
+            break;
+        }
+
         case 'detach': state.attachedFiles = []; console.log(c.ok('Anexos removidos.')); refreshPrompt(); break;
 
         case 'files':
@@ -1516,6 +1898,41 @@ async function handleSlash(text) {
             break;
         }
 
+        /* ── /desfazer ────────────────────────────────────────────────
+         * Quem não sabe git não tem como voltar uma edição ruim. Aqui volta:
+         * cada pedido tirou uma foto do projeto (com git) ou guardou o
+         * original dos arquivos que mexeu (sem git). */
+        case 'desfazer': case 'undo': case 'rewind': {
+            const cps = checkpoint.lista(projectDir());
+            if (!cps.length) { console.log(c.muted('  Nada para desfazer nesta pasta.')); break; }
+            const quando = (cp) => new Date(cp.quando).toLocaleString('pt-BR', { dateStyle: 'short', timeStyle: 'short' });
+            if (/^(lista|list|ls)$/i.test(rest)) {
+                cps.forEach((cp, i) => console.log(`  ${c.brand(String(i + 1).padStart(2))}  ${c.dim(quando(cp))}  `
+                    + `${c.white(cp.pedido.slice(0, 50) + (cp.pedido.length > 50 ? '…' : ''))}  `
+                    + c.muted(`${cp.mudou.length} ${cp.mudou.length === 1 ? 'arquivo mudou' : 'arquivos mudaram'}`)));
+                console.log(c.muted('\n  /desfazer N volta os N últimos pedidos.'));
+                if (checkpoint.modo(projectDir()) === 'arquivo') {
+                    console.log(c.muted('  Sem git aqui: só volta o que o agente escreveu com as ferramentas de arquivo (não o que um comando apagou).'));
+                }
+                break;
+            }
+            const n = rest ? parseInt(rest, 10) : 1;
+            if (!(n >= 1)) { console.log(c.err('Uso: /desfazer · /desfazer lista · /desfazer N')); break; }
+            const alvo = cps.slice(0, n);
+            console.log(c.muted(`\n  Volta ${alvo.length === 1 ? 'o último pedido' : `os ${alvo.length} últimos pedidos`}:`));
+            for (const cp of alvo) console.log(`  ${c.dim(quando(cp))}  ${c.white(cp.pedido.slice(0, 60))}`);
+            const previa = checkpoint.previa(projectDir(), n);
+            if (!previa.length) console.log(c.muted('    (o disco já está como estava antes)'));
+            for (const a of previa.slice(0, 40)) console.log(c.muted(`    ${a.acao}  `) + shortPath(a.caminho));
+            if (previa.length > 40) console.log(c.muted(`    … e mais ${previa.length - 40}`));
+            if (!(await confirm('Desfazer?'))) { console.log(c.muted('Cancelado.')); break; }
+            for (const f of checkpoint.desfazer(projectDir(), n)) {
+                const rotulo = f.acao === 'falhou' ? c.err(`  falhou: ${f.erro}  `) : c.ok(`  ${f.acao}  `);
+                console.log(rotulo + shortPath(f.caminho));
+            }
+            break;
+        }
+
         case 'tree': console.log(tools.treeDir(projectDir(), parseInt(rest, 10) || 2)); break;
 
         case 'read': {
@@ -1538,8 +1955,57 @@ async function handleSlash(text) {
             break;
         }
 
-        case 'open': {
-            if (!rest) { console.log(c.err('Uso: /open <arquivo|url>')); break; }
+        /* /novo: projeto novo por ORDEM da pessoa. Sem ele, "crie um site de
+           receitas" pode cair dentro de "site-receitas-velho" porque o nome
+           parece (findSimilarProject) — e quem quer começar do zero não tem
+           como dizer isso. Aqui a pasta nasce antes, com nome que não colide,
+           e o pedido roda preso nela. */
+        case 'novo': case 'new': {
+            if (!rest) { console.log(c.err('Uso: /novo <o que você quer criar>') + c.dim('  ex.: /novo site da padaria')); break; }
+            const nomes = cfg.listProjects();
+            const sp = new Spinner('escolhendo o nome da pasta').start();
+            const sugerido = await nomeProjeto.escolher({ pedido: rest, nomes, perguntar: perguntarNome }).catch(() => null);
+            sp.stop();
+            const nomeNovo = extra.nomeDoNovo({
+                descricao: rest, nomes, sugerido, derivar: deriveProjectName,
+                slugify: cfg.slugify, semColisao: nomeProjeto.semColisao,
+            });
+            const dir = cfg.createProjectDir(nomeNovo);
+            entrarNoProjeto(dir, 'projeto');
+            // Conversa nova junto: o que se falou do projeto anterior puxaria o
+            // agente de volta para ele.
+            state.history = []; state.memoria = memoria.nova(); state.gravador.zerar();
+            console.log(c.ok(`  Projeto novo: ${state.currentProject}`) + c.muted(`  (${shortPath(dir)})`));
+            refreshPrompt();
+            const modoAntes = state.mode;
+            state.mode = 'primocode';
+            state.projetoFixo = true;
+            try { await sendPrompt(extra.pedidoDoNovo(rest, state.currentProject)); }
+            finally { state.mode = modoAntes; state.projetoFixo = false; }
+            break;
+        }
+
+        /* /open sem nada (e /abrir) acha sozinho o que abrir: o servidor do
+           projeto de pé, ou a index.html. Antes pedia o caminho, e quem não
+           sabe que a página se chama index.html ficava parado aqui. */
+        case 'abrir': case 'open': {
+            if (!rest) {
+                const pastaAtual = projectDir();
+                if (path.resolve(pastaAtual) === path.resolve(cfg.ROOT_DIR)) {
+                    console.log(c.muted('  Nenhum projeto aberto.') + c.dim('  /projetos para escolher um'));
+                    break;
+                }
+                const alvo = await extra.acharAlvoAbrir(pastaAtual);
+                if (!alvo) {
+                    console.log(c.muted(`  Não achei página nem servidor em ${shortPath(pastaAtual)}.`));
+                    console.log(c.dim('  Peça "roda o projeto" ao Primo, ou /open <arquivo>.'));
+                    break;
+                }
+                const r = await tools.openInBrowser(alvo.url || alvo.caminho);
+                if (r && r.ok === false) { console.log(c.err(`  Não consegui abrir: ${r.error}`)); break; }
+                console.log(c.ok(`  Aberto: ${alvo.url || shortPath(alvo.caminho)}`) + c.dim(`  (${alvo.porque})`));
+                break;
+            }
             const target = /^https?:\/\//i.test(rest) ? rest : path.resolve(projectDir(), rest);
             await tools.openInBrowser(target);
             console.log(c.ok(`Aberto: ${rest}`));
@@ -1554,32 +2020,47 @@ async function handleSlash(text) {
             break;
         }
 
-        case 'mascot': {
-            const estilos = ['primo', 'fox', 'cat'];
-            const m = rest.toLowerCase();
-            if (!m) {
+        /* A galeria: todos lado a lado, número e nome em cima. Escolhe por
+           nome ou número — na hora, se há teclado; senão pelo /mascot <n>.
+           Num pipe não pergunta: a "resposta" seria o próximo comando. */
+        case 'mascot': case 'mascote': {
+            const reac = rest.match(/^(reac(?:oes|ões)?|rea[cç][aã]o|reactions?)\s*(on|off|liga[r]?|desliga[r]?|sim|n[aã]o)?$/i);
+            if (reac) {
+                const quer = reac[2] ? /^(on|liga|ligar|sim)$/i.test(reac[2]) : state.config.reacoes === false;
+                state.config.reacoes = quer;
+                cfg.saveConfig({ reacoes: quer });
+                console.log(c.ok(`  Reações do mascote: ${quer ? 'ligadas' : 'desligadas'}`)
+                    + (quer ? '  ' + ui.reacao(state.config.mascot, 'feliz').trim() : ''));
+                break;
+            }
+            let pedido = rest;
+            if (!pedido) {
                 console.log('');
-                for (const e of estilos) {
-                    console.log(`  ${e === state.config.mascot ? c.brand('● ' + e) : c.muted('○ ' + e)}`);
-                    ui.mascot(e).forEach((l) => console.log('   ' + l));
-                    console.log('');
+                console.log(ui.galeriaMascotes(state.config.mascot || 'primo', process.stdout.columns || 80));
+                if (!process.stdin.isTTY || state.semTerminal) {
+                    console.log(c.muted('  Escolha: /mascot <nome ou número>') + c.dim('  · /mascot reacoes off desliga o rostinho'));
+                    break;
                 }
-                console.log(c.muted('  Escolha: /mascot <estilo>'));
-                break;
+                pedido = String(await ask(`  ${c.brand('?')} Nome ou número ${c.dim('(Enter mantém)')}: `)).trim();
+                if (!pedido) { console.log(c.muted('  Nada mudou.')); break; }
             }
-            if (!estilos.includes(m)) { console.log(c.err(`Uso: /mascot ${estilos.join('|')}`)); break; }
+            const m = ui.resolverMascote(pedido);
+            if (!m) { console.log(c.err(`  Não conheço "${pedido}".`) + c.dim(`  São: ${ui.MASCOTES.join(', ')}`)); break; }
             state.config.mascot = m;
             cfg.saveConfig({ mascot: m });
+            const info = ui.mascoteInfo(m);
             console.log('');
-            ui.mascot(m).forEach((l) => console.log('  ' + l));
-            console.log(c.ok(`\nMascote: ${m}`));
+            const arte = ui.mascot(m);
+            arte.forEach((l, i) => console.log('  ' + l + (i === 0 ? '  ' + c.bold(c.white(info.nome))
+                : i === 1 ? '  ' + c.dim(`"${info.frase}"`) : '')));
+            console.log(c.ok(`\n  Mascote: ${m}`));
             break;
         }
 
         case 'config': {
             console.log('');
             console.log(`  ${c.muted('nome')}      ${c.white(state.config.userName || '(nenhum)')}`);
-            console.log(`  ${c.muted('mascote')}   ${c.white(state.config.mascot || 'primo')}`);
+            console.log(`  ${c.muted('mascote')}   ${c.white(state.config.mascot || 'primo')}${c.dim(state.config.reacoes === false ? '  · sem reações' : '  · com reações')}`);
             console.log(`  ${c.muted('esforço')}   ${c.white(state.config.effort)}${c.dim('  · /effort muda')}`);
             console.log(`  ${c.muted('modelo')}    ${c.white(state.config.model)}${c.dim('  (vem do esforço)')}`);
             console.log(`  ${c.muted('modo')}      ${c.white(state.mode)}`);
@@ -1618,6 +2099,78 @@ async function handleSlash(text) {
             state.gravador.zerar(); 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
+           ser o motivo de "não funciona" — e cada ✗ diz como consertar. */
+        case 'doctor': case 'medico': case 'médico': {
+            const sp = new Spinner('conferindo').start();
+            const linhas = await extra.diagnosticar({
+                saude: () => api.getHealth(state.config.server, state.config.token),
+                provedor: () => provedorLocal.atual(),
+                conferirChave: (id, chave) => provedorLocal.conferir(id, chave),
+                cliInstalado: (id) => require('../lib/local/motor-cli').instalado(id),
+                acharChrome: () => require('../lib/browser').findChrome(),
+                raiz: cfg.ROOT_DIR,
+                arquivoConfig: cfg.CONFIG_FILE,
+            });
+            sp.stop();
+            console.log('');
+            for (const l of linhas) {
+                const marca = l.ok === true ? c.ok('✓') : l.ok === false ? c.err('✗') : c.dim('·');
+                console.log(`  ${marca} ${ui.padRight(c.white(l.item), 18)}${ui.truncate(c.muted(l.detalhe || ''), Math.max(20, (process.stdout.columns || 80) - 23))}`);
+                if (l.conserto) console.log(`    ${c.dim('→ ' + l.conserto)}`);
+            }
+            const ruins = linhas.filter((l) => l.ok === false).length;
+            console.log(ruins ? c.warn(`\n  ${ruins} ${ruins === 1 ? 'coisa para arrumar' : 'coisas para arrumar'}.`) : c.ok('\n  Tudo certo.'));
+            break;
+        }
+
+        case 'custo': case 'cost': case 'tokens': {
+            const { linhas, total } = extra.resumoCusto(contadorDaSessao);
+            if (!linhas.length) { console.log(c.muted('  Nenhum pedido ao modelo nesta sessão ainda.')); break; }
+            console.log('');
+            for (const l of linhas) {
+                console.log(`  ${c.white(ui.padRight(l.provedor, 22))}${c.muted(ui.padRight(l.pedidos + (l.pedidos === 1 ? ' pedido' : ' pedidos'), 12))}`
+                    + `${c.dim('enviou ')}${c.white(extra.fmtNumero(l.enviados))}${c.dim(' · recebeu ')}${c.white(extra.fmtNumero(l.recebidos))}${c.dim(' tokens' + (l.exato ? '' : ' (estimado)'))}`);
+            }
+            if (linhas.length > 1) {
+                console.log(`  ${c.white(ui.padRight('Total', 22))}${c.muted(ui.padRight(total.pedidos + ' pedidos', 12))}`
+                    + `${c.dim('enviou ')}${c.white(extra.fmtNumero(total.enviados))}${c.dim(' · recebeu ')}${c.white(extra.fmtNumero(total.recebidos))}`);
+            }
+            if (linhas.some((l) => !l.exato)) console.log(c.dim('\n  Estimado = caracteres ÷ 4. Conta cada pedido inteiro, com a conversa que vai junto.'));
+            break;
+        }
+
+        case 'copiar': case 'copy': {
+            const r = extra.copiar(state.lastResponse);
+            if (r.ok) console.log(c.ok('  Copiado.') + c.dim(`  ${state.lastResponse.length} caracteres · é só colar`));
+            else console.log(c.muted(`  Não copiei: ${r.error}.`));
+            break;
+        }
+
+        case 'historico': case 'histórico': {
+            const achados = extra.buscarHistorico(cfg.HISTORY_FILE, rest, 20);
+            if (!achados.length) {
+                console.log(c.muted(rest ? `  Nada com "${rest}" nos seus pedidos.` : '  Nenhum pedido guardado ainda.'));
+                console.log(c.dim('  /chats mostra as conversas inteiras da sua conta.'));
+                break;
+            }
+            console.log('');
+            const largura = Math.max(30, (process.stdout.columns || 80) - 34);
+            for (const e of achados) {
+                const quando = new Date(e.ts).toLocaleString('pt-BR', { dateStyle: 'short', timeStyle: 'short' });
+                console.log(`  ${c.dim(quando)}  ${c.muted(ui.padRight(ui.truncate(e.project || e.mode || '', 14), 14))} `
+                    + ui.truncate(c.white(String(e.prompt).replace(/\s+/g, ' ')), largura));
+            }
+            console.log(c.dim(`\n  ${achados.length === 20 ? 'Os 20 mais recentes' : achados.length + ' pedido(s)'}${rest ? ` com "${rest}"` : ''} · /historico <termo> filtra · /chats abre conversas`));
+            break;
+        }
+
+        case 'atalhos': case 'shortcuts': case 'teclas': {
+            console.log('');
+            for (const [tecla, faz] of extra.ATALHOS) console.log(`  ${c.brand(ui.padRight(tecla, 20))}${c.muted(faz)}`);
+            break;
+        }
+
         case 'status': {
             const sp = new Spinner('verificando').start();
             try {
@@ -1788,6 +2341,8 @@ async function handleSlash(text) {
                         return resposta;
                     }
                     const plan = prepararPasta(texto);
+                    // Pasta pendente (projeto que ainda vai nascer) é o ~/primocode: sem foto.
+                    checkpoint.iniciar(texto, plan.pending ? null : plan.dir);
                     const resultado = await runAct(texto, {
                         instrucao: vozModo.COMO_FALAR,
                         server: state.config.server,
@@ -1800,7 +2355,9 @@ async function handleSlash(text) {
                         ensureWorkDir: plan.pending ? () => createPendingProject(plan) : null,
                         autorizar: autorizarPorVoz,
                         controle: state.controle,
+                        permissoes: state.config.permissoes,
                     });
+                    checkpoint.encerrar();
                     const resposta = (resultado.assistantMessage && resultado.assistantMessage.content) || '';
                     // A conversa é a MESMA do terminal: sair do modo voz e
                     // continuar digitando não pode começar do zero.
@@ -1910,18 +2467,7 @@ async function handleSlash(text) {
             }
             const sp = new Spinner('abrindo a janela').start();
             try {
-                janelaAberta = await appLib.abrir({
-                    versao: VERSION,
-                    enviar: (t) => sendPrompt(t),
-                    barra: (t) => handleSlash(t),
-                    interromper,
-                    estado: () => ({
-                        pasta: state.workDir ? shortPath(state.workDir) : null,
-                        projeto: state.currentProject,
-                        modo: state.mode,
-                        esforco: state.config.effort,
-                    }),
-                });
+                janelaAberta = await appLib.abrir(opcoesDaJanela());
                 sp.stop();
                 const j = janelaAberta.janela || {};
                 console.log(c.ok('  Janela aberta.')
@@ -1945,6 +2491,37 @@ async function handleSlash(text) {
             break;
         }
 
+        /* O /ide virou a MESMA janela do /rc, abrindo com a prévia do site
+           à direita. O editor de código saiu ("remove a IDE ou deixa
+           idêntico ao Codex"): quem não programa precisa ver o site
+           nascendo, não de um editor para quebrar o que o agente fez. O
+           comando continua existindo para o dedo viciado não bater em nada. */
+        case 'ide': {
+            if (janelaAberta) {
+                await appLib.abrirJanela(janelaAberta.urlPainel || janelaAberta.url);
+                console.log(c.ok('  Janela com a prévia aberta.') + c.muted('  (no mesmo servidor que já estava de pé)'));
+                break;
+            }
+            const sp = new Spinner('abrindo a janela').start();
+            try {
+                janelaAberta = await appLib.abrir(opcoesDaJanela({ abrirEm: 'ide' }));
+                sp.stop();
+                const j = janelaAberta.janela || {};
+                console.log(c.ok('  Janela aberta, com a prévia do site ao lado.')
+                    + c.muted(j.modo === 'janela' ? `  (${j.navegador})`
+                        : j.modo === 'aba' ? '  (aba do navegador padrão)' : ''));
+                console.log(c.dim(`  ${janelaAberta.urlPainel}`));
+                if (j.modo === 'nenhum') {
+                    console.log(c.warn('  Não consegui abrir sozinho — copie o endereço acima no navegador.'));
+                }
+                console.log(c.muted(`  Pasta: ${shortPath(projectDir())} · o terminal continua funcionando, os dois mostram a mesma coisa.`));
+            } catch (e) {
+                sp.stop();
+                console.log(c.err(`  Não subiu: ${e.message}`));
+            }
+            break;
+        }
+
         /* A conta do Conecta Primo, sem navegador: e-mail e senha aqui
            mesmo. O login inteiro mora em lib/conta.js; aqui é a tela dele. */
         case 'login': {
@@ -2002,18 +2579,8 @@ async function handleSlash(text) {
             const n = Number(rest);
             const alvo = l.conversas[n - 1];
             if (!alvo) { console.log(c.err(`  Não achei a conversa ${rest}.`)); break; }
-            const sp2 = new Spinner('abrindo').start();
-            const conv = await nuvem.lerConversa(alvo.id);
-            sp2.stop();
+            const conv = await abrirConversa(alvo);
             if (!conv.ok) { console.log(c.err(`  ${conv.error}`)); break; }
-            // A memória entra ZERADA: o resumo antigo não veio junto, e um
-            // resumo de outra conversa colado aqui faria o modelo responder
-            // sobre coisa que não foi dita nesta.
-            state.history = conv.mensagens.map((m) => ({
-                role: m.papel, content: m.texto,
-            }));
-            state.memoria = memoria.nova();
-            state.gravador.retomar(alvo.id, alvo.titulo, conv.mensagens.length);
             console.log(c.ok(`  ${alvo.titulo}`)
                 + c.muted(`  · ${conv.mensagens.length} mensagens carregadas`));
             console.log(c.dim('  Pode continuar daqui — o que você disser volta pro app e pro celular.'));
@@ -2084,6 +2651,73 @@ async function handleSlash(text) {
          * Eles não somem calados. Quem tem o dedo viciado em `/claude` e
          * bate num "comando não existe" conclui que a atualização quebrou
          * alguma coisa — e não vai procurar no /help, vai desinstalar. */
+        case 'api': {
+            await comandoApi(rest);
+            break;
+        }
+
+        /* O servidor aqui, no computador da pessoa, até a sessão acabar
+           (lib/offline.js). "Enquanto não tenho acesso ao Railway, eu testo
+           com o projeto rodando localmente." (24/09/2026) */
+        case 'offline': case 'local': {
+            if (/^(off|sair|desligar|parar)$/i.test(rest)) {
+                if (!state.servidorAntes) { console.log(c.muted('  O /offline não está ligado.')); break; }
+                offline.desligar();
+                state.config.server = state.servidorAntes;
+                state.servidorAntes = null;
+                console.log(c.ok('  Voltei ao servidor de antes: ') + c.dim(state.config.server));
+                break;
+            }
+            if (state.servidorAntes) { console.log(c.muted('  Já está no servidor local: ') + c.dim(state.config.server) + c.muted(' · /offline off volta')); break; }
+            const chaves = offline.prepararEnv();
+            if (chaves.criado || !chaves.temChave) {
+                console.log(c.warn(`  ${chaves.criado ? 'Criei' : 'Falta chave em'} ${chaves.arquivo}`));
+                console.log(c.muted('  Cole nele as chaves do Render (primocode-server → Environment), uma por linha:'));
+                console.log(c.dim('  GROQ_API_KEY=…  OPENROUTER_API_KEY=…  GEMINI_API_KEY=…'));
+                console.log(c.muted('  Depois rode ') + c.brand('/offline') + c.muted(' de novo.'));
+                break;
+            }
+            const dir = offline.acharServidor({ pedido: rest });
+            const sp = new Spinner('subindo o servidor aqui').start();
+            const r = await offline.ligar({ dir, env: chaves.env });
+            sp.stop();
+            if (!r.ok) {
+                console.log(c.err('  ' + r.error));
+                if (r.comoResolver) console.log(c.dim('  → ' + r.comoResolver));
+                break;
+            }
+            state.servidorAntes = state.config.server;
+            state.config.server = r.url;
+            console.log(c.ok(`  Servidor ${r.versao || ''} ${r.reaproveitado ? 'que já estava de pé' : 'rodando aqui'}: `) + c.dim(r.url));
+            console.log(c.dim(`  ${dir || ''}${dir ? ' · ' : ''}chaves: ${chaves.nomes.join(', ')}${r.reaproveitado ? '' : ' · log em ' + offline.ARQUIVO_LOG}`));
+            if (provedorLocal.atual()) console.log(c.warn('  Atenção: o /api está ligado e fala direto com a IA. Para usar o servidor local, /api off.'));
+            console.log(c.muted('  Vale até fechar o PrimoCode. ') + c.brand('/offline off') + c.muted(' volta antes.'));
+            break;
+        }
+
+        /* Os comandos da pessoa: lista, e explica como fazer o dela. */
+        case 'comandos': {
+            const novo = rest.match(/^(novo|new|criar)\s+(\S+)$/i);
+            if (novo) {
+                const r = comandosLib.criar(novo[2]);
+                if (!r.ok) { console.log(c.err(`  ${r.error}`)); break; }
+                cacheComandos.em = 0;
+                console.log(c.ok(`  Criado: /${path.basename(r.arquivo, '.md')}`) + c.muted('  abra e escreva o pedido:'));
+                console.log('  ' + c.white(r.arquivo));
+                break;
+            }
+            const lista = comandosDaPessoa();
+            console.log(c.white('\n  Seus comandos'));
+            for (const x of lista) {
+                console.log(`  ${c.brand(ui.padRight('/' + x.nome, 14))}${c.dim(ui.padRight(x.origem, 11))}${c.muted(x.descricao)}`);
+            }
+            console.log(c.dim('\n  Um arquivo .md vira um comando: revisar.md é /revisar.'));
+            console.log(c.dim('  ~/.primocode/comandos/ vale em todo projeto · <projeto>/.primocode/comandos/ só naquele.'));
+            console.log(c.dim('  $ARGUMENTOS no texto recebe o que você digitar depois: /revisar o login.'));
+            console.log(c.dim('  /comandos novo <nome> cria um para você editar.'));
+            break;
+        }
+
         case 'claude': case 'gpt': case 'codex': case 'key': case 'keys': {
             console.log(c.muted('  Não existe mais provedor para configurar.'));
             console.log(c.muted('  A API já vem com o PrimoCode: entrou na conta, pode usar.'));
@@ -2095,7 +2729,18 @@ async function handleSlash(text) {
             // "/" sozinho abre o menu; um prefixo único autopreenche e executa
             // ("/eff" → /effort); prefixo ambíguo mostra as opções.
             if (!cmd) { mostrarMenuSlash(); break; }
-            const casam = SLASH_COMANDOS.map(([nome]) => nome.slice(1)).filter((n) => n.startsWith(cmd.toLowerCase()));
+            // Chegou aqui, não é embutido: o switch já atendeu todos eles.
+            // Por isso um /help.md da pessoa nunca troca o /help de verdade.
+            const proprio = comandosDaPessoa().find((x) => x.nome === nome);
+            if (proprio) {
+                console.log(c.dim(`  ⎿ /${proprio.nome} · ${proprio.origem}`));
+                // O MESMO caminho de um pedido digitado: modo, pasta, plano,
+                // tudo. Um atalho que pulasse o sendPrompt pularia junto o
+                // portão do plano e a escolha da pasta.
+                await sendPrompt(comandosLib.expandir(proprio, rest));
+                break;
+            }
+            const casam = comandosDoMenu().map(([nome]) => nome.slice(1)).filter((n) => n.startsWith(cmd.toLowerCase()));
             if (casam.length === 1) {
                 console.log(c.dim(`  → /${casam[0]}`));
                 await handleSlash('/' + casam[0] + (rest ? ' ' + rest : ''));
@@ -2104,7 +2749,7 @@ async function handleSlash(text) {
             if (casam.length > 1) {
                 console.log(c.muted(`  /${cmd}… pode ser:`));
                 for (const n of casam) {
-                    const [, desc] = SLASH_COMANDOS.find(([nome]) => nome === '/' + n);
+                    const [, desc] = comandosDoMenu().find(([nome]) => nome === '/' + n);
                     console.log(`    ${c.brand(ui.padRight('/' + n, 12))}${c.dim(desc)}`);
                 }
                 break;
@@ -2141,6 +2786,9 @@ function conferirServidor() {
     jaConferiu = true;
     const minimo = (pkg.primocode && pkg.primocode.servidorMinimo) || '';
     if (!minimo) return;
+    // Com a chave própria (/api), quem pensa não é o servidor: a versão dele
+    // não muda nada no que a pessoa pede.
+    if (provedorLocal.atual()) return;
     const servidor = state.config.server;
     Promise.resolve()
         .then(() => api.getHealth(servidor, state.config.token))
@@ -2174,7 +2822,11 @@ async function main() {
     // mesmo que uma refatoração.
     state.mode = ['primocode', 'chat', 'auto'].includes(state.config.mode) ? state.config.mode : 'auto';
 
-    const args = process.argv.slice(2);
+    // `-c` / `--continue` pode vir em qualquer posição e sai da lista: o
+    // resto (one-shot, -f) segue sendo lido do jeito de sempre.
+    const todos = process.argv.slice(2);
+    const continuar = todos.some((a) => a === '-c' || a === '--continue');
+    const args = todos.filter((a) => a !== '-c' && a !== '--continue');
 
     // Flags padrão de CLI — funcionam em qualquer máquina, úteis em scripts/CI.
     if (args[0] === '--version' || args[0] === '-v' || args[0] === '-V') {
@@ -2212,18 +2864,7 @@ async function main() {
             process.exit(r.ok ? 0 : 1);
         }
 
-        const janela = await appLib.abrir({
-            versao: VERSION,
-            enviar: (t) => sendPrompt(t),
-            barra: (t) => handleSlash(t),
-            interromper,
-            estado: () => ({
-                pasta: state.workDir ? shortPath(state.workDir) : null,
-                projeto: state.currentProject,
-                modo: state.mode,
-                esforco: state.config.effort,
-            }),
-        });
+        const janela = await appLib.abrir(opcoesDaJanela());
         janelaAberta = janela;
         console.log(c.brand(`  PrimoCode`) + c.muted(`  ${janela.url.split('?')[0]}`));
         // Sem readline não há nada segurando o laço de eventos além do
@@ -2234,33 +2875,31 @@ async function main() {
         return;
     }
 
+    /* `primo ide`: o terminal de sempre, com a janela (e a prévia) já aberta.
+       Só a palavra SOZINHA: `primo ide para gatos` continua sendo um pedido
+       ao agente (modo um-tiro), como sempre foi. */
+    const abrirIde = args.length === 1 && args[0].toLowerCase() === 'ide';
+
     // Modo one-shot: primocode "crie um jogo de carro"
-    if (args.length && !args[0].startsWith('-')) {
+    if (args.length && !args[0].startsWith('-') && !abrirIde) {
         const fileFlag = args.indexOf('-f');
         const words = fileFlag >= 0 ? args.slice(0, fileFlag) : args;
         const promptText = words.join(' ');
-        let fullPrompt = promptText;
 
         if (fileFlag >= 0 && args[fileFlag + 1]) {
             try {
                 const fc = fs.readFileSync(path.resolve(args[fileFlag + 1]), 'utf-8');
-                fullPrompt = `Arquivo: ${args[fileFlag + 1]}\n\`\`\`\n${fc}\n\`\`\`\n\n${promptText}`;
+                state.attachedFiles.push({ path: args[fileFlag + 1], content: fc });
             } catch { console.log(c.err(`Não consegui ler: ${args[fileFlag + 1]}`)); process.exit(1); }
         }
 
-        // Mesma função do modo interativo: detecta a pasta, adota projeto que já
-        // existe, e só então decide se há projeto novo pendente.
-        const plan = prepararPasta(promptText);
-        await runAct(fullPrompt, {
-            server: state.config.server,
-            model: state.config.model,
-            effort: state.config.effort,
-            token: state.config.token,
-            history: [],
-            projectDir: plan.dir,
-            projectName: plan.name || state.currentProject,
-            ensureWorkDir: plan.pending ? () => createPendingProject(plan) : null,
-        });
+        // Com -c, o pedido continua a última conversa em vez de chegar sozinho.
+        if (continuar) await continuarUltima();
+        /* O MESMO caminho do pedido digitado (sendPrompt). Este modo tinha um
+           runAct próprio, e por isso ficava sem tudo o que vive lá: o plano em
+           passos, a retomada automática, o @arquivo, o checkpoint do /desfazer. */
+        state.semTerminal = true;
+        await sendPrompt(promptText);
         process.exit(0);
     }
 
@@ -2272,7 +2911,7 @@ async function main() {
     }));
     rl = entrada.criar({
         status: barraDeStatus,
-        comandos: () => SLASH_COMANDOS,
+        comandos: comandosDoMenu,
         vazio: 'peça alguma coisa, ou / para os comandos',
     });
 
@@ -2354,7 +2993,13 @@ async function main() {
             try {
                 if (ehBash(text)) await rodarBash(text);
                 else if (isSlash(text)) await handleSlash(text);
-                else await sendPrompt(text);
+                else {
+                    // Com a janela aberta, o pedido digitado AQUI também vira
+                    // balão lá — senão a janela mostraria a resposta de uma
+                    // pergunta que ninguém fez.
+                    if (janelaAberta && janelaAberta.pedidoDoTerminal) janelaAberta.pedidoDoTerminal(text);
+                    await sendPrompt(text);
+                }
             } catch (e) {
                 fala.problema(e);
             }
@@ -2411,15 +3056,22 @@ async function main() {
         // o primocode-server, que tem a chave do provedor.
         state.liberado = !r || r.liberado !== false;
         state.motivoBloqueio = r && r.motivo;
-    }).catch(() => { state.liberado = true; }).then(() => {
-        // O que sobrou de adiantado não era resposta de nada: vira comando,
-        // na ordem em que foi digitado. Nada se perde, só esperou a vez.
-        segurando = false;
-        while (adiantadas.length) queue.push(adiantadas.shift());
-        if (queue.length) drain();
-        else if (!closed) rl.prompt();
-        conferirServidor();
-    });
+    }).catch(() => { state.liberado = true; })
+        // Depois da abertura, porque é nela que a pessoa entra na conta — e
+        // sem conta não há conversa para achar.
+        .then(() => (continuar ? continuarUltima().catch(() => false) : null))
+        .then(() => {
+            // O que sobrou de adiantado não era resposta de nada: vira comando,
+            // na ordem em que foi digitado. Nada se perde, só esperou a vez.
+            segurando = false;
+            // Depois da abertura (e do login dela): a janela sem conta abriria
+            // mandando pedidos que o servidor recusa.
+            if (abrirIde) queue.push('/ide');
+            while (adiantadas.length) queue.push(adiantadas.shift());
+            if (queue.length) drain();
+            else if (!closed) rl.prompt();
+            conferirServidor();
+        });
 }
 
 main().catch((e) => { console.error(c.err(e.message || e)); process.exit(1); });