primocode 7.4.1 → 7.7.0

package/README.md

@@ -1,16 +1,13 @@
-# PrimoCode v7.4.0
+# PrimoCode v7.7.0
 
 Agente de engenharia brasileiro para o terminal, no estilo Claude Code.
 Cria arquivos de verdade, roda comandos, **controla o navegador e o desktop** —
 e lembra do que fez entre uma sessão e outra.
 
 ```
-    ╭◠╮
-  ╭─┴─┴─╮
- ◖┫ ● ● ┣◗     PrimoCode  v7.4.0
-  ┃  ‿  ┃      projeto: jogo-de-carro
-  ╰──┬──╯
-   ╰─┴─╯
+ ▐▛███▜▌   Primo Code v7.7.0
+▝▜█████▛▘  Bem-vindo de volta, Joel
+  ▘▘ ▝▝    ~/projetos/jogo-de-carro
 ```
 
 Personalize o mascote (`primo`, `fox`, `cat`) e o nome com que ele te chama —
@@ -26,20 +23,41 @@ veja `/mascot` e `/name`.
 | **Memória** | Cada projeto lembra o que foi feito, entre sessões | Esquece ao fechar |
 | **Instalação** | Node puro, **zero dependências** — segundos | Pacotes e dependências |
 | **Cara própria** | Mascote, nome e temas que você escolhe | Fixo |
-| **Custo** | Roda em modelos rápidos e baratos (Groq/Llama) | Cobrança por token da API |
+| **Modelos** | Claude Opus 5, Sonnet 5 e Haiku 4.5 via OpenRouter — trocáveis com `/model` | Preso ao provedor do fabricante |
 
 Em uma frase: **é o poder de um agente de código no terminal, em português, controlando o seu computador de verdade — sem você precisar configurar chave de API nenhuma.**
 
 ## Instalação
 
+**macOS / Linux / WSL** — um comando, e ele resolve tudo (inclusive instalar o Node, se faltar):
+
 ```bash
-git clone https://github.com/ConectaPrimoAI/primocode.git
-cd primocode
-npm link          # registra 'primocode' globalmente
-primocode
+curl -fsSL https://raw.githubusercontent.com/ConectaPrimoAI/primocode/main/install.sh | bash
+```
+
+**Windows** — baixe o repositório e rode:
+
+```cmd
+install.cmd
 ```
 
-Requer **Node.js 18.17+**. O CLI não tem dependências — só a stdlib do Node.
+Já tem Node 18.17+? Então basta:
+
+```bash
+npm install -g primocode
+```
+
+Requer **Node.js 18.17+**. O CLI não tem dependências — só a stdlib do Node, por isso instala em segundos.
+
+### Se der erro
+
+| Erro | O que fazer |
+|---|---|
+| `command not found: npm` | Você não tem Node. Rode o `install.sh` — ele detecta, pergunta e instala pra você. |
+| `EACCES ... mkdir '/usr/local/lib/node_modules'` | O npm está apontando para uma pasta do sistema. **Não use `sudo`** — rode o `install.sh`, que move o npm para `~/.npm-global`. |
+| `command not found: primocode` | A instalação não terminou, ou o PATH não foi recarregado. Abra um terminal novo; se persistir, rode o `install.sh` de novo. |
+
+O `install.sh` é seguro de rodar quantas vezes quiser — ele conserta o que estiver errado e não duplica nada.
 
 ## Como funciona
 
@@ -75,10 +93,43 @@ fim. É por isso que a IA não esquece o projeto entre sessões.
 
 | Modo | O que faz |
 |---|---|
-| **Primo Code** (padrão) | Agente completo — cria arquivos, roda comandos, abre o navegador |
+| **Auto** (padrão) | Escolhe por pedido: conversa vai pro chat, tarefa vai pro agente |
+| **Primo Code** | Agente completo — cria arquivos, roda comandos, abre o navegador |
 | **Chat** | Conversa pura, sem tools |
 
-Alterne com `/mode primocode` ou `/mode chat`.
+Alterne com `/mode auto`, `/mode primocode` ou `/mode chat`. A escolha fica
+guardada entre sessões.
+
+**Por que o auto é o padrão.** O modo Primo Code manda o catálogo das 30
+ferramentas em todo pedido — cerca de 4.700 tokens antes de você digitar a
+primeira letra. Um "oi" custava o mesmo que uma refatoração, e num plano com
+teto diário isso acaba a cota no meio da tarde. O auto decide na sua máquina,
+sem chamar o modelo para isso, e mostra o que escolheu:
+
+```
+Auto ❯ oi
+  ⎿ Chat · cumprimento
+
+Auto·chat ❯ conserta o bug do login em src/auth.js
+  ⎿ Primo Code · cita arquivo ou caminho
+```
+
+Na dúvida ele vai para o chat: errar para chat custa repetir o pedido, errar
+para o agente custa token e pode escrever arquivo que ninguém pediu.
+
+## Onde ele trabalha
+
+| Situação | Pasta de trabalho |
+|---|---|
+| Abriu o PrimoCode dentro de uma pasta | é ali que ele trabalha |
+| `/dir ~/meus-projetos/site` | a pasta que **você** escolher, onde ela estiver |
+| `/project loja` | cria `~/primocode/loja`, com memória própria |
+
+`/dir` sem argumento mostra a pasta ativa e de onde ela veio. Caminho relativo
+resolve contra a pasta ativa, então depois de um `/dir` o `/dir src` entra na
+subpasta. Se a pasta não existir, ele pergunta antes de criar; se for a sua home
+ou a raiz do disco, pergunta de novo — é onde um arquivo escrito por engano dói
+mais.
 
 ## Ferramentas do agente
 
@@ -187,9 +238,10 @@ primocode -f app.js "onde está o bug?" # com arquivo anexado
 
 | Comando | Descrição |
 |---|---|
-| `/project` | Lista projetos. `/project <nome>` cria ou entra em um |
-| `/mode primocode\|chat` | Alterna o modo |
-| `/model main\|fast` | main = llama-3.3-70b, fast = llama-3.1-8b |
+| `/dir <caminho>` | Trabalha numa pasta que já existe, onde você quiser |
+| `/project` | Lista projetos. `/project <nome>` cria em `~/primocode` |
+| `/mode primocode\|chat\|auto` | Alterna o modo (fica guardado) |
+| `/model top\|main\|fast` | top = Opus 5, main = Sonnet 5 (padrão), fast = Haiku 4.5. Aceita qualquer ID do OpenRouter |
 | `/attach <arquivo>` | Anexa arquivo ao próximo pedido |
 | `/detach` · `/files` | Remove / lista anexos |
 | `/tree [n]` | Árvore do projeto atual |
@@ -234,7 +286,7 @@ Caminho absoluto ou com `../` é recusado — o agente não escreve fora da sua
 
 ```
 ┌────────────────┐   HTTPS/SSE    ┌───────────────────┐   HTTPS   ┌──────────┐
-│  primocode CLI │ ─────────────► │  primocode-server │ ────────► │   Groq   │
+│  primocode CLI │ ─────────────► │  primocode-server │ ────────► │OpenRouter│
 │  (seu terminal)│ ◄───────────── │     (Render)      │ ◄──────── │   API    │
 └────────────────┘                └───────────────────┘           └──────────┘
      executa as tools                monta o prompt

package/bin/primocode.js

@@ -15,6 +15,7 @@ const os = require('os');
 const pkg = require('../package.json');
 const ui = require('../lib/ui');
 const { c, welcomeBox, Spinner } = ui;
+const { escolherModo } = require('../lib/modo.js');
 const api = require('../lib/api');
 const tools = require('../lib/tools');
 const cfg = require('../lib/config');
@@ -25,18 +26,21 @@ const VERSION = pkg.version;
 const state = {
     config: cfg.loadConfig(),
     history: [],
-    mode: 'primocode',
+    mode: null,        // 'primocode' | 'chat' | 'auto' — vem da config em main()
+    modoEfetivo: null, // no auto, o modo que o último pedido usou de fato
     attachedFiles: [],
     lastResponse: '',
     currentProject: null,
-    workDir: null, // pasta onde o agente trabalha nesta sessão
+    workDir: null,     // pasta onde o agente trabalha nesta sessão
+    workDirOrigem: null, // 'cwd' | '/dir' | 'projeto' — para o /dir explicar
 };
 
 const HELP = `
 ${c.bold('Comandos')}
-  ${c.brand('/project')}              lista projetos ou muda: /project <nome>
-  ${c.brand('/mode')}                 alterna: /mode primocode|chat
-  ${c.brand('/model')}                alterna: /model main|fast
+  ${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('/model')}                /model top|main|fast — ou um ID do OpenRouter
   ${c.brand('/attach')} <arquivo>     anexa arquivo ao próximo pedido
   ${c.brand('/files')}                lista anexos   ${c.brand('/detach')} remove
   ${c.brand('/tree')} [n]             árvore do projeto
@@ -52,14 +56,27 @@ ${c.bold('Comandos')}
   ${c.brand('/exit')}                 sair
 
 ${c.bold('Modos')}
-  ${c.magenta('Primo Code')}  ${c.muted('Agente completo — cria arquivos, roda comandos, abre o navegador')}
-  ${c.brand('Chat')}        ${c.muted('Conversa pura — sem tools, só diálogo')}
+  ${c.warn('Primo Code')}  ${c.muted('Agente completo — cria arquivos, roda comandos, abre o navegador')}
+  ${c.brandDim('Chat')}        ${c.muted('Conversa pura — sem tools, só diálogo. Gasta bem menos token')}
+  ${c.brand('Auto')}        ${c.muted('Escolhe por pedido: conversa vai pro chat, tarefa vai pro agente')}
+
+${c.bold('Onde ele trabalha')}
+  ${c.muted('Abriu dentro de uma pasta? É ali. Senão, /dir aponta para qualquer')}
+  ${c.muted('pasta sua, e /project cria uma nova em ~/primocode.')}
 `;
 
 let rl = null;
 
 function makePrompt() {
-    const modeTag = state.mode === 'primocode' ? c.magenta('Primo Code') : c.brand('Chat');
+    // No auto o rótulo mostra "Auto" e, depois do primeiro pedido, qual modo
+    // ele acabou usando — senão você nunca sabe quem respondeu.
+    let modeTag;
+    if (state.mode === 'auto') {
+        const ultimo = state.modoEfetivo === 'primocode' ? c.warn('primo') : state.modoEfetivo === 'chat' ? c.brandDim('chat') : '';
+        modeTag = c.brand('Auto') + (ultimo ? c.dim('·') + ultimo : '');
+    } else {
+        modeTag = state.mode === 'primocode' ? c.warn('Primo Code') : c.brandDim('Chat');
+    }
     const proj = state.currentProject ? c.dim(` ${state.currentProject}`) : '';
     const att = state.attachedFiles.length ? c.muted(` +${state.attachedFiles.length}`) : '';
     return `\n${c.muted(modeTag)}${proj}${att} ${c.brand('❯')} `;
@@ -129,6 +146,7 @@ function createPendingProject(plan) {
     const dir = cfg.createProjectDir(plan.name);
     state.workDir = dir;
     state.currentProject = path.basename(dir);
+    state.workDirOrigem = 'projeto';
     const rotulo = plan.similar ? 'Continuando em' : 'Projeto novo:';
     console.log(c.ok(`  ${rotulo} ${state.currentProject}`) + c.muted(`  (${dir})`));
     refreshPrompt();
@@ -148,7 +166,19 @@ async function sendPrompt(userText) {
         prompt = parts.join('\n\n') + '\n\n' + userText;
     }
 
-    if (state.mode === 'primocode') {
+    // O modo primocode manda o schema das 30 tools em todo pedido (~4.700
+    // tokens). No auto, quem não vai usar ferramenta não paga por ela.
+    let modo = state.mode;
+    if (modo === 'auto') {
+        const escolha = escolherModo(userText);
+        modo = escolha.modo;
+        state.modoEfetivo = modo;
+        const rotulo = modo === 'primocode' ? c.warn('Primo Code') : c.brandDim('Chat');
+        console.log(c.dim(`  ⎿ ${ui.stripAnsi(rotulo)} · ${escolha.motivo}`));
+        refreshPrompt();
+    }
+
+    if (modo === 'primocode') {
         const plan = planWorkDir(userText);
         const r = await runAct(prompt, {
             server: state.config.server,
@@ -232,22 +262,93 @@ async function handleSlash(text) {
             const dir = cfg.createProjectDir(rest);
             state.workDir = dir;
             state.currentProject = path.basename(dir);
+            state.workDirOrigem = 'projeto';
             console.log(c.ok(`Projeto: ${state.currentProject}`) + c.muted(`  (${dir})`));
             refreshPrompt();
             break;
         }
 
+        // 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': {
+            if (!rest) {
+                const de = { cwd: 'a pasta onde você abriu o PrimoCode', '/dir': 'você escolheu com /dir', projeto: 'projeto criado pelo PrimoCode' };
+                console.log(`  ${c.white(shortPath(projectDir()))}`);
+                console.log(c.muted(`  ${de[state.workDirOrigem] || 'pasta atual do terminal'}`));
+                console.log(c.dim('  /dir <caminho> muda · /project <nome> cria uma nova em ~/primocode'));
+                break;
+            }
+
+            // ~ e caminho relativo resolvem contra a pasta ativa, não contra o
+            // cwd do processo: depois de um /dir, "src" é dentro dela.
+            const bruto = rest.replace(/^~(?=$|[/\\])/, os.homedir());
+            const alvo = path.resolve(projectDir(), bruto);
+
+            if (!fs.existsSync(alvo)) {
+                if (!(await confirm(`A pasta ${shortPath(alvo)} não existe. Criar?`))) {
+                    console.log(c.muted('  Nada mudou.'));
+                    break;
+                }
+                try { fs.mkdirSync(alvo, { recursive: true }); }
+                catch (e) { console.log(c.err(`  Não consegui criar: ${e.message}`)); break; }
+            } else if (!fs.statSync(alvo).isDirectory()) {
+                console.log(c.err(`  ${shortPath(alvo)} é um arquivo, não uma pasta.`));
+                break;
+            }
+
+            // A home e a raiz do disco são recusadas por padrão em qualquer
+            // lugar do código — aqui o pedido é explícito, então pergunta em vez
+            // de recusar, mas pergunta mesmo: é onde um write_file erra feio.
+            if (!isUsableCwd(alvo)) {
+                console.log(c.warn(`  ${shortPath(alvo)} é a sua home ou a raiz do disco.`));
+                if (!(await confirm('O agente pode criar e editar arquivos aí. Confirma?'))) {
+                    console.log(c.muted('  Nada mudou.'));
+                    break;
+                }
+            }
+
+            state.workDir = alvo;
+            state.currentProject = path.basename(alvo);
+            state.workDirOrigem = '/dir';
+            const quantos = (() => { try { return fs.readdirSync(alvo).length; } catch { return 0; } })();
+            console.log(c.ok(`  Trabalhando em ${shortPath(alvo)}`) + c.muted(`  (${quantos} ${quantos === 1 ? 'item' : 'itens'})`));
+            refreshPrompt();
+            break;
+        }
+
         case 'mode': {
             const m = rest.toLowerCase();
-            if (['primocode', 'chat'].includes(m)) { state.mode = m; console.log(c.ok(`Modo: ${m}`)); refreshPrompt(); }
-            else console.log(c.err('Uso: /mode primocode|chat'));
+            if (['primocode', 'chat', 'auto'].includes(m)) {
+                state.mode = m;
+                state.modoEfetivo = null;
+                cfg.saveConfig({ mode: m });
+                console.log(c.ok(`Modo: ${m}`) + (m === 'auto'
+                    ? c.muted('  — escolho por pedido: conversa vai pro chat, tarefa vai pro agente')
+                    : ''));
+                refreshPrompt();
+            } else console.log(c.err('Uso: /mode primocode|chat|auto'));
             break;
         }
 
         case 'model': {
             const m = rest.toLowerCase();
-            if (['main', 'fast'].includes(m)) { state.config.model = m; cfg.saveConfig({ model: m }); console.log(c.ok(`Modelo: ${m}`)); }
-            else console.log(c.err('Uso: /model main|fast'));
+            const nomes = {
+                top: 'Opus 5 — o mais capaz, e o mais caro por pedido',
+                main: 'Sonnet 5 — o padrão: capacidade de topo a 2,5x menos',
+                fast: 'Haiku 4.5 — respostas curtas e baratas',
+            };
+            if (nomes[m]) {
+                state.config.model = m;
+                cfg.saveConfig({ model: m });
+                console.log(c.ok(`Modelo: ${m}`) + c.muted(`  ${nomes[m]}`));
+            } else if (m.includes('/')) {
+                // ID literal do OpenRouter, para quem quer sair dos três.
+                state.config.model = m;
+                cfg.saveConfig({ model: m });
+                console.log(c.ok(`Modelo: ${m}`) + c.muted('  precisa aceitar tools para o modo primocode'));
+            } else console.log(c.err('Uso: /model top|main|fast (ou um ID do OpenRouter, ex: google/gemini-2.5-pro)'));
             break;
         }
 
@@ -388,8 +489,13 @@ async function main() {
     if (isUsableCwd(process.cwd())) {
         state.workDir = process.cwd();
         state.currentProject = path.basename(state.workDir);
+        state.workDirOrigem = 'cwd';
     }
 
+    // Modo guardado entre sessões. O padrão é auto: sem ele, um "oi" gasta o
+    // mesmo que uma refatoração.
+    state.mode = ['primocode', 'chat', 'auto'].includes(state.config.mode) ? state.config.mode : 'auto';
+
     const args = process.argv.slice(2);
 
     // Flags padrão de CLI — funcionam em qualquer máquina, úteis em scripts/CI.
@@ -398,7 +504,7 @@ async function main() {
         process.exit(0);
     }
     if (args[0] === '--help' || args[0] === '-h') {
-        console.log(welcomeBox(VERSION, null, { mascot: state.config.mascot, userName: state.config.userName }));
+        console.log(welcomeBox(VERSION, null, { mascot: state.config.mascot, userName: state.config.userName, modo: state.mode }));
         console.log(HELP);
         process.exit(0);
     }
@@ -431,6 +537,7 @@ async function main() {
     }
 
     console.log(welcomeBox(VERSION, state.workDir ? shortPath(state.workDir) : null, {
+        modo: state.mode,
         mascot: state.config.mascot,
         userName: state.config.userName,
     }));

package/lib/browser.js

@@ -3,7 +3,7 @@
 // mínimo escrito à mão em cima de 'net'/'tls'.
 //
 // Como funciona:
-//   1) launch() abre o Chrome do usuário com --remote-debugging-port=9222
+//   1) launch() abre o Chrome do usuário com --remote-debugging-port=3199
 //      e um --user-data-dir dedicado (~/.primocode/chrome-profile) — assim
 //      o usuário logado nesse profile persiste (login GitHub, Vercel, etc).
 //   2) attach() descobre a aba ativa em /json/list e abre um WebSocket CDP.
@@ -23,7 +23,8 @@ const crypto = require('crypto');
 const { spawn, execSync } = require('child_process');
 
 const PROFILE_DIR = path.join(os.homedir(), '.primocode', 'chrome-profile');
-const DEBUG_PORT = 9222;
+// Dentro da faixa 3100-3199 do ambiente local, para o start.sh cuidar dela.
+const DEBUG_PORT = Number(process.env.PRIMOCODE_CDP_PORT || 3199);
 
 // ---- Helpers ---------------------------------------------------
 function findChrome() {

package/lib/config.js

@@ -166,6 +166,8 @@ function loadConfig() {
         userName: file.userName || null,
         mascot: file.mascot || 'primo',
         theme: file.theme || 'primo',
+        // Modo escolhido dura entre sessões: quem liga o auto quer o auto amanhã.
+        mode: process.env.PRIMOCODE_MODE || file.mode || 'auto',
         rootDir: ROOT_DIR,
         _file: file,
     };
@@ -175,8 +177,8 @@ function saveConfig(partial) {
     ensureDir(CONFIG_DIR);
     const cur = (() => { try { return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')); } catch { return {}; } })();
     // Só persiste o que faz sentido guardar — nada de campos derivados.
-    const { server, model, token, autoApply, currentProject, userName, mascot, theme } = { ...cur, ...partial };
-    const next = { server, model, token, autoApply, currentProject, userName, mascot, theme };
+    const { server, model, token, autoApply, currentProject, userName, mascot, theme, mode } = { ...cur, ...partial };
+    const next = { server, model, token, autoApply, currentProject, userName, mascot, theme, mode };
     fs.writeFileSync(CONFIG_FILE, JSON.stringify(next, null, 2), 'utf8');
     return next;
 }

package/lib/modo.js

@@ -0,0 +1,70 @@
+/**
+ * Escolha automática de modo.
+ *
+ * O modo primocode manda o schema das 30 ferramentas em todo pedido — ~4.700
+ * tokens antes de você digitar a primeira letra. Um "oi" gasta o mesmo que uma
+ * refatoração, e num plano com teto diário isso é dinheiro jogado fora (foi
+ * assim que a cota de 100 mil tokens/dia acabou às 15h).
+ *
+ * O modo chat não manda schema nenhum. Então a regra é: só paga o preço das
+ * ferramentas quem vai usar ferramenta.
+ *
+ * A decisão é local e sem custo — nenhuma chamada ao modelo para descobrir a
+ * intenção, senão o remédio custaria como a doença. É um classificador de
+ * pistas, deliberadamente conservador: na dúvida, chat, porque errar para chat
+ * custa uma repetição do pedido, e errar para primocode custa tokens e pode
+ * escrever arquivo que ninguém pediu.
+ */
+
+'use strict';
+
+// Verbos de tarefa no imperativo e no infinitivo, como as pessoas falam de
+// verdade: "cria um site", "criar um site", "crie um site", "faz pra mim".
+const VERBOS = [
+    'cri[ae]r?', 'faz(er)?', 'fa[çc]a', 'escrev[ae]r?', 'ger[ae]r?', 'monta?r?',
+    'consert[ae]r?', 'corrig[ei]r?', 'arrum[ae]r?', 'ajust[ae]r?',
+    'rod[ae]r?', 'execut[ae]r?', 'instal[ae]r?', 'test[ae]r?',
+    'abr[ae]?i?r?', 'clon[ae]r?', 'baix[ae]r?', 'public[ao]r?',
+    'refator[ae]r?', 'apag[ae]r?', 'delet[ae]r?', 'remov[ae]r?', 'mov[ae]r?',
+    'adicion[ae]r?', 'acrescent[ae]r?', 'mud[ae]r?', 'alter[ae]r?', 'atualiz[ae]r?',
+    'implement[ae]r?', 'l[eê]i?a?r?', 'procur[ae]r?', 'busc[ae]r?', 'encontr[ae]r?',
+    'renome[ai]r?', 'copi[ae]r?', 'commit[ae]r?', 'deploy',
+    'sobe', 'suba', 'subir', 'empurr[ae]r?', 'mergea?r?',
+];
+const RE_VERBO = new RegExp(`(^|\\s)(${VERBOS.join('|')})\\b`, 'i');
+
+// Coisas que só existem quando há trabalho de arquivo/máquina envolvido.
+const RE_ARTEFATO = /\.(js|ts|tsx|jsx|html|css|json|md|py|sh|yml|yaml|txt|csv|env)\b|[\w-]+\/[\w-]/i;
+const RE_FERRAMENTA = /\b(navegador|browser|desktop|terminal|shell|git|npm|node|deploy|servidor|localhost|porta \d+|screenshot|print da tela)\b/i;
+const RE_PASTA = /\b(pasta|diret[óo]rio|arquivo|arquivos|reposit[óo]rio|repo|projeto)\b/i;
+
+// Conversa: cumprimento, agradecimento, pergunta conceitual.
+const RE_SAUDACAO = /^\s*(oi+|ol[áa]|e?a[íi]|bom dia|boa tarde|boa noite|tudo bem|beleza|valeu|obrigad[oa]|brigad[oa]|tchau|até|ok|okay|entendi|legal|show|massa)\b[\s!.?]*$/i;
+const RE_CONCEITUAL = /\b(o que [ée]|o q [ée]|que [ée]|qual (a|o|as|os)?\s*(diferen[çc]a|melhor|sentido)|por qu[êe]|pra que serve|para que serve|como funciona|como (fa[çc]o|posso|se faz|fazer)|explica|explique|me explica|significa|vale a pena|devo usar|qual usar|prefere)\b/i;
+
+/**
+ * Decide o modo de um pedido.
+ * Devolve { modo: 'primocode'|'chat', motivo: string }.
+ * O motivo existe para o CLI mostrar por que escolheu — automode que decide em
+ * silêncio parece defeito na primeira vez que erra.
+ */
+function escolherModo(texto) {
+    const t = String(texto || '').trim();
+    if (!t) return { modo: 'chat', motivo: 'nada a fazer' };
+
+    // Cumprimento é chat mesmo que traga um verbo depois ("oi, tudo bem?").
+    if (RE_SAUDACAO.test(t)) return { modo: 'chat', motivo: 'cumprimento' };
+
+    // Pergunta conceitual ganha do verbo: "como faço para criar um site?" é
+    // dúvida, não pedido de execução.
+    if (RE_CONCEITUAL.test(t)) return { modo: 'chat', motivo: 'pergunta conceitual' };
+
+    if (RE_ARTEFATO.test(t)) return { modo: 'primocode', motivo: 'cita arquivo ou caminho' };
+    if (RE_VERBO.test(t)) return { modo: 'primocode', motivo: 'pede uma ação' };
+    if (RE_FERRAMENTA.test(t)) return { modo: 'primocode', motivo: 'menciona ferramenta ou máquina' };
+    if (RE_PASTA.test(t)) return { modo: 'primocode', motivo: 'fala de arquivo ou projeto' };
+
+    return { modo: 'chat', motivo: 'sem pista de tarefa' };
+}
+
+module.exports = { escolherModo };

package/lib/ui.js

@@ -6,17 +6,33 @@
 
 const readline = require('readline');
 
+// ── Paleta ───────────────────────────────────────────────────────────────
+// Vem do design system do produto (product-plan/design-system): primária cyan,
+// secundária amber, neutra slate, e rose para falha de ação. Os números são o
+// vizinho mais próximo de cada degrau do Tailwind no cubo de 256 cores do
+// terminal, calculado com peso perceptual — não escolhido a olho.
+//
+//   brand    cyan-400   #22d3ee → 45     o que foi apurado, confirmado
+//   brandDim cyan-600   #0891b2 → 31     a mesma cor recuando
+//   white    slate-200  #e2e8f0 → 254    texto
+//   muted    slate-400  #94a3b8 → 247    texto secundário
+//   dim      slate-500  #64748b → 243    borda, apoio
+//   warn     amber-400  #fbbf24 → 214    aviso que não é falha
+//   err      rose-400   #fb7185 → 204    falha de ação
+//
+// O terminal é fundo escuro, então os degraus usados são os da coluna `dark:`
+// da tabela de contraste validada do design system.
 const PALETTE = {
-    brand:      '\x1b[38;5;183m',
-    brandDim:   '\x1b[38;5;146m',
-    white:      '\x1b[38;5;253m',
-    muted:      '\x1b[38;5;245m',
-    dim:        '\x1b[38;5;240m',
-    ok:         '\x1b[38;5;114m',
-    warn:       '\x1b[38;5;180m',
-    err:        '\x1b[38;5;174m',
-    magenta:    '\x1b[38;5;176m',
-    cyan:       '\x1b[38;5;152m',
+    brand:      '\x1b[38;5;45m',
+    brandDim:   '\x1b[38;5;31m',
+    white:      '\x1b[38;5;254m',
+    muted:      '\x1b[38;5;247m',
+    dim:        '\x1b[38;5;243m',
+    ok:         '\x1b[38;5;45m',
+    warn:       '\x1b[38;5;214m',
+    err:        '\x1b[38;5;204m',
+    magenta:    '\x1b[38;5;214m',
+    cyan:       '\x1b[38;5;45m',
     bold:       '\x1b[1m',
     reset:      '\x1b[0m',
 };
@@ -37,63 +53,185 @@ const c = {
 };
 
 // ── Mascotes ─────────────────────────────────────────────────────────────
-// Primo, o mascote — expressivo e personalizável. Fones de "coach", antena
-// que brilha, olhos acesos. Escolha o estilo com /mascot.
-// Sem emoji — só formas geométricas de largura 1, alinhadas em qualquer
-// terminal monospace (Windows, Linux e Mac). Cada linha tem 9 colunas.
+// O mascote é um bloco fixo de 3 linhas × 9 colunas. Tamanho fixo porque ele
+// não fica sozinho: as três linhas de identidade do cabeçalho (nome, saudação,
+// pasta) sentam ao lado dele, uma por linha do desenho. Mudar a altura
+// desalinha o cabeçalho inteiro.
+//
+// Só glifos de bloco (U+2580–U+259F): largura 1 garantida em qualquer terminal
+// monospace, sem emoji e sem depender de fonte instalada.
+//
+// A família compartilha corpo e pés — o que muda é a linha de cima. É de
+// propósito: são o mesmo bicho de orelhas diferentes, não três desenhos de
+// autores diferentes. Troque com /mascot.
+
+const ART_W = 9;    // colunas de cada linha do desenho
+const ART_H = 3;    // linhas — igual ao número de linhas de identidade
+
+const CORPO = '▝▜█████▛▘';
+const PES   = '  ▘▘ ▝▝  ';
+
 const MASCOTS = {
-    // Padrão: robô-coach — antena que brilha, headset lateral, olhar vivo,
-    // sorriso e pezinhos. Limpo e simétrico, 11 colunas por linha.
-    primo: () => [
-        `    ${c.magenta('╭')}${c.magenta('◠')}${c.magenta('╮')}    `,
-        `  ${c.brand('╭─┴─┴─╮')}  `,
-        ` ${c.cyan('◖')}${c.brand('┫')} ${c.cyan('●')} ${c.cyan('●')} ${c.brand('┣')}${c.cyan('◗')} `,
-        `  ${c.brand('┃')}  ${c.magenta('‿')}  ${c.brand('┃')}  `,
-        `  ${c.brand('╰──┬──╯')}  `,
-        `   ${c.brandDim('╰─┴─╯')}   `,
-    ],
-    // Raposa — carismática e simétrica.
-    fox: () => [
-        ` ${c.warn('╱╲')}   ${c.warn('╱╲')} `,
-        `${c.warn('╱')}  ${c.warn('╲_╱')}  ${c.warn('╲')}`,
-        `${c.warn('▏')} ${c.cyan('◕')}   ${c.cyan('◕')} ${c.warn('▕')}`,
-        `${c.warn('╲')}   ${c.magenta('▾')}   ${c.warn('╱')}`,
-        ` ${c.warn('╲__')}${c.magenta('ᵕ')}${c.warn('__╱')} `,
-    ],
-    // Gato — minimalista e fofo.
-    cat: () => [
-        ` ${c.brand('╱╲_╱╲')}   `,
-        `${c.brand('│')} ${c.cyan('◕')} ${c.magenta('◡')} ${c.cyan('◕')} ${c.brand('│')}`,
-        ` ${c.brand('╲')}  ${c.magenta('▿')}  ${c.brand('╱')} `,
-        `  ${c.brand('╲───╯')}  `,
-    ],
+    // Padrão: o Primo — cabeça cheia, ombros marcados, dois pezinhos.
+    primo: { topo: ' ▐▛███▜▌ ', full: 'brand',  edge: 'brandDim' },
+    // Raposa — orelhas largas, abertas para fora. Na secundária do sistema.
+    fox:   { topo: ' ▛▀   ▀▜ ', full: 'warn',   edge: 'dim' },
+    // Gato — orelhas curtas e juntas. Primária recuada, para não repetir o Primo.
+    cat:   { topo: ' ▛▘   ▝▜ ', full: 'brandDim', edge: 'dim' },
 };
 
+// Bloco cheio na cor viva, contorno na apagada: dá volume ao desenho sem
+// precisar de gradiente nem de cor de fundo.
+function shade(line, full, edge) {
+    let out = '';
+    for (const ch of line) {
+        if (ch === ' ') out += ch;
+        else if (ch === '█' || ch === '▀') out += c[full](ch);
+        else out += c[edge](ch);
+    }
+    return out;
+}
+
 function mascot(style) {
-    const fn = MASCOTS[style] || MASCOTS.primo;
-    return fn();
+    const m = MASCOTS[style] || MASCOTS.primo;
+    return [m.topo, CORPO, PES].map((l) => shade(l, m.full, m.edge));
 }
 
+// ── Medição de largura ───────────────────────────────────────────────────
+// Alinhar caixa em terminal exige contar colunas VISÍVEIS: os códigos ANSI
+// não ocupam espaço, e emoji/CJK ocupam duas colunas. Usar .length desalinha.
+
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+
+const stripAnsi = (s) => String(s).replace(ANSI_RE, '');
+
+function charWidth(cp) {
+    if (cp === 0x200d) return 0;                       // zero-width joiner
+    if (cp >= 0xfe00 && cp <= 0xfe0f) return 0;        // seletores de variação
+    if (cp >= 0x0300 && cp <= 0x036f) return 0;        // acentos combinantes
+    if (
+        (cp >= 0x1100 && cp <= 0x115f) ||
+        (cp >= 0x2e80 && cp <= 0xa4cf) ||
+        (cp >= 0xac00 && cp <= 0xd7a3) ||
+        (cp >= 0xf900 && cp <= 0xfaff) ||
+        (cp >= 0xfe30 && cp <= 0xfe6f) ||
+        (cp >= 0xff00 && cp <= 0xff60) ||
+        (cp >= 0xffe0 && cp <= 0xffe6) ||
+        (cp >= 0x1f300 && cp <= 0x1f64f) ||            // emoji
+        (cp >= 0x1f900 && cp <= 0x1f9ff) ||
+        (cp >= 0x1f680 && cp <= 0x1f6ff)
+    ) return 2;
+    return 1;
+}
+
+function visibleWidth(s) {
+    let w = 0;
+    for (const ch of stripAnsi(s)) w += charWidth(ch.codePointAt(0));
+    return w;
+}
+
+// Corta preservando os códigos ANSI (senão a cor "vaza" para o resto da linha).
+function truncate(s, max) {
+    if (visibleWidth(s) <= max) return s;
+    const str = String(s);
+    let out = '', w = 0, i = 0;
+    while (i < str.length) {
+        ANSI_RE.lastIndex = i;
+        const m = ANSI_RE.exec(str);
+        if (m && m.index === i) { out += m[0]; i += m[0].length; continue; }
+        const ch = String.fromCodePoint(str.codePointAt(i));
+        const cw = charWidth(ch.codePointAt(0));
+        if (w + cw > max - 1) break;
+        out += ch; w += cw; i += ch.length;
+    }
+    return out + PALETTE.reset + PALETTE.dim + '…' + PALETTE.reset;
+}
+
+const padRight = (s, w) => s + ' '.repeat(Math.max(0, w - visibleWidth(s)));
+
+// ── Conteúdo do cabeçalho ────────────────────────────────────────────────
+// Editar aqui é o suficiente para mudar o que aparece na abertura.
+
+const NOME = 'Primo Code';
+
+const TIPS = [
+    'Peça um app novo, ou aponte para um repositório e mande clonar',
+    '/dir <pasta> para ele trabalhar numa pasta que já é sua',
+    '/help lista tudo · /mode troca o modo · /status confere a API',
+];
+
+const NEWS = [
+    'Modo auto: conversa vai pro chat, tarefa vai pro agente — gasta menos',
+    '/dir aponta para qualquer pasta sua, sem criar projeto novo',
+    'Corrigido o 413 que fazia todo pedido do modo primocode falhar',
+];
+
+// ── Cabeçalho ────────────────────────────────────────────────────────────
+// Duas faixas: identidade (mascote + 3 linhas) e orientação (dicas,
+// novidades, modos). Sem caixa — moldura em terminal estreito quebra, e o
+// alinhamento do desenho já dá a borda esquerda de graça.
+
 function welcomeBox(version, contexto, opts = {}) {
-    const { mascot: style, userName } = opts;
+    const { mascot: style, userName, modo } = opts;
     const art = mascot(style);
-    const saudacao = userName ? `${c.white('Olá, ')}${c.bold(c.brand(userName))}` : c.muted('agente de engenharia');
-    const side = [
-        '',
-        `${c.bold(c.brand('P R I M O C O D E'))}`,
-        `${saudacao}  ${c.dim('v' + version)}`,
-        contexto ? c.brandDim('▸ ' + contexto) : c.dim('nenhuma pasta ativa'),
-        c.dim('cria arquivos · roda comandos · controla navegador e desktop'),
-        '',
+    const cols = Math.max(32, Math.min(process.stdout.columns || 100, 120));
+
+    const saudacao = userName
+        ? `${c.muted('Bem-vindo de volta, ')}${c.bold(c.white(userName))}`
+        : c.muted('Bem-vindo de volta');
+
+    // As três linhas de identidade — uma por linha do mascote, na ordem em que
+    // se lê: quem é, quem chegou, onde estamos.
+    const ident = [
+        `${c.bold(c.brand(NOME))} ${c.dim('v' + version)}`,
+        saudacao,
+        contexto ? c.brandDim(contexto) : c.dim('nenhuma pasta ativa'),
     ];
-    const rows = art.map((linha, i) => `  ${linha}   ${side[i] || ''}`);
-    return [
-        '',
-        ...rows,
-        '',
-        `  ${c.magenta('●')} ${c.muted('Primo Code')}   ${c.brand('●')} ${c.muted('Chat')}   ${c.dim('/help')} ${c.dim('para tudo')}`,
-        '',
-    ].join('\n');
+
+    const out = [''];
+
+    // Terminal estreito: o texto ao lado não caberia, então empilha embaixo.
+    const largo = cols >= ART_W + 2 + 28;
+    if (largo) {
+        const textW = cols - ART_W - 2;
+        for (let i = 0; i < ART_H; i++) {
+            out.push(art[i] + '  ' + truncate(ident[i] || '', textW));
+        }
+    } else {
+        out.push(...art);
+        out.push('');
+        out.push(...ident.map((l) => truncate(l, cols)));
+    }
+
+    // Cada item ocupa 5 colunas de prefixo ("  1. "), então o texto tem cols-5.
+    // Estourar por uma coluna quebra a linha e o cabeçalho parece defeito.
+    const secao = (titulo, itens, marca) => {
+        out.push('');
+        out.push('  ' + c.bold(c.white(titulo)));
+        itens.forEach((t, i) => {
+            out.push(`  ${c.dim(marca(i))} ${truncate(c.muted(t), cols - 5)}`);
+        });
+    };
+
+    secao('Dicas para começar', TIPS, (i) => `${i + 1}.`);
+    secao('Novidades', NEWS, () => ' ·');
+
+    // Rodapé: em que modo você está agora, não a lista dos que existem. Em
+    // terminal apertado a dica do /help sai antes de empurrar a linha para
+    // baixo — cabeçalho que quebra parece defeito.
+    // Primária para o modo ativo, secundária quando ele tem poder de escrever:
+    // é a mesma leitura de "apurado" × "aviso que não é falha" do sistema.
+    const rotulos = {
+        auto: `${c.brand('●')} ${c.muted('Auto')}${c.dim(' — conversa vai pro chat, tarefa vai pro agente')}`,
+        primocode: `${c.warn('●')} ${c.muted('Primo Code')}${c.dim(' — agente completo, com ferramentas')}`,
+        chat: `${c.brandDim('●')} ${c.muted('Chat')}${c.dim(' — conversa pura, sem ferramentas')}`,
+    };
+    const linhaModo = '  ' + (rotulos[modo] || rotulos.auto);
+    out.push('');
+    out.push(visibleWidth(linhaModo) <= cols ? linhaModo : `  ${c.ok('●')} ${c.muted(modo || 'auto')}`);
+    if (cols >= 44) out.push(`  ${c.dim('/help para tudo · /mode troca o modo')}`);
+    out.push('');
+    return out.join('\n');
 }
 
 class Spinner {
@@ -167,7 +305,7 @@ function actionHeader(name, args) {
     return `  ${c.dim('⎿')} ${c.brand(label)}${argStr ? ' '+c.muted(argStr) : ''}`;
 }
 
-// Transforma erro cru (JSON do Groq, código HTTP, erro de rede) numa frase
+// Transforma erro cru (JSON do provedor, código HTTP, erro de rede) numa frase
 // humana. O usuário nunca deveria ver um paredão de JSON.
 function friendlyError(raw) {
     const s = String(raw && raw.message ? raw.message : raw || '').trim();
@@ -183,10 +321,48 @@ function friendlyError(raw) {
         }
     } catch {}
 
-    if (/rate.?limit|tokens per minute|tpm|request too large|too many requests|\b429\b|\b413\b/i.test(low)) {
-        return '⏳ O servidor está no limite de uso agora. Espere alguns segundos e tente de novo.';
+    // Falta de saldo: nem bug, nem espera. O provedor diz quanto a conta paga,
+    // e o servidor já refaz o pedido com esse teto — se ainda assim chegou aqui,
+    // é porque nem o mínimo cabe.
+    if (/can only afford|requires more credits|\b402\b/i.test(low)) {
+        const q = s.match(/afford\s+(\d+)/i);
+        return '💳 A conta do OpenRouter não tem crédito para uma resposta deste tamanho'
+            + (q ? ` (dá para ${q[1]} tokens)` : '')
+            + '. Adicione crédito em openrouter.ai/settings/credits, ou use /model fast'
+            + ' para pedidos menores.';
+    }
+    // Ordem importa: "grande demais" e "muitos pedidos" chegam os dois como
+    // rate_limit_exceeded, e a saída é oposta. Tamanho não se resolve
+    // esperando — o pedido vai estourar igual daqui a uma hora.
+    const porTamanho = /request too large|tokens per minute|\btpm\b|reduce your message size|\b413\b/i.test(low)
+        || /conversa passou do teto/i.test(low);
+    if (porTamanho) {
+        const nums = s.match(/Limit\s+(\d+),\s*Requested\s+(\d+)/i);
+        if (/conversa passou do teto/i.test(low)) return `📏 ${inner.replace(/\s+/g, ' ').trim()}`;
+        return '📏 Este pedido é maior que o teto do plano'
+            + (nums ? ` (${nums[2]} tokens contra um limite de ${nums[1]} por minuto)` : '')
+            + '. Esperar não resolve: use /clear para encurtar a conversa, ou divida o pedido em partes menores.';
+    }
+    // Cota do dia estourada. Nada a fazer no código, mas o provedor diz quanto
+    // falta para liberar — jogar isso fora e escrever "alguns instantes" é
+    // mandar o usuário tentar de novo em vão por uma hora e meia.
+    if (/tokens per day|\btpd\b/i.test(low)) {
+        // A classe [0-9hms.] engole o ponto final da frase do provedor, então tira
+        // a pontuação antes de arredondar os milissegundos fora.
+        const bruto = (s.match(/try again in ([0-9hms.]+)/i) || [])[1];
+        const quando = bruto && bruto.replace(/\.+$/, '').replace(/\.\d+s$/, 's');
+        const uso = s.match(/Limit\s+(\d+),\s*Used\s+(\d+)/i);
+        return '📅 A cota de tokens do dia acabou'
+            + (uso ? ` (${uso[2]} de ${uso[1]} tokens)` : '')
+            + (quando ? `, libera em ${quando}` : '')
+            + '. Enquanto isso o /mode chat gasta bem menos por pergunta.';
+    }
+    if (/rate.?limit|too many requests|\b429\b/i.test(low)) {
+        return '⏳ Muitos pedidos em pouco tempo. Espere alguns instantes e tente de novo.';
     }
-    if (/\b401\b|unauthorized|token/i.test(low)) {
+    // "token" solto não serve de pista: a mensagem de TPM tem a palavra e não
+    // tem nada a ver com autenticação. Exige o código ou a frase inteira.
+    if (/\b401\b|unauthorized|forbidden|token (inv[aá]lido|ausente|expirado)|invalid token|missing token/i.test(low)) {
         return '🔒 Este servidor pede um token. Configure PRIMOCODE_TOKEN ou "token" em ~/.primocode/config.json.';
     }
     if (/econnrefused|enotfound|etimedout|timeout|socket hang up|network|getaddrinfo|econnreset/i.test(low)) {
@@ -234,4 +410,4 @@ function askYesNo(question) {
     });
 }
 
-module.exports = { c, mascot, welcomeBox, Spinner, ProgressBar, actionHeader, toolLine, toolResult, fmtBytes, renderMarkdown, askYesNo, friendlyError };
+module.exports = { c, mascot, welcomeBox, Spinner, ProgressBar, actionHeader, toolLine, toolResult, fmtBytes, renderMarkdown, askYesNo, friendlyError, visibleWidth, stripAnsi, truncate, padRight };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "7.4.1",
+  "version": "7.7.0",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Modo primocode cria arquivos, controla o desktop e navegador. Modo chat é conversa pura.",
   "main": "bin/primocode.js",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "start": "node bin/primocode.js",
-    "test": "node test/tools.test.js"
+    "test": "node test/tools.test.js && node test/ui.test.js && node test/modo.test.js"
   },
   "engines": {
     "node": ">=18.17.0"