primocode 8.34.0 → 8.35.0

package/app/index.html

@@ -40,7 +40,7 @@
     <div class="rotulo">Conversas</div>
     <div class="recentes" id="recentes">
       <div class="vazio-lista" id="listaVazia">
-        As conversas aparecem aqui quando você entra na sua conta com <code>/conectar</code>.
+        As conversas aparecem aqui quando você entra na sua conta com <code>/connect</code>.
       </div>
     </div>
 
@@ -69,7 +69,7 @@
         <p>Escreva do jeito que você falaria. Ele lê a pasta, escreve o código,
            roda o que precisar e conta o que fez.</p>
         <div class="sugestoes">
-          <button class="sugestao" data-manda="/tudo">o que ele sabe fazer</button>
+          <button class="sugestao" data-manda="/all">o que ele sabe fazer</button>
           <button class="sugestao" data-manda="/project">meus projetos</button>
           <button class="sugestao" data-manda="/effort">esforço</button>
           <button class="sugestao" data-manda="/help">comandos</button>

package/bin/primocode.js

@@ -82,31 +82,32 @@ let janelaAberta = null;
 
 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('/mode')}                 /mode primocode|chat|auto
-  ${c.brand('/effort')}               esforço do agente — do rápido ao mais esperto
-  ${c.brand('/attach')} <arquivo>     anexa arquivo ao próximo pedido
-  ${c.brand('/files')}                lista anexos   ${c.brand('/detach')} remove
-  ${c.brand('/tudo')}                 lista tudo que ele sabe fazer
-  ${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')} <arquivo|url>   abre no navegador
-  ${c.brand('/rc')}                   abre a janela do PrimoCode (chat, sem terminal)
-  ${c.brand('/claude')}               usa o Claude Code da SUA conta como motor (Opus)
-  ${c.brand('/gpt')}                  usa o GPT (Codex) da SUA conta como motor
-  ${c.brand('/chave')} <provedor>    sua própria chave de API (Claude, Codex)
-  ${c.brand('/conectar')}             entra na sua conta Conecta Primo · ${c.brand('/conta')} mostra o plano
-  ${c.brand('/conversas')} [n]        suas conversas salvas — as mesmas do app e do celular
-  ${c.brand('/sair')}                 desconecta este computador
-  ${c.brand('/status')}               checa o servidor
-  ${c.brand('/name')} <nome>          como o Primo te chama
-  ${c.brand('/mascot')} <estilo>      mascote: primo|fox|cat
-  ${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
-  ${c.brand('/exit')}                 sair
+  ${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('/mode')}               /mode primocode|chat|auto
+  ${c.brand('/effort')}             esforço do agente — do rápido ao mais esperto
+  ${c.brand('/compact')}            resume a conversa e devolve o contexto
+  ${c.brand('/attach')} <arquivo>   anexa arquivo ao próximo pedido
+  ${c.brand('/files')}              lista anexos   ${c.brand('/detach')} remove
+  ${c.brand('/all')}                lista tudo que ele sabe fazer
+  ${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('/rc')}                 abre a janela do PrimoCode (chat, sem terminal)
+  ${c.brand('/claude')}             usa o Claude Code da SUA conta como motor (Opus)
+  ${c.brand('/gpt')}                usa o GPT (Codex) da SUA conta como motor
+  ${c.brand('/key')} <provedor>     sua própria chave de API (Claude, GPT)
+  ${c.brand('/connect')}            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('/status')}             checa o servidor
+  ${c.brand('/name')} <nome>        como o Primo te chama
+  ${c.brand('/mascot')} <estilo>    mascote: primo|fox|cat
+  ${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
+  ${c.brand('/exit')}               sai do PrimoCode
 
 ${c.bold('Modos')}
   ${c.warn('Primo Code')}  ${c.muted('Agente completo — cria arquivos, roda comandos, abre o navegador')}
@@ -131,10 +132,11 @@ const SLASH_COMANDOS = [
     ['/dir', 'trabalhar numa pasta sua'],
     ['/mode', 'primocode | chat | auto'],
     ['/effort', 'esforço: low → ultracode (←/→ para ajustar)'],
+    ['/compact', 'resume a conversa e devolve o contexto'],
     ['/attach', 'anexa arquivo ao pedido'],
     ['/detach', 'remove os anexos'],
     ['/files', 'lista os anexos'],
-    ['/tudo', 'tudo que ele sabe fazer'],
+    ['/all', 'tudo que ele sabe fazer'],
     ['/tree', 'árvore do projeto'],
     ['/read', 'mostra um arquivo'],
     ['/run', 'roda um comando'],
@@ -142,11 +144,11 @@ const SLASH_COMANDOS = [
     ['/rc', 'abre a janela do PrimoCode'],
     ['/claude', 'usa o Claude Code da sua conta como motor'],
     ['/gpt', 'usa o GPT (Codex) da sua conta como motor'],
-    ['/chave', 'sua própria chave de API (Claude, Codex)'],
-    ['/conectar', 'entra na sua conta Conecta Primo'],
-    ['/conta', 'sua conta, plano e computadores conectados'],
-    ['/conversas', 'suas conversas salvas, as mesmas do app e do celular'],
-    ['/sair', 'desconecta este computador'],
+    ['/key', 'sua própria chave de API (Claude, Codex)'],
+    ['/connect', 'entra na sua conta Conecta Primo'],
+    ['/account', 'sua conta, plano e computadores conectados'],
+    ['/chats', 'suas conversas salvas, as mesmas do app e do celular'],
+    ['/logout', 'desconecta este computador da conta'],
     ['/status', 'checa o servidor'],
     ['/name', 'como ele te chama'],
     ['/mascot', 'primo | fox | cat'],
@@ -259,8 +261,22 @@ function makePrompt() {
         modeTag = state.mode === 'primocode' ? c.warn('Primo Code') : c.brandDim('Chat');
     }
     const proj = state.currentProject ? c.dim(` ${state.currentProject}`) : '';
+
+    /* O CONTEXTO na barra, como o pedido pede. Só aparece depois que há
+       conversa: um "ctx 0%" na abertura é ruído, e ruído que aparece sempre é
+       o que a pessoa aprende a não enxergar — inclusive quando marcar 90%.
+       Fica âmbar a partir de 70% e vermelho a partir de 100%, que é quando
+       `/compact` deixa de ser conselho e vira o que fazer. */
+    const uso = memoria.usoDoContexto(state.memoria, state.history);
+    const ctx = uso.pct < 5 ? '' : c.dim(' · ')
+        + (uso.pct >= 100 ? c.err(`ctx ${uso.pct}%`)
+            : uso.pct >= 70 ? c.warn(`ctx ${uso.pct}%`)
+                : c.dim(`ctx ${uso.pct}%`));
+    // O modelo ativo: qual motor está pensando. No padrão é o do servidor.
+    const motor = state.engine === 'claude-code' ? c.dim(' · ') + c.dim('claude')
+        : state.engine === 'codex' ? c.dim(' · ') + c.dim('gpt') : '';
     const att = state.attachedFiles.length ? c.muted(` +${state.attachedFiles.length}`) : '';
-    return `\n${c.muted(modeTag)}${proj}${att} ${c.brand('❯')} `;
+    return `\n${c.muted(modeTag)}${motor}${ctx}${proj}${att} ${c.brand('❯')} `;
 }
 function refreshPrompt() { if (rl) rl.setPrompt(makePrompt()); }
 
@@ -268,9 +284,31 @@ function refreshPrompt() { if (rl) rl.setPrompt(makePrompt()); }
 // — não um novo comando. Sem isso o "s" de confirmação virava prompt para a IA.
 let pendingAsk = null;
 
+/* ── O QUE A PESSOA ADIANTA ──────────────────────────────────────────────
+ * Enquanto a abertura corre — e ela demora, porque confere o plano no
+ * servidor — o que for digitado não é comando nem resposta ainda: a pergunta
+ * ainda não apareceu. Fica aqui.
+ *
+ * Sem isto, esse texto caía como PEDIDO no agente. Medido no pacote
+ * publicado: o "2" da escolha da IA virou pergunta no chat e o modelo
+ * respondeu "Oi! Como posso ajudar?".
+ *
+ * E guardar não bastava: preso na fila de comandos, ele nunca chegava à
+ * pergunta que veio depois. Por isso o `ask` olha aqui ANTES de esperar uma
+ * linha nova — quem digitou 2 antes de ver o menu escolheu a 2, e a escolha
+ * dela vale.
+ */
+let segurando = false;
+const adiantadas = [];
+
 function ask(question) {
     return new Promise((resolve) => {
-        if (rl) { process.stdout.write(question); pendingAsk = resolve; return; }
+        if (rl) {
+            process.stdout.write(question);
+            if (adiantadas.length) { const a = adiantadas.shift(); process.stdout.write(a + '\n'); return resolve(a); }
+            pendingAsk = resolve;
+            return;
+        }
         const tmp = readline.createInterface({ input: process.stdin, output: process.stdout });
         tmp.question(question, (a) => { tmp.close(); resolve(a); });
     });
@@ -436,7 +474,7 @@ async function sendPrompt(userText) {
     if (state.liberado === false) {
         console.log(c.err('  O PrimoCode pede o plano Premium ou Super.'));
         console.log(c.muted('  Assine em ') + c.brand('conecta-primo-ai.vercel.app')
-            + c.muted(' · já assinou? ') + c.brand('/conectar'));
+            + c.muted(' · já assinou? ') + c.brand('/connect'));
         return;
     }
 
@@ -627,8 +665,12 @@ async function dividirTarefa(pedido) {
  * Silencioso quando não há o que fazer: nas primeiras rodadas a conversa é
  * curta e o resumo não pagaria a chamada.
  */
-async function comprimirConversa() {
-    if (!memoria.precisaResumir(state.memoria, state.history)) return;
+/* `forcado` é o `/compact`: a pessoa mandou resumir, e mandar resumir tem de
+   resumir. Sem isso o comando responderia "nada a fazer" justamente quando
+   ela está vendo a IA se perder — e "não fiz nada" é a pior resposta possível
+   para quem acabou de pedir socorro. */
+async function comprimirConversa(forcado = false) {
+    if (!forcado && !memoria.precisaResumir(state.memoria, state.history)) return;
     const sp = new Spinner('resumindo a conversa').start();
     try {
         state.memoria = await memoria.atualizar(state.memoria, state.history, ({ resumo, mensagens }) =>
@@ -698,11 +740,49 @@ function motorDaVez() {
 
 function isSlash(text) { return text.trim().startsWith('/'); }
 
+/* ── OS NOMES ANTIGOS ────────────────────────────────────────────────────
+ * Os comandos passaram a ser todos em inglês. Metade já era; a outra metade
+ * estava em português, e a mistura era o que a especificação chamou de
+ * bagunça — `/run` ao lado de `/pasta`, `/tree` ao lado de `/tudo`.
+ *
+ * O nome antigo NÃO some: ele responde e ensina o novo. Sumir de vez faz quem
+ * tem o dedo viciado bater num "comando não existe" e concluir que a
+ * atualização quebrou alguma coisa — e essa pessoa não vai procurar no /help,
+ * vai desinstalar.
+ *
+ * Uma tabela, e não um `if` dentro de cada `case`: com dezoito apelidos, o
+ * `if` espalhado é o jeito garantido de esquecer um. Aqui, esquecer é não
+ * escrever a linha, e a linha some da lista.
+ */
+const RENOMEADOS = {
+    // o que abre a janela
+    app: 'rc',
+    // a conta
+    entrar: 'connect', login: 'connect', conectar: 'connect',
+    conta: 'account',
+    sair: 'exit',        // sair é SAIR; desconectar a conta é /logout
+    // as chaves de API
+    chave: 'key', chaves: 'key',
+    // o histórico
+    conversas: 'chats', historico: 'chats', histórico: 'chats',
+    // o resto
+    pasta: 'dir',
+    esforco: 'effort', esforço: 'effort',
+    tudo: 'all', capacidades: 'all',
+};
+
 async function handleSlash(text) {
     const [cmd] = text.trim().slice(1).split(/\s+/);
     const rest = text.trim().slice(1 + cmd.length).trim();
 
-    switch (cmd.toLowerCase()) {
+    let nome = cmd.toLowerCase();
+    if (RENOMEADOS[nome]) {
+        const novo = RENOMEADOS[nome];
+        console.log(c.muted('  Agora é ') + c.brand('/' + novo) + c.muted('.'));
+        nome = novo;
+    }
+
+    switch (nome) {
         case 'help': console.log(HELP); break;
 
         case 'project': {
@@ -729,8 +809,7 @@ async function handleSlash(text) {
         // Antes só existia /project, que SEMPRE cria em ~/primocode/<nome>. Se a
         // sua pasta já existe em outro lugar, não havia como apontar para ela.
         case 'dir':
-        case 'cd':
-        case 'pasta': {
+        case 'cd': {
             if (!rest) {
                 const de = {
                     padrao: 'a pasta padrão do PrimoCode',
@@ -798,7 +877,7 @@ async function handleSlash(text) {
         /* A chave de API da própria pessoa. Guardada em ~/.primocode/
            chaves.json com permissão 600 — nunca no config.json, que é o
            arquivo que se cola num chamado de suporte. */
-        case 'chave': case 'chaves': {
+        case 'key': case 'keys': {
             const [qual, ...resto] = rest.split(/\s+/).filter(Boolean);
             const valor = resto.join(' ');
 
@@ -809,8 +888,8 @@ async function handleSlash(text) {
                         + (p.tem ? c.ok(p.disfarce) : c.dim('não configurada'))
                         + c.dim(`   ${p.variavel}`));
                 }
-                console.log(c.dim('\n  /chave claude sk-ant-…   guarda a chave'));
-                console.log(c.dim('  /chave codex remover     apaga a que estiver lá'));
+                console.log(c.dim('\n  /key claude sk-ant-…      guarda a chave'));
+                console.log(c.dim('  /key gpt remover          apaga a que estiver lá'));
                 console.log(c.muted('\n  Sem chave própria, cada motor usa a conta em que você já entrou nele.'));
                 break;
             }
@@ -826,7 +905,7 @@ async function handleSlash(text) {
             }
             if (!valor) {
                 const p = chaves.PROVEDORES[qual];
-                console.log(c.muted(`  Uso: `) + c.brand(`/chave ${qual} ${p.prefixo}…`));
+                console.log(c.muted(`  Uso: `) + c.brand(`/key ${qual} ${p.prefixo}…`));
                 console.log(c.dim(`  Pegue a sua em ${p.onde}`));
                 break;
             }
@@ -889,7 +968,7 @@ async function handleSlash(text) {
         // O /model virou /effort: você escolhe o ESFORÇO num slider (←/→,
         // Enter confirma, Esc cancela) e o modelo sai daí. Com argumento
         // ("/effort high") aplica direto, para quem já sabe o que quer.
-        case 'effort': case 'esforco': case 'esforço': {
+        case 'effort': {
             const pedido = rest.toLowerCase().trim();
             if (pedido) {
                 if (!effort.NOMES.includes(pedido)) {
@@ -942,9 +1021,8 @@ async function handleSlash(text) {
         // A lista vem de lib/catalogo.js, e o test/catalogo.test.js cruza aquela
         // lista com as tools que o tools.execute realmente atende. Ou seja: esta
         // tela não consegue prometer coisa que o programa não faz.
-        case 'tudo':
-        case 'tools':
-        case 'capacidades': {
+        case 'all':
+        case 'tools': {
             const cols = Math.max(40, Math.min(process.stdout.columns || 90, 110));
             console.log('');
             for (const g of catalogo.GRUPOS) {
@@ -1033,6 +1111,29 @@ async function handleSlash(text) {
         // Limpar aqui não apaga o que já subiu: encerra ESTA conversa e a
         // próxima pergunta abre outra. Apagar do histórico é decisão da
         // pessoa, e ela toma no app — não de raspão num comando de limpar tela.
+        /* Resume a conversa por ordem da pessoa. Diferente do /clear: aqui
+           nada é esquecido — o que já passou vira resumo e o fim continua
+           cru, então dá para seguir de onde parou. */
+        case 'compact': {
+            if (!state.history.length) {
+                console.log(c.muted('  A conversa está vazia — não há o que resumir.'));
+                break;
+            }
+            const antes = memoria.usoDoContexto(state.memoria, state.history);
+            await comprimirConversa(true);
+            const depois = memoria.usoDoContexto(state.memoria, state.history);
+            if (depois.tokens >= antes.tokens) {
+                // Pode não haver o que dobrar (conversa curta, ou o servidor
+                // recusou). Dizer isso é melhor que fingir que encolheu.
+                console.log(c.muted('  Não deu para encolher mais desta vez.'));
+            } else {
+                console.log(c.ok('  Conversa resumida.')
+                    + c.muted(`  ctx ${antes.pct}% → ${depois.pct}%`));
+            }
+            refreshPrompt();
+            break;
+        }
+
         case 'clear': state.history = []; state.memoria = memoria.nova();
             state.gravador.zerar(); console.log(c.ok('Conversa limpa.')); break;
         case 'cls': process.stdout.write('\x1Bc'); break;
@@ -1074,10 +1175,7 @@ async function handleSlash(text) {
            não existe" e acha que a atualização quebrou alguma coisa; o aviso
            custa uma linha e ensina o nome novo na hora em que ele é
            procurado, que é a única hora em que alguém lê. */
-        case 'rc': case 'app': {
-            if (cmd.toLowerCase() === 'app') {
-                console.log(c.muted('  Agora é ') + c.brand('/rc') + c.muted('. Abrindo…'));
-            }
+        case 'rc': {
             // `/rc --instalar` põe o PrimoCode no Dock, no menu Iniciar ou no
             // menu de aplicativos, com o ícone do mascote. Uma vez só.
             if (/^--?(instalar|install)$/.test(rest)) {
@@ -1128,7 +1226,7 @@ async function handleSlash(text) {
                 // /rc viraria ruído para quem já instalou de propósito.
                 if (!require('../lib/instalar-app.js').instalado()) {
                     console.log(c.dim('  Quer o ícone no ') + c.dim(os.platform() === 'darwin' ? 'Dock' : 'menu Iniciar')
-                        + c.dim('? ') + c.brand('/app --instalar'));
+                        + c.dim('? ') + c.brand('/rc --instalar'));
                 }
             } catch (e) {
                 sp.stop();
@@ -1139,15 +1237,12 @@ async function handleSlash(text) {
 
         /* A conta do Conecta Primo. O login inteiro mora em lib/conta.js;
            aqui é a tela dele. */
-        case 'conectar': case 'entrar': case 'login': {
-            if (/^(entrar|login)$/.test(cmd.toLowerCase())) {
-                console.log(c.muted('  Agora é ') + c.brand('/conectar') + c.muted('.'));
-            }
+        case 'connect': {
             const jaEsta = conta.atual();
             if (jaEsta && rest !== 'trocar') {
                 console.log(c.muted('  Já conectado como ') + c.brand(jaEsta.uid.slice(0, 12) + '…')
                     + c.muted(` · plano ${jaEsta.plano}`));
-                console.log(c.dim('  Para entrar com outra conta: ') + c.brand('/conectar trocar'));
+                console.log(c.dim('  Para entrar com outra conta: ') + c.brand('/connect trocar'));
                 break;
             }
             if (rest === 'trocar') conta.sair();
@@ -1163,11 +1258,20 @@ async function handleSlash(text) {
                         console.log('  ' + c.brand(msg));
                         primeiro = false;
                     } else {
-                        // O código aparece AQUI para a pessoa comparar com o
-                        // da página. Sem essa comparação, um link mandado por
-                        // outra pessoa conectaria o computador dela à conta
-                        // de quem clicou.
-                        console.log(c.muted('  Confira o código na página: ') + c.bold(c.warn(msg)));
+                        /* O código é para DIGITAR na página, e é ele que
+                           protege: como não vai no link, quem não está olhando
+                           este terminal não tem o que digitar — e um link
+                           mandado por outra pessoa não conecta o computador
+                           dela à sua conta.
+
+                           Por isso ele aparece grande e sozinho, com o traço
+                           no meio: o que se lê de uma tela e se digita noutra
+                           erra menos partido em dois. */
+                        const meio = msg.length === 8 ? msg.slice(0, 4) + '-' + msg.slice(4) : msg;
+                        console.log('');
+                        console.log(c.muted('  Digite este código na página:'));
+                        console.log('    ' + c.bold(c.brand(meio.split('').join(' '))));
+                        console.log('');
                         console.log(c.dim('  Esperando você aprovar…'));
                     }
                 },
@@ -1181,9 +1285,9 @@ async function handleSlash(text) {
 
         /* O histórico da conta — o MESMO que o app desktop e o celular
            mostram. Sem número, lista; com número, abre e continua dali. */
-        case 'conversas': case 'historico': {
+        case 'chats': {
             if (!conta.atual()) {
-                console.log(c.muted('  Não conectado. ') + c.brand('/conectar')
+                console.log(c.muted('  Não conectado. ') + c.brand('/connect')
                     + c.muted(' para ver suas conversas aqui, no app e no celular.'));
                 break;
             }
@@ -1204,7 +1308,7 @@ async function handleSlash(text) {
                         + ' ' + c.white(x.titulo.slice(0, 52).padEnd(52))
                         + c.dim(`${String(x.mensagens).padStart(3)} msg  ${quando}`));
                 });
-                console.log(c.dim('\n  /conversas 1  abre a primeira e continua dela.'));
+                console.log(c.dim('\n  /chats 1  abre a primeira e continua dela.'));
                 break;
             }
             const n = Number(rest);
@@ -1228,18 +1332,18 @@ async function handleSlash(text) {
             break;
         }
 
-        case 'sair': case 'logout': {
+        case 'logout': {
             if (!conta.atual()) { console.log(c.muted('  Você não está conectado.')); break; }
             conta.sair();
             console.log(c.ok('  Desconectado deste computador.')
-                + c.dim('  A conta continua intacta; entre de novo com /conectar.'));
+                + c.dim('  A conta continua intacta; entre de novo com /connect.'));
             break;
         }
 
-        case 'conta': {
+        case 'account': {
             const eu = conta.atual();
             if (!eu) {
-                console.log(c.muted('  Não conectado. ') + c.brand('/conectar') + c.muted(' para entrar.'));
+                console.log(c.muted('  Não conectado. ') + c.brand('/connect') + c.muted(' para entrar.'));
                 break;
             }
             const sp = new Spinner('conferindo').start();
@@ -1527,6 +1631,8 @@ async function main() {
 
     rl.on('line', (line) => {
         if (pendingAsk) { const resolve = pendingAsk; pendingAsk = null; resolve(line); return; }
+        // Abertura correndo: guarda em vez de mandar ao agente.
+        if (segurando) { adiantadas.push(line); return; }
         queue.push(line);
         drain();
     });
@@ -1540,13 +1646,25 @@ async function main() {
      * para pegar. Quem colasse dois comandos perdia o segundo, e quem
      * fechasse a entrada saía sem nem o "Até logo". Digitando devagar ninguém
      * via — os ouvintes ficam prontos milissegundos depois. */
+    /* A FILA FICA SEGURA ENQUANTO A ABERTURA CORRE.
+     *
+     * `busy` já é o freio do `drain`, e é ele que se usa aqui. Sem isso, tudo
+     * o que a pessoa digitar antes de a pergunta aparecer — e ela demora,
+     * porque confere o plano no servidor — cai como PEDIDO no agente. Medido
+     * no pacote publicado: o "2" da escolha da IA virou uma pergunta no chat,
+     * e o modelo respondeu "Oi! Como posso ajudar?".
+     *
+     * O ouvinte de `line` continua atendendo o `ask` normalmente: ele olha o
+     * `pendingAsk` antes da fila. O que fica retido é só o que não era
+     * resposta a nada. */
+    segurando = true;
     boasVindas.rodar({
         perguntar: ask,
         mostrar: (t) => console.log(t),
         cores: c,
         interativo: !!(process.stdin.isTTY && process.stdout.isTTY),
         conectado: () => conta.atual(),
-        conectar: () => handleSlash('/conectar').then(() => conta.atual()),
+        conectar: () => handleSlash('/connect').then(() => conta.atual()),
         sessao: () => conta.sessao(),
         aplicar: (cmd) => handleSlash(cmd),
     }).then((r) => {
@@ -1555,8 +1673,14 @@ async function main() {
         // o primocode-server, que tem a chave do provedor.
         state.liberado = !r || r.liberado !== false;
         state.motivoBloqueio = r && r.motivo;
-        if (!closed && !busy) rl.prompt();
-    }).catch(() => { state.liberado = true; });
+    }).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();
+    });
 }
 
 main().catch((e) => { console.error(c.err(e.message || e)); process.exit(1); });

package/lib/icone.js

@@ -82,56 +82,72 @@ function caixa(t, x0, y0, l, a, r, cor) {
 
 // ── o mascote ────────────────────────────────────────────────────────────
 
-/* O Primo, o mesmo do terminal: cabeça de topo arredondado, ombros largos,
- * dois pezinhos. Lá ele é feito de glifos de bloco:
+/* O DESENHO VEM DE UM LUGAR SÓ.
  *
- *      ▐▛███▜▌        a cabeça
- *     ▝▜█████▛▘       o corpo, mais largo
- *       ▘▘ ▝▝         os pés
+ * Antes esta função desenhava um bicho à mão — cabeça arredondada, ombros,
+ * dois pés, olhos no negativo — e o app e o site desenhavam OUTRO, a matriz de
+ * pixels do logo que o dono mandou. Dois desenhos com o mesmo nome: o ícone no
+ * Dock não era o bicho que aparecia dentro do programa.
  *
- * Aqui são as mesmas três peças em proporção, e não uma transliteração dos
- * glifos: meio bloco de terminal vira escada num ícone de 512px. O que faz
- * reconhecer é a SILHUETA — topo redondo, ombro saliente, dois pés —, e ela é
- * a mesma.
- */
+ * Agora os dois leem a mesma `MATRIZ` do `app/primo-marca.js`. Mudar o logo é
+ * mudar onze linhas de texto, e o Dock, a janela e o site mudam juntos.
+ *
+ * (Aquele arquivo é escrito para o navegador, mas se pendura no `globalThis`
+ * quando não há `window` — então dá para carregá-lo aqui sem uma segunda
+ * versão dele.) */
+require('../app/primo-marca.js');
+const MARCA = (typeof globalThis !== 'undefined' && globalThis.PrimoMarca) || null;
+
+/** #5ec8ef → [94, 200, 239] */
+function doHex(h) {
+    const n = parseInt(String(h).replace('#', ''), 16);
+    return [(n >> 16) & 255, (n >> 8) & 255, n & 255];
+}
+
 function desenharPrimo(n) {
     const t = tela(n);
-    const u = n / 32;                      // a grade do desenho, em pixels
 
-    // A base: o quadrado escuro do app, com o mesmo arredondado do ícone de
-    // sistema (22% do lado é o raio que o macOS e o Windows usam hoje).
+    // A base: o quadrado escuro do app, com o mesmo arredondado que o macOS e
+    // o Windows usam hoje (22% do lado). É o formato de azulejo do estilo
+    // pedido — glifo chapado, centrado, sobre cor sólida.
     caixa(t, 0, 0, n, n, n * 0.22, FUNDO);
 
-    // Um brilho fraco atrás do bicho — o mesmo halo do fundo do app.
+    // Um brilho fraco atrás do bicho, para o azulejo não ficar chapado.
     for (let y = 0; y < n; y++) {
         for (let x = 0; x < n; x++) {
-            const dx = (x - n / 2) / (n * 0.6);
-            const dy = (y - n * 0.34) / (n * 0.6);
+            const dx = (x - n / 2) / (n * 0.62);
+            const dy = (y - n * 0.42) / (n * 0.62);
             const d = Math.sqrt(dx * dx + dy * dy);
-            if (d < 1) ponto(t, x, y, AZUL, 0.11 * (1 - d) * (1 - d));
+            if (d < 1) ponto(t, x, y, AZUL, 0.10 * (1 - d) * (1 - d));
         }
     }
 
-    // Cabeça: topo arredondado, ombros retos embaixo (raio só em cima é o que
-    // dá a silhueta do ▐▛███▜▌ — redondo por cima, quadrado por baixo).
-    caixa(t, 9 * u, 7 * u, 14 * u, 11 * u, 3.4 * u, AZUL);
-    caixa(t, 9 * u, 14 * u, 14 * u, 4 * u, 0.6 * u, AZUL);
-
-    // Corpo: mais largo que a cabeça, que é o ombro marcado do desenho.
-    caixa(t, 6 * u, 17.6 * u, 20 * u, 7.6 * u, 2.2 * u, AZUL);
+    if (!MARCA) return t;                 // sem a matriz, fica o azulejo
 
-    // Os dois pés.
-    caixa(t, 10 * u, 24.6 * u, 4.4 * u, 2.6 * u, 1 * u, AZUL_FUNDO);
-    caixa(t, 17.6 * u, 24.6 * u, 4.4 * u, 2.6 * u, 1 * u, AZUL_FUNDO);
+    const linhas = MARCA.MATRIZ;
+    const colunas = linhas[0].length;
+    const corpo = doHex(MARCA.CORPO);
+    const detalhe = doHex(MARCA.DETALHE);
 
-    // Os olhos, no negativo — é o que faz o bloco virar bicho.
-    caixa(t, 12.4 * u, 10.6 * u, 2.6 * u, 3.2 * u, 1.1 * u, FUNDO);
-    caixa(t, 17 * u, 10.6 * u, 2.6 * u, 3.2 * u, 1.1 * u, FUNDO);
+    /* O bicho ocupa 62% do azulejo. Mais que isso ele encosta na borda
+     * arredondada e o ícone fica apertado; menos, e some no tamanho de 16px da
+     * barra de tarefas — que é onde ele mais aparece. */
+    const lado = Math.floor((n * 0.62) / colunas);
+    const largura = lado * colunas;
+    const altura = lado * linhas.length;
+    const x0 = Math.round((n - largura) / 2);
+    const y0 = Math.round((n - altura) / 2);
 
-    // A luz de cima: uma faixa clara na testa e no ombro. Sem ela o bicho é
-    // uma silhueta chapada — é o mesmo bisel do "vidro" do estúdio.
-    caixa(t, 10.4 * u, 8.2 * u, 11.2 * u, 1.4 * u, 0.7 * u, BRILHO);
-    caixa(t, 7.6 * u, 18.6 * u, 16.8 * u, 1.2 * u, 0.6 * u, BRILHO);
+    for (let f = 0; f < linhas.length; f++) {
+        for (let cIdx = 0; cIdx < colunas; cIdx++) {
+            const ch = linhas[f][cIdx];
+            if (ch !== 'C' && ch !== 'D') continue;
+            // Sem raio: pixel art com canto redondo deixa de ser pixel art, e
+            // vira um monte de bolinhas quando o quadrado é pequeno.
+            caixa(t, x0 + cIdx * lado, y0 + f * lado, lado, lado, 0,
+                ch === 'C' ? corpo : detalhe);
+        }
+    }
 
     return t;
 }

package/lib/memoria-conversa.js

@@ -115,10 +115,33 @@ function paraEnviar(memoria, history) {
 }
 
 /** Quanto este jeito economiza — para o /status e para o teste provarem. */
+/* ── O QUANTO DA CONVERSA JÁ ESTÁ NA MESA ────────────────────────────────
+ * A barra do terminal mostra isso em porcentagem, e a porcentagem precisa de
+ * um teto para ser porcentagem DE alguma coisa.
+ *
+ * O teto de verdade é do servidor e muda com o modelo e com o minuto (ele
+ * divide o orçamento entre prompt, ferramentas e conversa a cada pedido). O
+ * CLI não vê esse número, e fingir que vê seria pior que não mostrar: a barra
+ * diria 20% no exato momento em que o pedido não coubesse.
+ *
+ * Então o teto aqui é declarado e é DA CONVERSA: quanto de histórico vale a
+ * pena carregar antes de resumir. É uma régua honesta — quem chega perto de
+ * 100% está mesmo com a conversa pesada, e `/compact` resolve. */
+const TETO_CONVERSA = 4000;
+
+function usoDoContexto(memoria, history) {
+    const tokens = tokensDe(paraEnviar(memoria, history));
+    return {
+        tokens,
+        teto: TETO_CONVERSA,
+        pct: Math.min(999, Math.round((tokens / TETO_CONVERSA) * 100)),
+    };
+}
+
 function economia(memoria, history) {
     const cheio = tokensDe((history || []).slice(-20));
     const enxuto = tokensDe(paraEnviar(memoria, history));
     return { cheio, enxuto, poupado: Math.max(0, cheio - enxuto) };
 }
 
-module.exports = { nova, pendentes, precisaResumir, atualizar, paraEnviar, economia, tokensDe, inicioSeguro, CRUAS, LIMITE_TOKENS };
+module.exports = { nova, pendentes, usoDoContexto, TETO_CONVERSA, precisaResumir, atualizar, paraEnviar, economia, tokensDe, inicioSeguro, CRUAS, LIMITE_TOKENS };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "8.34.0",
+  "version": "8.35.0",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Requer conta Conecta Primo AI (Premium ou Super). Cria arquivos, roda comandos, controla navegador e desktop: abre apps, clica em botões e ícones pelo nome, digita e usa atalhos.",
   "main": "bin/primocode.js",
   "bin": {