primocode 9.8.0-beta.4 → 9.8.0-beta.6

package/bin/primocode.js

@@ -43,6 +43,16 @@ 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');
+
+/* 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';
+});
 
 // 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
@@ -97,10 +107,34 @@ const state = {
 // existe para a frente em vez de subir outro servidor ao lado.
 let janelaAberta = null;
 
+/* O que a janela do /rc, a IDE do /ide e o `primo --app` passam ao
+   lib/app.js. Uma função só porque os três sobem o MESMO servidor: se cada um
+   montasse o seu, o /ide aberto depois do /rc acharia um servidor sem a pasta
+   do projeto — e a IDE nasceria sem árvore. */
+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,
+        }),
+        // Lida na hora, não guardada: o /dir e o /project trocam a pasta
+        // com a IDE aberta, e ela tem de acompanhar.
+        pastaProjeto: () => projectDir(),
+    }, 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
@@ -114,14 +148,21 @@ ${c.bold('Comandos')}
   ${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 IDE: arquivos, editor, prévia do site e o chat
   ${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('/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
@@ -147,6 +188,8 @@ ${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)'],
@@ -162,7 +205,11 @@ const SLASH_COMANDOS = [
     ['/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 IDE: arquivos, editor, prévia e o chat, lado a 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'],
@@ -176,9 +223,12 @@ const SLASH_COMANDOS = [
     ['/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'],
+    ['/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'],
@@ -654,6 +704,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.
@@ -675,36 +727,27 @@ 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;
-    };
-    plan.batizando = 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; });
 }
 
-/* O kit de partida (lib/kits.js): pedido de landing numa pasta nova começa
-   de uma página pronta, e o agente só adapta. A pasta nasce AGORA, e não na
-   primeira escrita, porque o kit precisa estar lá antes de o agente ler. */
+/* A inspiração visual (lib/kits.js): pedido de landing leva a ficha da
+   direção que combina com o negócio. Nada é copiado para a pasta — o agente
+   escreve a página dele, inspirado, e não troca texto num molde. */
 async function prepararKit(plan, userText) {
     const kit = kits.escolher(userText, { provedor: provedorLocal.atual() });
     if (!kit) return '';
-    let dir = plan.dir;
-    if (plan.pending) {
-        await Promise.race([plan.batizando, new Promise((r) => setTimeout(r, 8000))]);
-        dir = createPendingProject(plan);
-        plan.pending = false;
-        plan.dir = dir;
-    }
-    if (!dir || path.resolve(dir) === path.resolve(cfg.ROOT_DIR)) return '';
-    const copiados = kits.aplicar(kit, dir);
-    if (!copiados.length) return '';
-    console.log(c.dim(`  ⎿ começando do kit de ${kit.nome} (${copiados.join(', ')}) — o agente só adapta`));
+    console.log(c.dim(`  ⎿ inspiração visual: ${kit.titulo}`));
     return kit.instrucao;
 }
 
@@ -1067,7 +1110,9 @@ async function sendPrompt(userText) {
            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.
-        checkpoint.iniciar(userText);
+        // 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
@@ -1153,6 +1198,12 @@ async function sendPrompt(userText) {
            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();
@@ -1526,7 +1577,10 @@ 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',
@@ -1590,16 +1644,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);
@@ -1794,25 +1865,31 @@ async function handleSlash(text) {
 
         /* ── /desfazer ────────────────────────────────────────────────
          * Quem não sabe git não tem como voltar uma edição ruim. Aqui volta:
-         * cada pedido guardou o original dos arquivos que mexeu. */
+         * 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.arquivos.length + ' arq.')}`));
+                    + `${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))}`);
-                for (const a of cp.arquivos) console.log(c.muted(`    ${a.existia ? 'volta ao original' : 'apaga (era novo)'}  `) + shortPath(a.caminho));
-            }
+            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}  `);
@@ -1843,8 +1920,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}`));
@@ -1859,32 +1985,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)}`);
@@ -1923,6 +2064,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 {
@@ -2093,7 +2306,8 @@ async function handleSlash(text) {
                         return resposta;
                     }
                     const plan = prepararPasta(texto);
-                    checkpoint.iniciar(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,
@@ -2108,6 +2322,7 @@ async function handleSlash(text) {
                         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.
@@ -2217,18 +2432,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.')
@@ -2252,6 +2456,37 @@ async function handleSlash(text) {
             break;
         }
 
+        /* A IDE: "um app ao invés de CLI, aí fica uma IDE e uma CLI".
+           Mora no MESMO servidor do /rc (lib/app.js + lib/ide.js): com a
+           janela do chat já aberta, o /ide só abre outra tela nele — mesma
+           chave, mesmo agente, a mesma conversa nas duas. */
+        case 'ide': {
+            if (janelaAberta && janelaAberta.urlIde) {
+                await appLib.abrirJanela(janelaAberta.urlIde);
+                console.log(c.ok('  IDE aberta.') + c.muted('  (no mesmo servidor da janela que já estava aberta)'));
+                console.log(c.dim(`  ${janelaAberta.urlIde}`));
+                break;
+            }
+            const sp = new Spinner('abrindo a IDE').start();
+            try {
+                janelaAberta = await appLib.abrir(opcoesDaJanela({ abrirEm: 'ide' }));
+                sp.stop();
+                const j = janelaAberta.janela || {};
+                console.log(c.ok('  IDE aberta.')
+                    + c.muted(j.modo === 'janela' ? `  (${j.navegador})`
+                        : j.modo === 'aba' ? '  (aba do navegador padrão)' : ''));
+                console.log(c.dim(`  ${janelaAberta.urlIde}`));
+                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': {
@@ -2555,18 +2790,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
@@ -2577,8 +2801,13 @@ async function main() {
         return;
     }
 
+    /* `primo ide`: o terminal de sempre, com a IDE já aberta ao lado.
+       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(' ');
@@ -2757,6 +2986,9 @@ async function main() {
             // 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 IDE 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();