primocode 7.5.0 → 7.8.0

package/README.md

@@ -1,13 +1,17 @@
-# PrimoCode v7.5.0
+# PrimoCode v7.8.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.
 
+**Grátis, sem chave de API sua e sem teto de gasto.** Os modelos são os grátis do
+OpenRouter, e cada apelido (`top`/`main`/`fast`) é uma **corrente**: se um modelo
+está no limite de pedidos, o próximo atende. Você não vê o erro, e não paga nada.
+
 ```
- ▐▛███▜▌   Primo Code v7.5.0
+ ▐▛███▜▌   Primo Code v7.8.0
 ▝▜█████▛▘  Bem-vindo de volta, Joel
-  ▘▘ ▝▝    ~/projetos/jogo-de-carro
+  ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```
 
 Personalize o mascote (`primo`, `fox`, `cat`) e o nome com que ele te chama —
@@ -23,7 +27,7 @@ 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.**
 
@@ -93,10 +97,58 @@ 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
+
+**Por padrão, sempre `~/primocode`** — não importa de onde você abriu o
+PrimoCode. Antes ele adotava a pasta atual do terminal, e o mesmo "crie um site"
+caía num lugar diferente a cada vez; quem digitava não tinha como saber onde ia
+parar. Agora o começo é sempre o mesmo, e o cabeçalho avisa em amber qual é.
+
+Para trabalhar em outra pasta, três caminhos:
+
+| Situação | Pasta de trabalho |
+|---|---|
+| **Falar o nome dela no pedido** — "crie o index.html na pasta loja-do-joao" | ele procura no seu computador (`~/primocode`, Downloads, Documentos, Desktop, projetos…) e muda sozinho |
+| `/dir ~/meus-projetos/site` | a pasta que **você** escolher, onde ela estiver |
+| `/project loja` | cria `~/primocode/loja`, com memória própria |
+
+A busca por nome é conservadora de propósito: se achar duas pastas com o mesmo
+nome, ela **lista e espera** o `/dir` em vez de escolher — heurística não deve
+decidir onde um agente escreve arquivo. E nome de arquivo nunca é confundido com
+pasta: "edita o `src/app.js`" não muda pasta nenhuma.
+
+**Pasta de projeto nova só nasce quando ele vai mexer em arquivo.** Pedir "abre o
+Chrome" não cria projeto — antes criava, e `~/primocode` enchia de pasta vazia.
+
+`/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
 
@@ -205,11 +257,13 @@ 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` | **Todos grátis.** top = o mais capaz (550B, 1M de contexto), main = agente de código (padrão), fast = o mais rápido. Aceita qualquer ID do OpenRouter |
 | `/attach <arquivo>` | Anexa arquivo ao próximo pedido |
 | `/detach` · `/files` | Remove / lista anexos |
+| `/tudo` | Lista as 30 ferramentas que ele sabe usar, por grupo |
 | `/tree [n]` | Árvore do projeto atual |
 | `/read <arquivo>` | Mostra um arquivo do projeto |
 | `/run <comando>` | Executa no shell, dentro da pasta do projeto |
@@ -252,7 +306,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,30 +15,42 @@ 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');
 const { runAct } = require('../lib/act');
+const pasta = require('../lib/pasta');
+const catalogo = require('../lib/catalogo');
+
+// A pasta de onde o comando foi dado. Não é mais onde ele trabalha (o padrão é
+// ~/primocode), mas continua servindo de ponto de partida para achar pasta que
+// o usuário mencionar por nome relativo.
+const CWD_INICIAL = process.cwd();
 
 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, // 'padrao' | '/dir' | 'detectada' | '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('/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
@@ -52,14 +64,30 @@ ${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('Sempre em')} ${c.warn('~/primocode')}${c.muted(', não importa de onde você abriu o PrimoCode.')}
+  ${c.muted('Para outra pasta, dois caminhos:')}
+  ${c.muted('  ·')} ${c.brand('/dir <caminho>')} ${c.muted('aponta para qualquer pasta sua')}
+  ${c.muted('  ·')} ${c.muted('falar o nome dela no pedido — ele procura no seu computador')}
+  ${c.dim('Pasta de projeto nova só nasce quando ele vai mexer em arquivo.')}
 `;
 
 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('❯')} `;
@@ -103,32 +131,41 @@ function deriveProjectName(text) {
     return picked || 'projeto';
 }
 
-// Como o Claude Code: se você abriu o PrimoCode dentro de uma pasta de
-// trabalho, é ali que ele trabalha. Home e raiz de disco não contam — ninguém
-// quer um agente soltando arquivo no meio de C:\Users\você.
-function isUsableCwd(dir) {
+// Pasta em que é seguro deixar um agente criar e editar arquivo. A home e a raiz
+// do disco não contam — ninguém quer um agente soltando arquivo no meio de
+// C:\Users\você. O ~/primocode ERA recusado aqui, de quando a pasta atual do
+// terminal era adotada; hoje ele é o padrão, então recusá-lo não faz sentido.
+function pastaSegura(dir) {
     const home = os.homedir();
     const resolved = path.resolve(dir);
     if (resolved === path.resolve(home)) return false;
     if (resolved === path.parse(resolved).root) return false;
-    if (resolved.startsWith(path.join(home, 'primocode'))) return false;
     return true;
 }
 
-// Escolhe onde trabalhar SEM criar nada. A pasta só é criada de verdade em
-// createPendingProject(), quando o agente for mexer em arquivo.
+// Escolhe onde trabalhar SEM criar nada.
+//
+// Três casos, nesta ordem:
+//   1. pasta escolhida a dedo (/dir, ou detectada no pedido) — manda, sempre.
+//   2. projeto que JÁ existe e parece com o pedido — entra nele agora, senão a
+//      memory.md dele não carrega neste turno.
+//   3. projeto novo — fica PENDENTE: age em ~/primocode e só cria a pasta se o
+//      agente for mexer em arquivo. Pedir para abrir o Chrome não cria projeto.
 function planWorkDir(userText) {
-    if (state.workDir) return { dir: state.workDir, pending: false };
-    const proposed = deriveProjectName(userText);
-    const similar = cfg.findSimilarProject(proposed);
-    const name = similar ? similar.name : proposed;
-    return { dir: cfg.getProjectDir(name), pending: true, name, similar: !!similar };
+    if (['/dir', 'detectada', 'projeto'].includes(state.workDirOrigem)) {
+        return { dir: state.workDir, pending: false, name: state.currentProject };
+    }
+    const proposto = deriveProjectName(userText);
+    const parecido = cfg.findSimilarProject(proposto);
+    if (parecido) return { dir: parecido.dir, pending: false, name: parecido.name, similar: true };
+    return { dir: cfg.ROOT_DIR, projeto: cfg.getProjectDir(proposto), pending: true, name: proposto };
 }
 
 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();
@@ -141,6 +178,63 @@ function projectDir() {
 
 // ── Envio ──────────────────────────────────────────────────────────────
 
+/**
+ * Falou de uma pasta? Ele procura no computador e muda para ela.
+ *
+ * Conservador de propósito: só troca quando acha UMA pasta. Com mais de uma,
+ * lista e espera o /dir — heurística não deve escolher onde o agente escreve.
+ */
+function talvezTrocarDePasta(userText) {
+    const candidato = pasta.detectarPasta(userText);
+    if (!candidato) return;
+
+    const achado = pasta.resolverPasta(candidato, { raiz: cfg.ROOT_DIR, cwd: CWD_INICIAL });
+    if (!achado) return;   // não existe no disco: segue onde está, sem barulho
+
+    if (achado.ambiguo) {
+        console.log(c.warn(`  Achei ${achado.ambiguo.length} pastas chamadas "${candidato}":`));
+        achado.ambiguo.forEach((a) => console.log(`   ${c.dim('·')} ${c.white(shortPath(a.caminho))}`));
+        console.log(c.dim('  Escolha com /dir <caminho>.'));
+        return;
+    }
+    if (path.resolve(achado.caminho) === path.resolve(projectDir())) return;  // já está lá
+    if (!pastaSegura(achado.caminho)) return;   // home ou raiz: só por /dir explícito
+
+    state.workDir = achado.caminho;
+    state.currentProject = path.basename(achado.caminho);
+    state.workDirOrigem = 'detectada';
+    console.log(c.ok(`  Trabalhando em ${shortPath(achado.caminho)}`) + c.dim(`  (você falou "${candidato}")`));
+    refreshPrompt();
+}
+
+/**
+ * Decide, de uma vez, onde este pedido vai trabalhar.
+ *
+ * ESTA É A ÚNICA função que decide pasta. Existiam duas cópias — uma no
+ * sendPrompt e outra no modo um-tiro — e a do um-tiro ficou sem a detecção: pedir
+ * `primocode "crie x na pasta loja"` ignorava a pasta e criava projeto novo.
+ * Duas cópias da mesma decisão significam que uma delas está errada.
+ */
+function prepararPasta(userText) {
+    // A pasta é decidida ANTES de o agente começar. Trocar no meio faria as
+    // primeiras tools agirem num lugar e as seguintes em outro.
+    talvezTrocarDePasta(userText);
+
+    const plan = planWorkDir(userText);
+
+    // Projeto que já existe: entra nele AGORA. Se deixasse para depois, o
+    // buildMemoryContext deste turno leria a pasta errada e a memória do projeto
+    // não carregaria.
+    if (!plan.pending && path.resolve(plan.dir) !== path.resolve(projectDir())) {
+        state.workDir = plan.dir;
+        state.currentProject = plan.name || path.basename(plan.dir);
+        state.workDirOrigem = 'projeto';
+        console.log(c.ok(`  Continuando em ${state.currentProject}`) + c.muted(`  (${shortPath(plan.dir)})`));
+        refreshPrompt();
+    }
+    return plan;
+}
+
 async function sendPrompt(userText) {
     let prompt = userText;
     if (state.attachedFiles.length) {
@@ -148,16 +242,30 @@ async function sendPrompt(userText) {
         prompt = parts.join('\n\n') + '\n\n' + userText;
     }
 
-    if (state.mode === 'primocode') {
-        const plan = planWorkDir(userText);
+    // 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 = prepararPasta(userText);
+
         const r = await runAct(prompt, {
             server: state.config.server,
             model: state.config.model,
             token: state.config.token,
             history: state.history,
             projectDir: plan.dir,
-            projectName: plan.pending ? plan.name : state.currentProject,
-            // Só chamado se o agente for mesmo mexer em arquivo.
+            projectName: plan.name || state.currentProject,
+            // Só chamado se o agente for mesmo MEXER EM ARQUIVO — abrir o Chrome
+            // não é motivo para criar pasta de projeto.
             ensureWorkDir: plan.pending ? () => createPendingProject(plan) : null,
         });
         state.history.push({ role: 'user', content: userText });
@@ -232,22 +340,99 @@ 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 = {
+                    padrao: 'a pasta padrão do PrimoCode',
+                    '/dir': 'você escolheu com /dir',
+                    detectada: 'você falou dela no pedido',
+                    projeto: 'projeto do 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 (!pastaSegura(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'));
+            // Todos grátis. A lista viva de cada corrente está no /status.
+            const nomes = {
+                top: 'o mais capaz — 550B, 1 milhão de tokens de contexto',
+                main: 'o padrão — agente de código, o melhor em tarefa de terminal',
+                fast: 'o mais rápido — resposta curta, alta vazão',
+            };
+            if (nomes[m]) {
+                state.config.model = m;
+                cfg.saveConfig({ model: m });
+                console.log(c.ok(`Modelo: ${m}`) + c.muted(`  ${nomes[m]}`) + c.dim('  · grátis'));
+            } 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;
         }
 
@@ -269,6 +454,25 @@ async function handleSlash(text) {
             else state.attachedFiles.forEach((f) => console.log(`  ${c.brand(f.path)} ${c.muted(tools.fmtBytes(f.content.length))}`));
             break;
 
+        // 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': {
+            const cols = Math.max(40, Math.min(process.stdout.columns || 90, 110));
+            console.log('');
+            for (const g of catalogo.GRUPOS) {
+                console.log('  ' + c.bold(c.white(g.nome)) + ' ' + ui.truncate(c.dim('— ' + g.resumo), cols - 4 - ui.visibleWidth(g.nome)));
+                for (const i of g.itens) {
+                    console.log('    ' + c.brand(ui.padRight(i.tool, 21)) + ui.truncate(c.muted(i.faz), cols - 26));
+                }
+                console.log('');
+            }
+            console.log(c.dim(`  ${catalogo.TODAS.length} ferramentas. Você não precisa saber nenhum desses nomes — peça em português.`));
+            break;
+        }
+
         case 'tree': console.log(tools.treeDir(projectDir(), parseInt(rest, 10) || 2)); break;
 
         case 'read': {
@@ -350,7 +554,13 @@ async function handleSlash(text) {
                 sp.stop();
                 console.log(c.ok(`Servidor: ${h.status || 'ok'}`));
                 if (h.version) console.log(c.muted(`  Versão: ${h.version}`));
-                if (h.model) console.log(c.muted(`  Modelo: ${h.model}`));
+                if (h.model) console.log(c.muted(`  Modelo: ${h.model}`) + (h.gratis ? c.dim('  · grátis') : ''));
+                // A corrente inteira: é o que garante que um modelo no limite não
+                // vira erro na sua tela.
+                if (h.correntes && h.correntes[state.config.model || 'main']) {
+                    const fila = h.correntes[state.config.model] || h.correntes.main;
+                    console.log(c.dim(`  Reservas: ${fila.length - 1}`));
+                }
             } catch (e) { sp.stop(); console.log(c.err(`Indisponível: ${e.message}`)); }
             break;
         }
@@ -384,11 +594,16 @@ function shortPath(p) {
 async function main() {
     cfg.ensureStructure();
 
-    // Abriu dentro de uma pasta de trabalho? Então é ali que ele atua.
-    if (isUsableCwd(process.cwd())) {
-        state.workDir = process.cwd();
-        state.currentProject = path.basename(state.workDir);
-    }
+    // Padrão fixo: ~/primocode, não importa de onde o comando foi dado. Antes ele
+    // adotava a pasta atual do terminal, e o mesmo "crie um site" caía num lugar
+    // diferente a cada vez — quem digitava não tinha como saber onde ia parar.
+    state.workDir = cfg.ROOT_DIR;
+    state.currentProject = null;
+    state.workDirOrigem = 'padrao';
+
+    // 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);
 
@@ -398,7 +613,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);
     }
@@ -417,22 +632,26 @@ async function main() {
             } catch { console.log(c.err(`Não consegui ler: ${args[fileFlag + 1]}`)); process.exit(1); }
         }
 
-        const plan = planWorkDir(promptText);
+        // Mesma função do modo interativo: detecta a pasta, adota projeto que já
+        // existe, e só então decide se há projeto novo pendente.
+        const plan = prepararPasta(promptText);
         await runAct(fullPrompt, {
             server: state.config.server,
             model: state.config.model,
             token: state.config.token,
             history: [],
             projectDir: plan.dir,
-            projectName: plan.pending ? plan.name : state.currentProject,
+            projectName: plan.name || state.currentProject,
             ensureWorkDir: plan.pending ? () => createPendingProject(plan) : null,
         });
         process.exit(0);
     }
 
     console.log(welcomeBox(VERSION, state.workDir ? shortPath(state.workDir) : null, {
+        modo: state.mode,
         mascot: state.config.mascot,
         userName: state.config.userName,
+        pastaPadrao: state.workDirOrigem === 'padrao',
     }));
     rl = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: makePrompt() });
     rl.prompt();

package/lib/act.js

@@ -14,6 +14,7 @@ const { c, actionHeader, Spinner, friendlyError } = require('./ui');
 const tools = require('./tools');
 const api = require('./api');
 const cfg = require('./config');
+const catalogo = require('./catalogo');
 
 const MAX_ITERATIONS = 15;
 const MAX_PROFUNDIDADE = 2; // principal + 1 nível de subagente
@@ -136,9 +137,13 @@ async function runAct(userPrompt, opts) {
         ensureWorkDir, profundidade = 0, subagent = false,
     } = opts || {};
 
-    // A pasta só nasce quando o agente for mesmo mexer em arquivo. Um "oi"
-    // não deve deixar diretório vazio espalhado pelo disco.
-    let workDirReady = !ensureWorkDir;
+    // A pasta de projeto só nasce quando o agente for mesmo MEXER EM ARQUIVO.
+    // Antes ela nascia na primeira tool qualquer — pedir "abre o Chrome" criava
+    // um projeto vazio, e ~/primocode enchia de pasta que não era projeto de
+    // nada. Quem decide é o catálogo: `escreve: true`.
+    let criarPasta = ensureWorkDir || null;
+    let pastaAtual = projectDir;      // onde as tools agem AGORA
+    let temPasta = !criarPasta;       // já é a pasta definitiva?
     const falhasPendentes = [];
     let tentativasDeEncerrar = 0;
 
@@ -235,16 +240,21 @@ async function runAct(userPrompt, opts) {
 
             if (tc.name === 'spawn_agent') {
                 const r = await runSubagent(tc.arguments || {}, {
-                    server, model, token, projectDir, projectName, profundidade,
+                    server, model, token, projectDir: pastaAtual, projectName, profundidade,
                 });
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: r });
                 continue;
             }
 
-            if (!workDirReady) { ensureWorkDir(); workDirReady = true; }
+            if (criarPasta && catalogo.escreveArquivo(tc.name)) {
+                const nova = criarPasta();
+                if (nova) pastaAtual = nova;
+                criarPasta = null;
+                temPasta = true;
+            }
 
             console.log(ident(profundidade) + actionHeader(tc.name, tc.arguments));
-            const result = await tools.execute(tc.name, tc.arguments, { projectDir });
+            const result = await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual });
             logResult(tc.name, result, profundidade);
 
             // Uma escrita bem-sucedida limpa a dívida: o agente se corrigiu.
@@ -263,9 +273,11 @@ async function runAct(userPrompt, opts) {
 
     if (!finalText) finalText = 'Cheguei ao limite de passos sem concluir. Refaça o pedido em partes menores.';
 
-    // Nada de arquivo mexido = nada para lembrar.
-    if (!subagent && projectName && workDirReady) {
-        cfg.appendProjectMemory(projectDir, `**Pedido:** ${userPrompt.slice(0, 300)}\n**Resultado:** ${finalText.slice(0, 500)}`);
+    // Nada de arquivo mexido = nada para lembrar. E grava em `pastaAtual`, não em
+    // `projectDir`: quando a pasta do projeto nasceu no meio do caminho, a memória
+    // precisa ir para ela, não para a raiz onde a sessão começou.
+    if (!subagent && projectName && temPasta) {
+        cfg.appendProjectMemory(pastaAtual, `**Pedido:** ${userPrompt.slice(0, 300)}\n**Resultado:** ${finalText.slice(0, 500)}`);
     }
 
     return {

package/lib/browser.js

@@ -36,12 +36,16 @@ function findChrome() {
         '/Applications/Chromium.app/Contents/MacOS/Chromium',
         '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
         '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser',
+        '/Applications/Arc.app/Contents/MacOS/Arc',
+        '/Applications/Vivaldi.app/Contents/MacOS/Vivaldi',
+        '/Applications/Opera.app/Contents/MacOS/Opera',
     ] : platform === 'win32' ? [
         `${process.env['PROGRAMFILES']}\\Google\\Chrome\\Application\\chrome.exe`,
         `${process.env['PROGRAMFILES(X86)']}\\Google\\Chrome\\Application\\chrome.exe`,
         `${process.env['LOCALAPPDATA']}\\Google\\Chrome\\Application\\chrome.exe`,
         `${process.env['PROGRAMFILES(X86)']}\\Microsoft\\Edge\\Application\\msedge.exe`,
         `${process.env['PROGRAMFILES']}\\Microsoft\\Edge\\Application\\msedge.exe`,
+        `${process.env['LOCALAPPDATA']}\\BraveSoftware\\Brave-Browser\\Application\\brave.exe`,
     ] : [
         '/usr/bin/google-chrome',
         '/usr/bin/google-chrome-stable',
@@ -271,7 +275,7 @@ async function ensureChromeRunning() {
     } catch {}
 
     const chrome = findChrome();
-    if (!chrome) throw new Error('Google Chrome não encontrado no sistema. Instale o Chrome para usar o controle de navegador.');
+    if (!chrome) throw new Error('Nenhum navegador controlável encontrado. O PrimoCode usa Chrome, Edge, Brave, Arc, Vivaldi ou Chromium — instale qualquer um deles, ou aponte o seu com PRIMOCODE_CHROME=/caminho/do/navegador. (O Safari não serve: não fala o protocolo que permite controlar a página.)');
 
     fs.mkdirSync(PROFILE_DIR, { recursive: true });
 

package/lib/catalogo.js

@@ -0,0 +1,94 @@
+/**
+ * O que o PrimoCode sabe fazer — a lista, em um lugar só.
+ *
+ * Existe porque "o que ele faz" estava espalhado entre o README, o /help, o
+ * prompt do servidor e o switch do `tools.js`, e quatro cópias da mesma verdade
+ * significam que pelo menos uma está mentindo.
+ *
+ * O `test/catalogo.test.js` cruza esta lista com as tools que o `tools.execute`
+ * realmente atende: item aqui que não existe lá derruba o teste, e tool que
+ * existe lá e não está aqui também. A lista não consegue mentir.
+ *
+ * `escreve: true` marca a ferramenta que cria ou muda arquivo. É o que decide
+ * quando nasce uma pasta de projeto — pedir para abrir o Chrome não cria projeto.
+ */
+
+'use strict';
+
+const GRUPOS = [
+    {
+        nome: 'Arquivos',
+        resumo: 'ler, criar e mudar arquivo na pasta de trabalho',
+        itens: [
+            { tool: 'write_file', escreve: true,  faz: 'cria arquivo, ou reescreve inteiro' },
+            { tool: 'edit_file',  escreve: true,  faz: 'troca um trecho exato, sem reescrever o resto' },
+            { tool: 'multi_edit', escreve: true,  faz: 'várias trocas no mesmo arquivo, tudo ou nada' },
+            { tool: 'read_file',  escreve: false, faz: 'lê arquivo, inteiro ou por pedaço' },
+            { tool: 'list_dir',   escreve: false, faz: 'mostra a árvore de pastas' },
+            { tool: 'glob',       escreve: false, faz: 'acha arquivo pelo nome (**/*.js)' },
+            { tool: 'grep',       escreve: false, faz: 'acha texto dentro dos arquivos' },
+        ],
+    },
+    {
+        nome: 'Terminal',
+        resumo: 'rodar comando na sua máquina',
+        itens: [
+            { tool: 'run_shell',           escreve: false, faz: 'roda comando e devolve a saída' },
+            { tool: 'run_in_new_terminal', escreve: false, faz: 'abre outro terminal para o que fica de pé (servidor, watch)' },
+        ],
+    },
+    {
+        nome: 'Navegador',
+        resumo: 'controla um navegador de verdade (Chrome, Edge, Brave, Arc…) — clica, digita, lê, fotografa',
+        itens: [
+            { tool: 'browser_open',       escreve: false, faz: 'abre uma página ou um arquivo seu' },
+            { tool: 'browser_click',      escreve: false, faz: 'clica por texto, por seletor ou por coordenada' },
+            { tool: 'browser_type',       escreve: false, faz: 'digita num campo' },
+            { tool: 'browser_key',        escreve: false, faz: 'aperta tecla (Enter, Tab, Escape)' },
+            { tool: 'browser_read',       escreve: false, faz: 'lê o texto da página para conferir o resultado' },
+            { tool: 'browser_screenshot', escreve: true,  faz: 'tira foto da página' },
+            { tool: 'browser_scroll',     escreve: false, faz: 'rola a página' },
+            { tool: 'browser_wait',       escreve: false, faz: 'espera um elemento aparecer' },
+            { tool: 'browser_eval',       escreve: false, faz: 'roda JavaScript na página' },
+            { tool: 'open_in_browser',    escreve: false, faz: 'abre no seu navegador normal, sem controlar' },
+        ],
+    },
+    {
+        nome: 'Computador',
+        resumo: 'mouse, teclado e tela — age em qualquer programa, não só no navegador',
+        itens: [
+            { tool: 'desktop_screenshot', escreve: true,  faz: 'tira foto da sua tela' },
+            { tool: 'desktop_click',      escreve: false, faz: 'clica na tela' },
+            { tool: 'desktop_move',       escreve: false, faz: 'move o mouse' },
+            { tool: 'desktop_drag',       escreve: false, faz: 'arrasta de um ponto a outro' },
+            { tool: 'desktop_type',       escreve: false, faz: 'digita no programa que está na frente' },
+            { tool: 'desktop_key',        escreve: false, faz: 'aperta tecla ou atalho' },
+            { tool: 'desktop_scroll',     escreve: false, faz: 'rola a tela' },
+            { tool: 'desktop_size',       escreve: false, faz: 'mede a tela, para se orientar antes de clicar' },
+        ],
+    },
+    {
+        nome: 'Organização',
+        resumo: 'como ele se organiza numa tarefa grande',
+        itens: [
+            { tool: 'write_todos', escreve: false, faz: 'monta o plano e vai marcando o que terminou' },
+            // Estas duas o loop do agente atende (lib/act.js), não o tools.execute.
+            { tool: 'spawn_agent', escreve: false, faz: 'chama um subagente para uma parte da tarefa', noLoop: true },
+            { tool: 'finish',      escreve: false, faz: 'encerra dizendo o que fez', noLoop: true },
+        ],
+    },
+];
+
+/** Só as que criam ou mudam arquivo. É o gatilho da pasta de projeto. */
+const ESCREVEM = new Set(
+    GRUPOS.flatMap((g) => g.itens.filter((i) => i.escreve).map((i) => i.tool)),
+);
+
+const TODAS = GRUPOS.flatMap((g) => g.itens.map((i) => i.tool));
+
+/** Esta ferramenta cria ou muda arquivo? */
+function escreveArquivo(tool) {
+    return ESCREVEM.has(tool);
+}
+
+module.exports = { GRUPOS, TODAS, ESCREVEM, escreveArquivo };

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/pasta.js

@@ -0,0 +1,187 @@
+/**
+ * Descobrir em que pasta trabalhar a partir do que a pessoa escreveu.
+ *
+ * A regra do produto: por padrão ele trabalha em `~/primocode`, sempre, não
+ * importa de onde foi aberto. Se você **falar** de uma pasta no pedido, ele
+ * procura essa pasta no seu computador e muda para ela sozinho.
+ *
+ * Duas funções, de propósito: `detectarPasta` é pura (texto → candidato) e
+ * `resolverPasta` toca o disco. Assim a parte que erra feio — decidir que uma
+ * palavra qualquer é nome de pasta — é testável sem criar arquivo nenhum.
+ *
+ * ── POR QUE CONSERVADOR ──────────────────────────────────────────────────
+ * Errar para MENOS custa um `/dir` a mais. Errar para MAIS faz o agente escrever
+ * arquivo dentro de uma pasta que ninguém escolheu. Então: só detecta quando há
+ * marca explícita ("pasta X", "~/x/y") e nunca quando o texto parece nome de
+ * arquivo.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Onde procurar uma pasta pelo nome, na ordem. É onde as pessoas guardam
+// trabalho — não é varredura do disco, que seria lenta e traria lixo.
+const ONDE_PROCURAR = [
+    '',                 // a própria raiz de trabalho (~/primocode)
+    'Downloads',
+    'Documents',
+    'Documentos',
+    'Desktop',
+    'Área de Trabalho',
+    'projetos',
+    'Projetos',
+    'dev',
+    'code',
+    'repos',
+    'git',
+];
+
+// Palavras que vêm depois de "pasta" mas não são nome de pasta nenhuma.
+const NAO_E_NOME = new Set([
+    'do', 'da', 'de', 'dos', 'das', 'no', 'na', 'em', 'o', 'a', 'os', 'as',
+    'projeto', 'atual', 'raiz', 'aqui', 'certa', 'mesma', 'essa', 'esta',
+    'dele', 'minha', 'meu', 'nova', 'novo', 'onde', 'que', 'qual', 'toda',
+]);
+
+// Extensão de arquivo: "index.html" nunca é pasta. Sem isto, "crie o
+// src/index.html" viraria uma troca de pasta para "src/index.html".
+const TEM_EXTENSAO = /\.[a-z0-9]{1,5}$/i;
+
+const CARACTERES_DE_CAMINHO = 'A-Za-z0-9À-ÖØ-öø-ÿ_~./\\\\-';
+
+/**
+ * O texto menciona uma pasta? Devolve o candidato cru, ou null.
+ *
+ * Aceita, em ordem de confiança:
+ *   1. caminho explícito: `~/projetos/loja`, `/Users/joel/x`
+ *   2. marca de pasta: `na pasta loja`, `diretório src/app`
+ *   3. caminho relativo com barra e sem extensão: `Downloads/meu-site`
+ */
+function detectarPasta(texto) {
+    const s = String(texto || '');
+    if (!s.trim()) return null;
+
+    // 1. Caminho explícito — `~/...` ou absoluto com pelo menos dois segmentos.
+    //    Um `/algo` solto não conta: seria confundido com comando (`/dir`).
+    const explicito = s.match(new RegExp(`(?:^|\\s)(~[${CARACTERES_DE_CAMINHO}]*|/[${CARACTERES_DE_CAMINHO}]+/[${CARACTERES_DE_CAMINHO}]*)`));
+    if (explicito) {
+        const bruto = limpar(explicito[1]);
+        if (bruto && !TEM_EXTENSAO.test(bruto)) return bruto;
+    }
+
+    // 2. Marca explícita de pasta.
+    const marcado = s.match(new RegExp(`\\b(?:pasta|diret[óo]rio|dir)\\s+(?:d[eoa]s?\\s+|no\\s+|na\\s+|em\\s+)?["'\`]?([${CARACTERES_DE_CAMINHO}]+)["'\`]?`, 'i'));
+    if (marcado) {
+        const bruto = limpar(marcado[1]);
+        if (bruto && !TEM_EXTENSAO.test(bruto) && !NAO_E_NOME.has(bruto.toLowerCase())) return bruto;
+    }
+
+    // 3. Caminho relativo com barra e sem extensão.
+    // O ponto ENTRA no token de propósito: sem ele, `src/app.js` casaria como
+    // `src/app` e passaria pelo filtro de extensão sem ser visto. Capturando a
+    // extensão junto, o TEM_EXTENSAO abaixo consegue recusar.
+    const relativo = s.match(new RegExp(`(?:^|\\s)([A-Za-zÀ-ÖØ-öø-ÿ0-9_.-]+(?:/[A-Za-zÀ-ÖØ-öø-ÿ0-9_.-]+)+)`));
+    if (relativo) {
+        const bruto = limpar(relativo[1]);
+        if (bruto && !TEM_EXTENSAO.test(bruto)) return bruto;
+    }
+
+    return null;
+}
+
+// Tira pontuação de fim de frase e barra final — "na pasta loja." → "loja".
+function limpar(bruto) {
+    return String(bruto || '').trim().replace(/[.,;:!?)\]}]+$/, '').replace(/\/+$/, '');
+}
+
+/**
+ * Transforma o candidato em pasta de verdade no disco.
+ *
+ * Devolve `{ caminho, ondeAchou }` quando há uma só, `{ ambiguo: [...] }` quando
+ * há mais de uma (aí quem decide é o usuário, não a heurística), e `null` quando
+ * não achou nada.
+ */
+function resolverPasta(candidato, opts = {}) {
+    const bruto = String(candidato || '').trim();
+    if (!bruto) return null;
+
+    const home = opts.home || os.homedir();
+    const raiz = opts.raiz || path.join(home, 'primocode');
+    const cwd = opts.cwd || process.cwd();
+
+    // Caminho que já se explica: `~/x`, `/Users/...`, `./x`, `../x`.
+    if (/^~(?:$|[/\\])/.test(bruto) || path.isAbsolute(bruto) || /^\.\.?[/\\]/.test(bruto)) {
+        const alvo = path.resolve(cwd, bruto.replace(/^~(?=$|[/\\])/, home));
+        return ehPasta(alvo) ? { caminho: alvo, ondeAchou: 'caminho' } : null;
+    }
+
+    // Nome ou caminho relativo: procura nos lugares prováveis, na ordem.
+    const achados = [];
+    const bases = [raiz, cwd, home, ...ONDE_PROCURAR.map((p) => path.join(home, p))];
+    for (const base of bases) {
+        if (!base) continue;
+        const alvo = path.join(base, bruto);
+        if (!ehPasta(alvo)) continue;
+        const real = canonico(alvo);
+        if (achados.some((a) => canonico(a.caminho) === real)) continue;
+        achados.push({ caminho: alvo, ondeAchou: base === raiz ? 'primocode' : base });
+    }
+
+    // Ainda nada? Um nível dentro de cada lugar provável — é onde mora
+    // `~/Downloads/clientes/loja-do-joao`.
+    if (!achados.length) {
+        for (const base of bases) {
+            for (const filho of listarPastas(base)) {
+                const alvo = path.join(base, filho, bruto);
+                if (!ehPasta(alvo)) continue;
+                const real = canonico(alvo);
+                if (achados.some((a) => canonico(a.caminho) === real)) continue;
+                achados.push({ caminho: alvo, ondeAchou: path.join(base, filho) });
+            }
+        }
+    }
+
+    if (!achados.length) return null;
+    if (achados.length === 1) return achados[0];
+    return { ambiguo: achados.slice(0, 5) };
+}
+
+function ehPasta(p) {
+    try { return fs.statSync(p).isDirectory(); } catch { return false; }
+}
+
+/**
+ * Identidade da pasta no disco — `dispositivo:inode`.
+ *
+ * Necessário porque no macOS e no Windows o sistema de arquivos não diferencia
+ * maiúscula: `~/projetos` e `~/Projetos` são a MESMA pasta, e a lista de lugares
+ * prováveis tem as duas grafias. Sem isto, procurar "duplicado" achava a mesma
+ * pasta duas vezes e virava "ambíguo" sem haver ambiguidade nenhuma.
+ *
+ * Comparar `realpathSync` não resolve: no macOS ele resolve symlink mas **não**
+ * corrige a caixa — medido aqui, `.../Projetos/duplicado` volta com o P maiúsculo.
+ * O inode volta igual (850551 nos dois), então é ele que diz a verdade. Também
+ * pega symlink e hard link de graça, o que é o comportamento certo.
+ */
+function canonico(p) {
+    try {
+        const st = fs.statSync(p);
+        return `${st.dev}:${st.ino}`;
+    } catch {
+        return path.resolve(p);
+    }
+}
+
+function listarPastas(base) {
+    try {
+        return fs.readdirSync(base, { withFileTypes: true })
+            .filter((e) => e.isDirectory() && !e.name.startsWith('.') && e.name !== 'node_modules')
+            .map((e) => e.name)
+            .slice(0, 40);
+    } catch { return []; }
+}
+
+module.exports = { detectarPasta, resolverPasta, ONDE_PROCURAR };

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',
 };
@@ -58,10 +74,10 @@ const PES   = '  ▘▘ ▝▝  ';
 const MASCOTS = {
     // Padrão: o Primo — cabeça cheia, ombros marcados, dois pezinhos.
     primo: { topo: ' ▐▛███▜▌ ', full: 'brand',  edge: 'brandDim' },
-    // Raposa — orelhas largas, abertas para fora.
+    // Raposa — orelhas largas, abertas para fora. Na secundária do sistema.
     fox:   { topo: ' ▛▀   ▀▜ ', full: 'warn',   edge: 'dim' },
-    // Gato — orelhas curtas e juntas.
-    cat:   { topo: ' ▛▘   ▝▜ ', full: 'cyan',   edge: 'brandDim' },
+    // 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
@@ -140,14 +156,14 @@ const NOME = 'Primo Code';
 
 const TIPS = [
     'Peça um app novo, ou aponte para um repositório e mande clonar',
-    'Ele controla navegador e desktop de verdade — peça e veja',
-    '/help lista tudo · /mascot troca o mascote · /status confere a API',
+    '/dir <pasta> para ele trabalhar numa pasta que já é sua',
+    '/help lista tudo · /mode troca o modo · /status confere a API',
 ];
 
 const NEWS = [
-    'Cabeçalho novo: mascote em blocos e identidade em três linhas',
-    'Mascotes redesenhados na mesma família — primo, fox e cat',
-    'Instalador detecta e instala o Node sozinho, sem sudo e sem EACCES',
+    'Modelos grátis, com reserva: um no limite não vira erro na sua tela',
+    'Ele trabalha em ~/primocode. Fale o nome de uma pasta e ele muda sozinho',
+    '/tudo lista as 30 ferramentas que ele sabe usar',
 ];
 
 // ── Cabeçalho ────────────────────────────────────────────────────────────
@@ -156,7 +172,7 @@ const NEWS = [
 // 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, pastaPadrao } = opts;
     const art = mascot(style);
     const cols = Math.max(32, Math.min(process.stdout.columns || 100, 120));
 
@@ -166,10 +182,20 @@ function welcomeBox(version, contexto, opts = {}) {
 
     // As três linhas de identidade — uma por linha do mascote, na ordem em que
     // se lê: quem é, quem chegou, onde estamos.
+    // A pasta é o que mais confundia quem usa, então ela avisa de si mesma — na
+    // MESMA linha de sempre, sem mudar o desenho do cabeçalho. Amber quando é a
+    // pasta padrão (é um aviso, não uma falha: dá para trabalhar em outra), e a
+    // primária quando foi você que escolheu — aí não há nada a avisar.
+    const linhaPasta = !contexto
+        ? c.dim('nenhuma pasta ativa')
+        : pastaPadrao
+            ? `${c.warn(contexto)}${c.dim('  · /dir <pasta> muda')}`
+            : c.brandDim(contexto);
+
     const ident = [
         `${c.bold(c.brand(NOME))} ${c.dim('v' + version)}`,
         saudacao,
-        contexto ? c.brandDim(contexto) : c.dim('nenhuma pasta ativa'),
+        linhaPasta,
     ];
 
     const out = [''];
@@ -200,13 +226,20 @@ function welcomeBox(version, contexto, opts = {}) {
     secao('Dicas para começar', TIPS, (i) => `${i + 1}.`);
     secao('Novidades', NEWS, () => ' ·');
 
-    // Rodapé de modos. Em terminal apertado a dica do /help sai antes de
-    // empurrar a linha para baixo — cabeçalho que quebra parece defeito.
-    const modos =
-        `  ${c.magenta('●')} ${c.muted('Primo Code')}` +
-        `   ${c.brand('●')} ${c.muted('Chat')}`;
+    // 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(cols >= 44 ? `${modos}   ${c.dim('/help para tudo')}` : modos);
+    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');
 }
@@ -282,7 +315,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();
@@ -298,10 +331,57 @@ 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.';
+    }
+    // O corte de prompt da conta sem crédito. Mensagem própria porque a cura é
+    // outra: não é encurtar a conversa nem esperar, é trocar de modelo — e os
+    // apelidos padrão já são grátis, então quem cai aqui forçou um modelo pago.
+    if (/prompt tokens limit exceeded/i.test(low)) {
+        const n = s.match(/exceeded:\s*(\d+)\s*>\s*(\d+)/i);
+        return '🆓 Este modelo é pago e a conta não tem crédito, então o provedor corta o pedido'
+            + (n ? ` em ${n[2]} tokens (o seu tem ${n[1]})` : '')
+            + '. Use /model main — os modelos padrão são grátis e não têm esse corte.';
+    }
+    // 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)) {

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "primocode",
-  "version": "7.5.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.",
+  "version": "7.8.0",
+  "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Modelos grátis. Cria arquivos, roda comandos, controla navegador e desktop.",
   "main": "bin/primocode.js",
   "bin": {
     "primocode": "bin/primocode.js"
   },
   "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 && node test/pasta.test.js && node test/catalogo.test.js"
   },
   "engines": {
     "node": ">=18.17.0"