primocode 7.15.0 → 7.16.0

package/bin/primocode.js

@@ -23,6 +23,7 @@ const { runAct, interromper } = require('../lib/act');
 const pasta = require('../lib/pasta');
 const catalogo = require('../lib/catalogo');
 const streaming = require('../lib/streaming');
+const effort = require('../lib/effort');
 
 // 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
@@ -48,7 +49,7 @@ ${c.bold('Comandos')}
   ${c.brand('/dir')} <caminho>       trabalha numa pasta que já existe (onde você quiser)
   ${c.brand('/project')}              lista projetos ou cria em ~/primocode: /project <nome>
   ${c.brand('/mode')}                 /mode primocode|chat|auto
-  ${c.brand('/model')}                /model top|main|fast — ou um ID do OpenRouter
+  ${c.brand('/effort')}               esforço do agente — do rápido ao mais esperto
   ${c.brand('/attach')} <arquivo>     anexa arquivo ao próximo pedido
   ${c.brand('/files')}                lista anexos   ${c.brand('/detach')} remove
   ${c.brand('/tudo')}                 lista tudo que ele sabe fazer
@@ -87,7 +88,7 @@ const SLASH_COMANDOS = [
     ['/project', 'lista/cria projetos em ~/primocode'],
     ['/dir', 'trabalhar numa pasta sua'],
     ['/mode', 'primocode | chat | auto'],
-    ['/model', 'top | main | fast'],
+    ['/effort', 'esforço: low → ultracode (←/→ para ajustar)'],
     ['/attach', 'anexa arquivo ao pedido'],
     ['/detach', 'remove os anexos'],
     ['/files', 'lista os anexos'],
@@ -117,6 +118,105 @@ function completarSlash(line) {
     return [acertos, line];
 }
 
+// ── /effort: o slider de esforço (estilo Claude Code) ──────────────────
+// Régua com os níveis, o marcador ▲ embaixo do escolhido, "Faster" à
+// esquerda e "Smarter" à direita. ←/→ move, Enter confirma, Esc cancela.
+
+function desenharEffort(idx) {
+    const cols = Math.max(52, Math.min(process.stdout.columns || 100, 104));
+    const regua = '▔'.repeat(cols);
+    const linhas = [];
+
+    // Cada nível ocupa uma coluna própria; o ultracode fica destacado no fim.
+    const rotulos = effort.NOMES;
+    const larguras = rotulos.map((n) => Math.max(n.length + 3, 9));
+    const posicoes = [];
+    let x = 23;   // recuo da régua, igual ao do mockup
+    for (let i = 0; i < rotulos.length; i++) {
+        posicoes.push(x + Math.floor(larguras[i] / 2));
+        x += larguras[i];
+    }
+    const fimRegua = x;
+
+    linhas.push(c.dim(regua));
+    linhas.push('   ' + c.bold(c.white('Effort')));
+    linhas.push('');
+
+    // Faster ....▲.... Smarter — a trilha, com o marcador na posição atual.
+    const marca = posicoes[idx];
+    let trilha = '';
+    for (let k = 23; k < fimRegua; k++) {
+        if (k === marca) trilha += c.brand('▲');
+        else if (k === fimRegua - 12) trilha += c.dim('┆');       // ultracode é um degrau à parte
+        else trilha += c.dim(k < marca ? '─' : '─');
+    }
+    linhas.push('                       ' + c.muted('Faster') + ' '.repeat(Math.max(1, fimRegua - 23 - 6 - 7)) + c.muted('Smarter'));
+    linhas.push('                       ' + trilha);
+
+    // Os nomes, o escolhido aceso.
+    let linhaNomes = ' '.repeat(23);
+    for (let i = 0; i < rotulos.length; i++) {
+        const nome = rotulos[i];
+        const espaco = larguras[i];
+        const pad = Math.floor((espaco - nome.length) / 2);
+        const texto = i === idx ? c.bold(c.brand(nome)) : c.muted(nome);
+        linhaNomes += ' '.repeat(pad) + texto + ' '.repeat(espaco - nome.length - pad);
+    }
+    linhas.push(linhaNomes);
+
+    const nivel = effort.nivelDe(rotulos[idx]);
+    linhas.push('                       ' + c.dim(nivel.resumo));
+    linhas.push('');
+    linhas.push('   ' + c.muted('←/→ ajusta · Enter confirma · Esc cancela'));
+    return linhas.join('\n');
+}
+
+// Desenha, escuta as setas, e devolve o nome escolhido (ou null se cancelou).
+function sliderEffort(atual) {
+    return new Promise((resolve) => {
+        if (!process.stdin.isTTY) {   // sem terminal (pipe, CI) não há slider
+            console.log(c.muted(`  Esforço atual: ${effort.normalizar(atual)}. Use /effort <${effort.NOMES.join('|')}>.`));
+            return resolve(null);
+        }
+        let idx = effort.indiceDe(atual);
+        const ALTURA = 9;   // linhas que o desenho ocupa — para redesenhar por cima
+
+        const pintar = (primeira) => {
+            if (!primeira) process.stdout.write(`\x1b[${ALTURA}A\r`);
+            process.stdout.write(desenharEffort(idx).split('\n').map((l) => '\x1b[2K' + l).join('\n') + '\n');
+        };
+        pintar(true);
+
+        const aoTeclar = (ch, key) => {
+            if (!key) return;
+            if (key.name === 'right' || key.name === 'l') { idx = Math.min(effort.NOMES.length - 1, idx + 1); pintar(false); return; }
+            if (key.name === 'left' || key.name === 'h') { idx = Math.max(0, idx - 1); pintar(false); return; }
+            if (key.name === 'return' || key.name === 'enter') { encerrar(effort.NOMES[idx]); return; }
+            if (key.name === 'escape' || (key.ctrl && key.name === 'c')) { encerrar(null); return; }
+        };
+        const encerrar = (valor) => {
+            process.stdin.removeListener('keypress', aoTeclar);
+            sliderAtivo = false;
+            resolve(valor);
+        };
+        sliderAtivo = true;
+        process.stdin.on('keypress', aoTeclar);
+    });
+}
+
+function aplicarEffort(nome) {
+    const nivel = effort.nivelDe(nome);
+    state.config.effort = nivel.nome;
+    state.config.model = nivel.model;
+    cfg.saveConfig({ effort: nivel.nome, model: nivel.model });
+    console.log(c.ok(`Esforço: ${nivel.nome}`) + c.muted(`  ${nivel.resumo}`));
+    if (nivel.pesquisa) console.log(c.dim('  Pesquisa de referência ligada: ele consulta docs e exemplos antes de escrever.'));
+    refreshPrompt();
+}
+
+// Enquanto o slider está no ar, o fantasma do autocompletar não desenha.
+let sliderAtivo = false;
+
 function mostrarMenuSlash() {
     console.log('');
     for (const [nome, desc] of SLASH_COMANDOS) {
@@ -309,6 +409,7 @@ async function sendPrompt(userText) {
         const r = await runAct(prompt, {
             server: state.config.server,
             model: state.config.model,
+            effort: state.config.effort,
             token: state.config.token,
             history: state.history,
             projectDir: plan.dir,
@@ -464,24 +565,38 @@ async function handleSlash(text) {
             break;
         }
 
+        // O /model virou /effort: você escolhe o ESFORÇO num slider (←/→,
+        // Enter confirma, Esc cancela) e o modelo sai daí. Com argumento
+        // ("/effort high") aplica direto, para quem já sabe o que quer.
+        case 'effort': case 'esforco': case 'esforço': {
+            const pedido = rest.toLowerCase().trim();
+            if (pedido) {
+                if (!effort.NOMES.includes(pedido)) {
+                    console.log(c.err(`Esforço inválido. Use: ${effort.NOMES.join(' | ')}`));
+                    break;
+                }
+                aplicarEffort(pedido);
+                break;
+            }
+            const escolhido = await sliderEffort(state.config.effort);
+            if (escolhido) aplicarEffort(escolhido);
+            else console.log(c.muted('  Nada mudou.'));
+            break;
+        }
+
+        // Continua existindo para quem fixa um ID do OpenRouter na unha; o
+        // caminho normal é o /effort.
         case 'model': {
             const m = rest.toLowerCase();
-            // 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]) {
+            if (m.includes('/')) {
                 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)'));
+                console.log(c.ok(`Modelo fixo: ${m}`) + c.muted('  precisa aceitar tools no modo primocode'));
+                console.log(c.dim('  Para voltar ao normal, use /effort.'));
+            } else {
+                console.log(c.muted('  O modelo agora vem do esforço. Use ') + c.brand('/effort') + c.muted('.'));
+                console.log(c.dim(`  Agora: ${state.config.effort} → modelo ${effort.modeloDe(state.config.effort)}`));
+            }
             break;
         }
 
@@ -613,7 +728,8 @@ async function handleSlash(text) {
             console.log('');
             console.log(`  ${c.muted('nome')}      ${c.white(state.config.userName || '(nenhum)')}`);
             console.log(`  ${c.muted('mascote')}   ${c.white(state.config.mascot || 'primo')}`);
-            console.log(`  ${c.muted('modelo')}    ${c.white(state.config.model)}`);
+            console.log(`  ${c.muted('esforço')}   ${c.white(state.config.effort)}${c.dim('  · /effort muda')}`);
+            console.log(`  ${c.muted('modelo')}    ${c.white(state.config.model)}${c.dim('  (vem do esforço)')}`);
             console.log(`  ${c.muted('modo')}      ${c.white(state.mode)}`);
             console.log(`  ${c.muted('servidor')}  ${c.dim(state.config.server)}`);
             console.log(c.muted(`\n  ${cfg.CONFIG_FILE}`));
@@ -733,6 +849,7 @@ async function main() {
         await runAct(fullPrompt, {
             server: state.config.server,
             model: state.config.model,
+            effort: state.config.effort,
             token: state.config.token,
             history: [],
             projectDir: plan.dir,
@@ -766,7 +883,7 @@ async function main() {
     if (process.stdin.isTTY && process.stdout.isTTY) {
         let fantasma = '';
         const desenharFantasma = () => {
-            if (busy || pendingAsk || !rl) return;
+            if (busy || pendingAsk || sliderAtivo || !rl) return;
             const linha = rl.line;
             const noFim = rl.cursor === linha.length;
             fantasma = '';
@@ -785,6 +902,7 @@ async function main() {
         // sequence "\x1b\x1b" — vale como os dois.
         let ultimoEsc = 0;
         process.stdin.on('keypress', (ch, key) => {
+            if (sliderAtivo) return;   // o slider é dono do teclado enquanto está no ar
             if (key && (key.name === 'escape' || key.sequence === '\x1b\x1b')) {
                 if (!busy) { ultimoEsc = 0; return; }   // sem agente rodando, Esc é só Esc
                 const agora = Date.now();

package/lib/act.js

@@ -105,6 +105,14 @@ function logResult(kind, result, profundidade) {
         case 'browser_read':
             console.log(p + c.muted(`${(result.text || '').length} caracteres lidos da página`));
             return;
+        case 'pesquisar_referencia': {
+            console.log(p + c.muted(`${result.fontes} fonte${result.fontes === 1 ? '' : 's'} lida${result.fontes === 1 ? '' : 's'} sobre "${result.consulta}"`));
+            for (const r of (result.referencias || []).slice(0, 4)) {
+                console.log(p + c.dim(`${r.titulo}`.slice(0, 100)));
+                console.log(p + c.dim(`  ${r.url}`.slice(0, 110)));
+            }
+            return;
+        }
         case 'desktop_windows': {
             console.log(p + c.muted(`${result.total} janela${result.total === 1 ? '' : 's'}`));
             for (const j of (result.janelas || []).slice(0, 5)) console.log(p + c.dim(`${j.app ? j.app + ' · ' : ''}${j.titulo}`.slice(0, 120)));
@@ -168,7 +176,7 @@ function buildMemoryContext(projectDir, projectName) {
 async function runAct(userPrompt, opts) {
     const {
         server, model, token, history, projectDir, projectName,
-        ensureWorkDir, profundidade = 0, subagent = false,
+        ensureWorkDir, profundidade = 0, subagent = false, effort,
     } = opts || {};
 
     // A pasta de projeto só nasce quando o agente for mesmo MEXER EM ARQUIVO.
@@ -210,7 +218,7 @@ async function runAct(userPrompt, opts) {
         let streaming = false;
 
         try {
-            await api.requestAct(server, { messages, model, token, projectDir, projectName, subagent }, (evt) => {
+            await api.requestAct(server, { messages, model, effort, token, projectDir, projectName, subagent }, (evt) => {
                 if (evt.erro) { streamError = evt.erro; return; }
                 if (evt.tool_call) { toolCalls.push(evt.tool_call); return; }
                 if (evt.delta) {

package/lib/catalogo.js

@@ -78,6 +78,7 @@ const GRUPOS = [
         resumo: 'como ele se organiza numa tarefa grande',
         itens: [
             { tool: 'write_todos', escreve: false, faz: 'monta o plano e vai marcando o que terminou' },
+            { tool: 'pesquisar_referencia', escreve: false, faz: 'lê docs e exemplos antes de escrever — sobe a qualidade' },
             // 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 },

package/lib/config.js

@@ -160,6 +160,9 @@ function loadConfig() {
     return {
         server: process.env.PRIMOCODE_SERVER || file.server || 'https://primocode-server.onrender.com',
         model: process.env.PRIMOCODE_MODEL || file.model || 'main',
+        // Esforço, estilo Claude Code (/effort). É o que o usuário escolhe; o
+        // modelo é derivado dele. Guardado para durar entre sessões.
+        effort: process.env.PRIMOCODE_EFFORT || file.effort || 'medium',
         token: process.env.PRIMOCODE_TOKEN || file.token || null,
         autoApply: file.autoApply === true,
         currentProject: file.currentProject || null,
@@ -177,8 +180,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, mode } = { ...cur, ...partial };
-    const next = { server, model, token, autoApply, currentProject, userName, mascot, theme, mode };
+    const { server, model, effort, token, autoApply, currentProject, userName, mascot, theme, mode } = { ...cur, ...partial };
+    const next = { server, model, effort, token, autoApply, currentProject, userName, mascot, theme, mode };
     fs.writeFileSync(CONFIG_FILE, JSON.stringify(next, null, 2), 'utf8');
     return next;
 }

package/lib/effort.js

@@ -0,0 +1,51 @@
+/**
+ * effort.js — o "esforço" do agente, no espírito do /effort do Claude Code.
+ *
+ * O usuário não escolhe mais um modelo por nome (/model): escolhe um ESFORÇO
+ * num controle deslizante, do mais rápido ao mais esperto. O modelo é derivado
+ * daqui. Fica tudo num lugar só, puro (sem I/O), para o teste bater sem rede.
+ *
+ * A pesquisa de referência (abrir docs/exemplos e aprender com eles antes de
+ * escrever) liga a partir do "high": esforço maior = ele pesquisa antes de
+ * codar, o que melhora a qualidade. É VISÍVEL no painel — nada escondido.
+ */
+
+'use strict';
+
+// Ordem = ordem do slider, do mais rápido ao mais esperto.
+const NIVEIS = [
+    { nome: 'low',       model: 'fast', pesquisa: false, resumo: 'rápido — tarefa simples, resposta curta' },
+    { nome: 'medium',    model: 'main', pesquisa: false, resumo: 'equilíbrio — o padrão do dia a dia' },
+    { nome: 'high',      model: 'main', pesquisa: true,  resumo: 'capricha no código e pesquisa referências' },
+    { nome: 'xhigh',     model: 'top',  pesquisa: true,  resumo: 'o mais capaz — 1M de contexto, pesquisa' },
+    { nome: 'max',       model: 'top',  pesquisa: true,  resumo: 'esforço máximo — pesquisa a fundo' },
+    { nome: 'ultracode', model: 'top',  pesquisa: true,  resumo: 'tudo no talo — pesquisa e cruza referências' },
+];
+
+const NOMES = NIVEIS.map((n) => n.nome);
+
+function normalizar(nome) {
+    const n = String(nome || '').toLowerCase().trim();
+    return NOMES.includes(n) ? n : 'medium';
+}
+
+function nivelDe(nome) {
+    return NIVEIS.find((n) => n.nome === normalizar(nome)) || NIVEIS[1];
+}
+
+function indiceDe(nome) {
+    const i = NOMES.indexOf(normalizar(nome));
+    return i < 0 ? 1 : i;
+}
+
+/** O apelido de modelo que este esforço usa. */
+function modeloDe(nome) {
+    return nivelDe(nome).model;
+}
+
+/** Este esforço pesquisa referências antes de codar? */
+function pesquisaDe(nome) {
+    return nivelDe(nome).pesquisa;
+}
+
+module.exports = { NIVEIS, NOMES, normalizar, nivelDe, indiceDe, modeloDe, pesquisaDe };

package/lib/referencia.js

@@ -0,0 +1,288 @@
+/**
+ * referencia.js — pesquisa de referência antes de escrever código.
+ *
+ * A ideia do dono: em vez de o agente inventar tudo da cabeça, ele consulta o
+ * que já existe sobre o pedido (documentação oficial, exemplos, respostas) e
+ * escreve com esse conhecimento na mão. A qualidade sobe porque ele para de
+ * chutar API que não existe e passa a seguir o padrão real da ferramenta.
+ *
+ * Duas decisões de projeto, deliberadas:
+ *
+ * 1. É VISÍVEL, não oculto. Cada pesquisa aparece no terminal e vira uma aba
+ *    no /streaming, com as fontes. Um agente que abre coisas escondido do dono
+ *    da máquina é um agente em que não dá para confiar — e o /streaming existe
+ *    justamente para mostrar tudo.
+ *
+ * 2. Ele extrai CONHECIMENTO (como se faz, qual API, que cuidado tomar), não
+ *    blocos de código para colar. Copiar trechos de terceiros para dentro do
+ *    projeto do usuário sem olhar licença é problema jurídico dele, não nosso;
+ *    e código colado de fontes que não conversam entre si é justamente o que
+ *    produz o Frankenstein que não compila. O modelo lê, aprende e ESCREVE.
+ *
+ * Zero dependências: https nativo. Sem chave de API — usa as fontes abertas.
+ */
+
+'use strict';
+
+const https = require('https');
+const http = require('http');
+const net = require('net');
+const tls = require('tls');
+const { URL } = require('url');
+
+const TIMEOUT_MS = 12000;
+const MAX_POR_FONTE = 4;
+const MAX_TEXTO = 4500;
+
+// Rede de empresa costuma exigir proxy. Sem isto, a pesquisa simplesmente não
+// funciona em metade dos computadores corporativos — e o usuário nunca
+// descobre por quê.
+const PROXY = process.env.HTTPS_PROXY || process.env.https_proxy
+    || process.env.HTTP_PROXY || process.env.http_proxy || null;
+
+/** Abre um túnel CONNECT no proxy e devolve o socket TLS pronto. */
+function viaProxy(alvo, { timeout }) {
+    return new Promise((resolve, reject) => {
+        const p = new URL(PROXY);
+        const porta = alvo.port || 443;
+        const req = http.request({
+            host: p.hostname,
+            port: p.port || 80,
+            method: 'CONNECT',
+            path: `${alvo.hostname}:${porta}`,
+            timeout,
+            headers: p.username
+                ? { 'Proxy-Authorization': 'Basic ' + Buffer.from(`${p.username}:${p.password}`).toString('base64') }
+                : {},
+        });
+        req.on('connect', (res, socket) => {
+            if (res.statusCode !== 200) { socket.destroy(); return reject(new Error(`proxy ${res.statusCode}`)); }
+            resolve(tls.connect({ socket, servername: alvo.hostname }));
+        });
+        req.on('error', reject);
+        req.on('timeout', () => { req.destroy(); reject(new Error('timeout no proxy')); });
+        req.end();
+    });
+}
+
+function pegar(url, { timeout = TIMEOUT_MS } = {}) {
+    return new Promise((resolve) => {
+        let req;
+        const alvo = (() => { try { return new URL(url); } catch { return null; } })();
+        if (!alvo) return resolve(null);
+
+        const opcoes = {
+            headers: {
+                'User-Agent': 'PrimoCode/1.0 (+https://github.com/ConectaPrimoAI/primocode)',
+                Accept: 'text/html,application/json;q=0.9,*/*;q=0.8',
+            },
+            timeout,
+        };
+
+        // Com proxy, a conexão vai por um túnel CONNECT; sem proxy, direto.
+        const abrir = PROXY && alvo.protocol === 'https:'
+            ? viaProxy(alvo, { timeout }).then((socket) => ({
+                ...opcoes, createConnection: () => socket, host: alvo.hostname, servername: alvo.hostname,
+            })).catch(() => null)
+            : Promise.resolve(opcoes);
+
+        abrir.then((cfg) => {
+            if (!cfg) return resolve(null);
+            try {
+                req = https.get(url, cfg, (res) => {
+                // Redirecionamento: segue uma vez, o suficiente para docs.
+                if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                    res.resume();
+                    const destino = new URL(res.headers.location, url).href;
+                    return pegar(destino, { timeout }).then(resolve);
+                }
+                if (res.statusCode !== 200) { res.resume(); return resolve(null); }
+                let corpo = '';
+                res.setEncoding('utf8');
+                res.on('data', (c) => {
+                    corpo += c;
+                    if (corpo.length > 400000) { req.destroy(); }   // página gigante não serve
+                });
+                    res.on('end', () => resolve(corpo));
+                    res.on('error', () => resolve(null));
+                });
+            } catch { return resolve(null); }
+            req.on('timeout', () => { req.destroy(); resolve(null); });
+            req.on('error', () => resolve(null));
+        });
+    });
+}
+
+/** HTML → texto legível. Sem dependência: corta script/style e as tags. */
+function textoDe(html) {
+    return String(html || '')
+        .replace(/<script[\s\S]*?<\/script>/gi, ' ')
+        .replace(/<style[\s\S]*?<\/style>/gi, ' ')
+        .replace(/<nav[\s\S]*?<\/nav>/gi, ' ')
+        .replace(/<footer[\s\S]*?<\/footer>/gi, ' ')
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/&nbsp;/g, ' ').replace(/&amp;/g, '&').replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>').replace(/&quot;/g, '"').replace(/&#39;/g, "'")
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+
+// Links que não são referência de nada — resultado de busca sujo.
+const LIXO = /(facebook|twitter|x)\.com|instagram|pinterest|youtube\.com\/(?!watch)|\/search\?|duckduckgo|bing\.com\/(?!ck)|google\./i;
+
+function limparLinks(pares, limite) {
+    const vistos = new Set();
+    const bons = [];
+    for (const { titulo, url } of pares) {
+        if (!/^https?:\/\//i.test(url) || LIXO.test(url)) continue;
+        const chave = url.replace(/[#?].*$/, '');
+        if (vistos.has(chave)) continue;
+        vistos.add(chave);
+        bons.push({ titulo: titulo.slice(0, 140), url });
+        if (bons.length >= limite) break;
+    }
+    return bons;
+}
+
+/** DuckDuckGo (HTML). O destino vem embrulhado em /l/?uddg=<url>. */
+async function buscarDDG(consulta, limite) {
+    const html = await pegar(`https://duckduckgo.com/html/?q=${encodeURIComponent(consulta)}`);
+    if (!html) return [];
+    const pares = [];
+    const re = /<a[^>]+class="[^"]*result__a[^"]*"[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
+    let m;
+    while ((m = re.exec(html))) {
+        let href = m[1];
+        const embrulho = href.match(/[?&]uddg=([^&]+)/);
+        if (embrulho) href = decodeURIComponent(embrulho[1]);
+        pares.push({ titulo: textoDe(m[2]), url: href });
+    }
+    return limparLinks(pares, limite);
+}
+
+/** Bing (HTML) — a reserva quando o DDG não responde. */
+async function buscarBing(consulta, limite) {
+    const html = await pegar(`https://www.bing.com/search?q=${encodeURIComponent(consulta)}&setlang=en`);
+    if (!html) return [];
+    const pares = [];
+    const re = /<h2>\s*<a[^>]+href="(https?:\/\/[^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
+    let m;
+    while ((m = re.exec(html))) pares.push({ titulo: textoDe(m[2]), url: m[1] });
+    return limparLinks(pares, limite);
+}
+
+/** SearXNG público, em JSON — a terceira porta. */
+async function buscarSearx(consulta, limite) {
+    const corpo = await pegar(`https://searx.be/search?q=${encodeURIComponent(consulta)}&format=json`);
+    if (!corpo) return [];
+    try {
+        const j = JSON.parse(corpo);
+        return limparLinks((j.results || []).map((r) => ({ titulo: String(r.title || ''), url: String(r.url || '') })), limite);
+    } catch { return []; }
+}
+
+/**
+ * Busca na web. Tenta as portas em ordem e para na primeira que responder —
+ * um buscador fora do ar (ou bloqueado pela rede) não pode desligar a
+ * pesquisa inteira. Sem chave de API em nenhuma delas.
+ */
+async function buscar(consulta, limite = MAX_POR_FONTE) {
+    for (const porta of [buscarDDG, buscarBing, buscarSearx]) {
+        try {
+            const achados = await porta(consulta, limite);
+            if (achados.length) return achados;
+        } catch {}
+    }
+    return [];
+}
+
+/** Respostas do StackOverflow — a API pública, sem chave. */
+async function stackoverflow(consulta, limite = 3) {
+    const url = 'https://api.stackexchange.com/2.3/search/advanced'
+        + `?order=desc&sort=relevance&q=${encodeURIComponent(consulta)}`
+        + '&site=stackoverflow&filter=default&pagesize=' + limite;
+    const corpo = await pegar(url);
+    if (!corpo) return [];
+    try {
+        const j = JSON.parse(corpo);
+        return (j.items || []).slice(0, limite).map((i) => ({
+            titulo: textoDe(i.title).slice(0, 140),
+            url: i.link,
+            nota: `${i.score} votos${i.is_answered ? ', respondida' : ''}`,
+        }));
+    } catch { return []; }
+}
+
+// Última porta: a documentação oficial dos assuntos mais comuns, direto. Não
+// depende de buscador nenhum — é o que salva a pesquisa em rede corporativa
+// que bloqueia mecanismo de busca mas libera site de documentação.
+const DOCS = [
+    [/\b(js|javascript|array|string|promise|fetch|dom|css|html|regex)\b/i,
+        (q) => `https://developer.mozilla.org/en-US/search?q=${encodeURIComponent(q)}`],
+    [/\b(react|jsx|hook|usestate|useeffect)\b/i, () => 'https://react.dev/reference/react'],
+    [/\b(node|npm|express|fs|require)\b/i, () => 'https://nodejs.org/docs/latest/api/'],
+    [/\b(python|django|flask|pandas)\b/i,
+        (q) => `https://docs.python.org/3/search.html?q=${encodeURIComponent(q)}`],
+];
+
+function docsConhecidas(consulta) {
+    const achados = [];
+    for (const [re, url] of DOCS) {
+        if (re.test(consulta)) achados.push({ titulo: 'documentação oficial', url: url(consulta) });
+    }
+    return achados;
+}
+
+/**
+ * A pesquisa completa: busca, abre as melhores páginas e devolve o texto
+ * delas para o modelo LER. O modelo escreve o código dele com isso na mão.
+ */
+async function pesquisar({ consulta, paginas = 3 }) {
+    const termo = String(consulta || '').trim();
+    if (!termo) return { ok: false, error: 'diga o que pesquisar' };
+
+    const [web, so] = await Promise.all([
+        buscar(termo, MAX_POR_FONTE),
+        stackoverflow(termo, 2),
+    ]);
+
+    // A documentação oficial entra SEMPRE na fila, não só quando as outras
+    // portas vieram vazias: ela é a melhor fonte, e é o que salva a pesquisa
+    // quando os links do buscador não abrem (rede corporativa, site fora do
+    // ar, bloqueio). Foi assim que a pesquisa falhava mesmo achando links.
+    const candidatos = [...web, ...so, ...docsConhecidas(termo)]
+        .slice(0, Math.max(2, Math.min(8, paginas + 4)));
+    if (!candidatos.length) {
+        return { ok: false, error: `nada encontrado para "${termo}" (sem internet?)`, consulta: termo };
+    }
+
+    const lidas = [];
+    for (const cand of candidatos) {
+        if (lidas.length >= paginas) break;
+        const html = await pegar(cand.url);
+        if (!html) continue;
+        const texto = textoDe(html);
+        if (texto.length < 200) continue;
+        lidas.push({
+            titulo: cand.titulo,
+            url: cand.url,
+            nota: cand.nota,
+            trecho: texto.slice(0, MAX_TEXTO),
+        });
+    }
+
+    if (!lidas.length) {
+        return { ok: false, error: 'achei os links mas não consegui abrir nenhum', consulta: termo, links: candidatos.map((c) => c.url) };
+    }
+
+    return {
+        ok: true,
+        consulta: termo,
+        fontes: lidas.length,
+        referencias: lidas,
+        comoUsar: 'Leia, entenda o padrão e ESCREVA o seu próprio código. Não copie trechos literais: '
+            + 'cite a fonte se aproveitar uma ideia, e confira se a API citada existe na versão que o projeto usa.',
+    };
+}
+
+module.exports = { pesquisar, buscar, stackoverflow, textoDe };

package/lib/streaming.js

@@ -26,8 +26,13 @@ const DIR = path.join(os.homedir(), '.primocode', 'streaming');
 const MAX_LOG = 300;
 // Fotos guardadas em disco para o "voltar no tempo" das abas. Além disso a
 // pasta viraria um álbum infinito — as mais velhas saem.
-const MAX_FRAMES = 80;
+const MAX_FRAMES = 60;
 const MAX_ABAS = 12;
+// Teto de disco: mesmo com poucos quadros, tela 4K dá PNG gordo. Passou
+// disso, as fotos mais velhas saem até caber. 120 MB de screenshots numa
+// pasta escondida é exatamente o tipo de coisa que ninguém vai limpar.
+const MAX_BYTES = 120 * 1024 * 1024;
+let bytesEmDisco = 0;
 // Uma foto por ação no máximo a cada 600ms: digitar letra por letra não pode
 // virar uma rajada de screenshots.
 const INTERVALO_FOTO_MS = 600;
@@ -154,6 +159,7 @@ function descrever(name, args = {}) {
         case 'run_shell': return `rodou: ${corta(args.command, 60)}`;
         case 'run_in_new_terminal': return `terminal novo: ${corta(args.command, 50)}`;
         case 'write_todos': return 'atualizou o plano';
+        case 'pesquisar_referencia': return `pesquisou referências: “${corta(args.consulta || args.query, 50)}”`;
         default: return name.replace(/_/g, ' ');
     }
 }
@@ -170,21 +176,69 @@ function nomeDeAba(name, args = {}) {
         try { return new URL(String(args.url)).hostname || 'navegador'; } catch { return 'navegador'; }
     }
     if (args && args.window) return String(args.window).trim();
+
+    // Trabalho que não é de janela também merece aba — senão o painel fica
+    // vazio de "o que ela fez" justamente no caso mais comum (mexer em
+    // arquivo, rodar comando, pesquisar referência).
+    if (['write_file', 'edit_file', 'multi_edit', 'read_file'].includes(name)) {
+        const arq = String(args.path || '').split(/[\\/]/).pop();
+        return arq ? `📄 ${arq}` : '📄 Arquivos';
+    }
+    if (['run_shell', 'run_in_new_terminal'].includes(name)) return '⌨ Terminal';
+    if (name === 'pesquisar_referencia') return '🔎 Pesquisa';
+    if (['glob', 'grep', 'list_dir'].includes(name)) return '🔍 Busca';
+    if (name.startsWith('browser_')) return '🌐 Navegador';
+    if (name.startsWith('desktop_')) return '🖥 Tela';
+    if (name === 'spawn_agent') return '🤖 Subagente';
     return '';
 }
 
+let proximaAba = 1;
 function entrarNaAba(nome) {
     const alvo = corta(nome, 24);
     if (!alvo) return;
     let aba = state.abas.find((a) => a.nome.toLowerCase() === alvo.toLowerCase());
     if (!aba) {
-        aba = { id: state.abas.length + 1, nome: alvo, passos: 0 };
+        // id de contador próprio: com `abas.length + 1`, uma aba descartada
+        // fazia a próxima nascer com id repetido — e os passos da nova
+        // apareciam dentro da antiga.
+        aba = { id: proximaAba++, nome: alvo, passos: 0 };
         state.abas.push(aba);
         if (state.abas.length > MAX_ABAS) state.abas.shift();
     }
     state.abaAtual = aba;
 }
 
+// Guarda o quadro e cobra o aluguel: acima de MAX_FRAMES ou de MAX_BYTES, as
+// fotos mais velhas são APAGADAS do disco. É o que impede a pasta de virar um
+// álbum infinito na máquina do usuário.
+function registrarFrame(meta, arquivo) {
+    let tamanho = 0;
+    try { tamanho = fs.statSync(arquivo).size; } catch {}
+    state.frames.push({ ...meta, bytes: tamanho });
+    bytesEmDisco += tamanho;
+
+    while (state.frames.length > MAX_FRAMES || (bytesEmDisco > MAX_BYTES && state.frames.length > 1)) {
+        const velho = state.frames.shift();
+        bytesEmDisco -= velho.bytes || 0;
+        try { fs.unlinkSync(path.join(DIR, `frame-${velho.id}.png`)); } catch {}
+    }
+    if (bytesEmDisco < 0) bytesEmDisco = 0;
+}
+
+/** Apaga TUDO que o painel deixou no disco. Chamado ao desligar e ao sair. */
+function limparDisco() {
+    try {
+        for (const f of fs.readdirSync(DIR)) {
+            if (/^(frame-\d+|live|live-tmp)\.png$/.test(f)) {
+                try { fs.unlinkSync(path.join(DIR, f)); } catch {}
+            }
+        }
+    } catch {}
+    state.frames = [];
+    bytesEmDisco = 0;
+}
+
 /**
  * A instrução que o usuário acabou de dar. A página autopreenche na barra de
  * comando, letra por letra, e marca o começo dela na linha do tempo.
@@ -210,7 +264,7 @@ function step(name, args, result) {
 
     const troca = nomeDeAba(name, args || {});
     if (troca) entrarNaAba(troca);
-    if (!state.abaAtual && ACOES_NA_TELA.has(name)) entrarNaAba('Tela');
+    if (!state.abaAtual) entrarNaAba('🖥 Tela');
 
     state.passo++;
     if (state.abaAtual) state.abaAtual.passos++;
@@ -246,11 +300,7 @@ function capturar(entrada) {
     if (agora - state.liveAt < 900) {
         try { fs.copyFileSync(LIVE(), arquivo); } catch { return null; }
         state.proximoFrame++;
-        state.frames.push({ id, hora: entrada.hora, acao: entrada.acao, aba: entrada.aba });
-        while (state.frames.length > MAX_FRAMES) {
-            const velho = state.frames.shift();
-            try { fs.unlinkSync(path.join(DIR, `frame-${velho.id}.png`)); } catch {}
-        }
+        registrarFrame({ id, hora: entrada.hora, acao: entrada.acao, aba: entrada.aba }, arquivo);
         return id;
     }
 
@@ -259,11 +309,7 @@ function capturar(entrada) {
 
     state.erroFoto = null;
     state.proximoFrame++;
-    state.frames.push({ id, hora: entrada.hora, acao: entrada.acao, aba: entrada.aba });
-    while (state.frames.length > MAX_FRAMES) {
-        const velho = state.frames.shift();
-        try { fs.unlinkSync(path.join(DIR, `frame-${velho.id}.png`)); } catch {}
-    }
+    registrarFrame({ id, hora: entrada.hora, acao: entrada.acao, aba: entrada.aba }, arquivo);
     return id;
 }
 
@@ -274,11 +320,38 @@ function capturar(entrada) {
 
 // O mascote do CLI (▐▛███▜▌ …) redesenhado em SVG, célula a célula, na mesma
 // paleta: bloco cheio na cor viva, contorno na apagada.
-// Olhos e pés têm classe própria: a página anima (piscada e passinhos) por CSS.
-const MASCOTE_SVG = `<svg viewBox="0 0 9 3.6" aria-hidden="true">
-<g fill="#0891b2"><rect x="1" y="0" width="1" height="1"/><rect x="7" y="0" width="1" height="1"/><rect x="0" y="1" width="1" height="1" opacity=".7"/><rect x="8" y="1" width="1" height="1" opacity=".7"/><rect x="1" y="1" width="1" height="1"/><rect x="7" y="1" width="1" height="1"/></g>
-<g fill="#22d3ee"><rect x="2" y="0" width="5" height="1" rx=".12"/><rect x="2" y="1" width="5" height="1"/><rect class="pe pe1" x="1.9" y="2.2" width=".9" height=".5" rx=".1"/><rect class="pe pe2" x="3.4" y="2.2" width=".9" height=".5" rx=".1"/><rect class="pe pe1" x="4.9" y="2.2" width=".9" height=".5" rx=".1"/><rect class="pe pe2" x="6.4" y="2.2" width=".9" height=".5" rx=".1"/></g>
-<g fill="#0b1220"><rect class="olho" x="3" y=".35" width=".8" height=".5" rx=".1"/><rect class="olho" x="5.2" y=".35" width=".8" height=".5" rx=".1"/><rect x="3.9" y="1.25" width="1.2" height=".28" rx=".14"/></g>
+// O mascote: um robozinho PROGRAMADOR. A cabeça é um monitor com o prompt
+// "❯_" na tela (é isso que ele faz: linha de comando), antena com luz de
+// atividade e dois bracinhos que digitam num tecladinho. O anterior era um
+// bloco de pixels sem leitura nenhuma — não dizia "programação", não dizia
+// nada. Olhos, antena, mão e cursor têm classe própria: a animação é CSS.
+const MASCOTE_SVG = `<svg viewBox="0 0 44 40" aria-hidden="true">
+  <!-- antena com a luz de atividade -->
+  <line x1="22" y1="1.5" x2="22" y2="6" stroke="#0891b2" stroke-width="1.6" stroke-linecap="round"/>
+  <circle class="antena" cx="22" cy="2" r="2.3" fill="#22d3ee"/>
+  <!-- corpo/monitor -->
+  <rect x="4" y="6" width="36" height="24" rx="5" fill="#0e2233" stroke="#22d3ee" stroke-width="1.8"/>
+  <rect x="7.5" y="9.5" width="29" height="17" rx="3" fill="#071522"/>
+  <!-- olhos -->
+  <g fill="#22d3ee">
+    <rect class="olho" x="12" y="14" width="5" height="6" rx="2.2"/>
+    <rect class="olho" x="27" y="14" width="5" height="6" rx="2.2"/>
+  </g>
+  <!-- o prompt: ❯ e o cursor piscando (é um programador, afinal) -->
+  <path d="M12.5 23.2 l2.4 1.5 -2.4 1.5" fill="none" stroke="#5eead4" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+  <rect class="cursor" x="17" y="23" width="4.5" height="3.2" rx=".6" fill="#5eead4"/>
+  <!-- braços + teclado -->
+  <g stroke="#0891b2" stroke-width="1.8" stroke-linecap="round">
+    <path class="braco braco1" d="M6 27 L3.5 33"/>
+    <path class="braco braco2" d="M38 27 L40.5 33"/>
+  </g>
+  <rect x="8" y="33" width="28" height="5" rx="2" fill="#12384d" stroke="#0891b2" stroke-width="1.2"/>
+  <g fill="#22d3ee" opacity=".85">
+    <rect class="tecla t1" x="11" y="35" width="4" height="1.6" rx=".6"/>
+    <rect class="tecla t2" x="17" y="35" width="4" height="1.6" rx=".6"/>
+    <rect class="tecla t3" x="23" y="35" width="4" height="1.6" rx=".6"/>
+    <rect class="tecla t1" x="29" y="35" width="4" height="1.6" rx=".6"/>
+  </g>
 </svg>`;
 
 // A tela do painel, na identidade do app — a MESMA paleta do design system do
@@ -288,8 +361,10 @@ const MASCOTE_SVG = `<svg viewBox="0 0 9 3.6" aria-hidden="true">
 // embaixo. Dentro da tela roda o VÍDEO ao vivo (o loop de captura acima); as
 // abas em cima são tudo que o agente abriu — clicáveis, cada uma com seus
 // quadros e passos; e a barra de comando autopreenche a instrução digitando.
+// O favicon é o próprio mascote — o viewBox vem dele, não fixo (já ficou
+// errado uma vez quando o desenho mudou de tamanho e o número aqui não).
 const FAVICON = 'data:image/svg+xml,' + encodeURIComponent(
-    `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 9 3.6">${MASCOTE_SVG.replace(/^<svg[^>]*>|<\/svg>$/g, '')}</svg>`,
+    MASCOTE_SVG.replace('<svg ', '<svg xmlns="http://www.w3.org/2000/svg" '),
 );
 
 const PAGINA = `<!doctype html>
@@ -308,16 +383,24 @@ const PAGINA = `<!doctype html>
 
   /* ── Cabeçalho: mascote inclinado + nome, como no desenho ── */
   #topo { position: relative; width: min(1120px, 100%); padding: 44px 0 26px; text-align: center; }
-  #topo .mascote { position: absolute; left: 4px; top: 24px; width: 104px; height: 44px; filter: drop-shadow(0 8px 20px rgba(34,211,238,.4)); animation: flutua 2.8s ease-in-out infinite; }
-  @keyframes flutua { 0%, 100% { transform: translateY(0) } 50% { transform: translateY(6px) } }
+  #topo .mascote { position: absolute; left: 8px; top: 18px; width: 62px; height: 56px; filter: drop-shadow(0 8px 20px rgba(34,211,238,.35)); animation: flutua 3s ease-in-out infinite; }
+  @keyframes flutua { 0%, 100% { transform: translateY(0) } 50% { transform: translateY(5px) } }
   #topo .mascote svg { width: 100%; height: 100%; display: block; overflow: visible; }
-  /* vivo: pisca os olhos de vez em quando e dá passinhos com os pés */
-  .mascote .olho { transform-box: fill-box; transform-origin: center; animation: piscaOlho 3.6s infinite; }
-  @keyframes piscaOlho { 0%, 89%, 100% { transform: scaleY(1) } 93%, 95% { transform: scaleY(.12) } }
-  .mascote .pe { transform-box: fill-box; transform-origin: center; }
-  .mascote .pe1 { animation: passinho 1.4s ease-in-out infinite; }
-  .mascote .pe2 { animation: passinho 1.4s ease-in-out infinite; animation-delay: .7s; }
-  @keyframes passinho { 0%, 100% { transform: translateY(0) } 50% { transform: translateY(-.14px) } }
+  /* vivo: pisca os olhos, o cursor do prompt pisca, a antena respira e as
+     mãozinhas digitam no teclado */
+  .mascote .olho { transform-box: fill-box; transform-origin: center; animation: piscaOlho 4s infinite; }
+  @keyframes piscaOlho { 0%, 91%, 100% { transform: scaleY(1) } 94%, 96% { transform: scaleY(.1) } }
+  .mascote .cursor { animation: piscaCursor 1.05s steps(1) infinite; }
+  @keyframes piscaCursor { 50% { opacity: 0 } }
+  .mascote .antena { animation: respira 2.2s ease-in-out infinite; }
+  @keyframes respira { 0%, 100% { opacity: 1; r: 2.3 } 50% { opacity: .55; r: 1.9 } }
+  .mascote .braco { transform-box: fill-box; transform-origin: top center; }
+  .mascote .braco1 { animation: digita .62s ease-in-out infinite; }
+  .mascote .braco2 { animation: digita .62s ease-in-out infinite; animation-delay: .31s; }
+  @keyframes digita { 0%, 100% { transform: translateY(0) } 50% { transform: translateY(1.6px) } }
+  .mascote .tecla { animation: teclaAcende 1.24s steps(1) infinite; }
+  .mascote .t2 { animation-delay: .31s } .mascote .t3 { animation-delay: .62s }
+  @keyframes teclaAcende { 0%, 74% { opacity: .35 } 75%, 99% { opacity: 1 } }
   #topo h1 { font-size: clamp(34px, 5.6vw, 54px); font-weight: 650; letter-spacing: .4px; color: #f1f5f9; text-shadow: 0 4px 28px rgba(34,211,238,.22); }
   #topo h1 span { color: #22d3ee; }
   #topo .vivo { position: absolute; right: 2px; top: 48px; display: inline-flex; align-items: center; gap: 8px; color: #94a3b8; font-size: 12.5px; background: rgba(15,23,42,.85); border: 1px solid #1e293b; border-radius: 999px; padding: 6px 14px; }
@@ -645,6 +728,7 @@ function start() {
             // primeiro quadro está no ar — nada de tela vazia esperando ação.
             state.viewerAt = Date.now();
             agendarVideo(50);
+            armarFaxina();
             resolve(state.url);
         });
     });
@@ -656,6 +740,20 @@ function stop() {
     state.server = null;
     state.on = false;
     state.url = '';
+    limparDisco();   // desligou o painel, as fotos vão junto
+}
+
+// Fechou o PrimoCode (/exit, Ctrl+C, Ctrl+D): nada de print esquecido no
+// disco. `exit` cobre a saída normal; os sinais cobrem o resto.
+let faxinaArmada = false;
+function armarFaxina() {
+    if (faxinaArmada) return;
+    faxinaArmada = true;
+    const faxina = () => { try { limparDisco(); } catch {} };
+    process.once('exit', faxina);
+    for (const sinal of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
+        process.once(sinal, () => { faxina(); process.exit(0); });
+    }
 }
 
-module.exports = { start, stop, step, instrucao, isOn, url, descrever };
+module.exports = { start, stop, step, instrucao, isOn, url, descrever, limparDisco };

package/lib/tools.js

@@ -13,6 +13,7 @@ const os = require('os');
 const { exec } = require('child_process');
 const browser = require('./browser');
 const desktop = require('./desktop');
+const referencia = require('./referencia');
 
 const IGNORAR = new Set(['node_modules', '.git', 'dist', 'build', '.next', 'coverage', '.cache', 'vendor']);
 const MAX_ARQUIVOS_VARREDURA = 5000;
@@ -388,6 +389,15 @@ async function despachar(name, args, ctx) {
             case 'write_todos':
                 return writeTodos(args);
 
+            // Pesquisa de referência: abre documentação e exemplos sobre o
+            // pedido e devolve o TEXTO para o modelo aprender antes de
+            // escrever. Aparece no terminal e no /streaming — nada oculto.
+            case 'pesquisar_referencia':
+                return referencia.pesquisar({
+                    consulta: args.consulta || args.query || '',
+                    paginas: Math.max(1, Math.min(5, Number(args.paginas) || 3)),
+                });
+
             // ── Navegador controlado (CDP) — o agente age numa página real ──
             case 'browser_open': {
                 const alvo = /^https?:\/\//i.test(args.url || '')

package/lib/ui.js

@@ -157,13 +157,13 @@ 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',
+    '/help lista tudo · /effort ajusta o esforço · /streaming mostra ao vivo',
 ];
 
 const NEWS = [
-    '/streaming agora é VÍDEO ao vivo — assista ele trabalhando, aba por aba',
-    'Comandos se autopreenchem: /str + Tab (ou Enter) vira /streaming',
-    'Ele INTERAGE com o computador: janelas, botões e ícones pelo nome',
+    '/effort escolhe o esforço num slider — do rápido ao mais esperto',
+    'Do "high" para cima ele PESQUISA referências antes de escrever',
+    'Esc Esc para o agente · /streaming mostra tudo ao vivo, e limpa os prints',
 ];
 
 // ── Cabeçalho ────────────────────────────────────────────────────────────
@@ -302,7 +302,7 @@ function actionHeader(name, args) {
         read_file:'Read', write_file:'Write', edit_file:'Edit', multi_edit:'MultiEdit',
         list_dir:'List', glob:'Glob', grep:'Grep', run_shell:'Bash',
         run_in_new_terminal:'Terminal', open_in_browser:'Open', spawn_agent:'Agent',
-        write_todos:'Plano', finish:'Finish',
+        write_todos:'Plano', finish:'Finish', pesquisar_referencia:'Pesquisa',
         browser_open:'Browser', browser_click:'Browser·click', browser_type:'Browser·type',
         browser_key:'Browser·key', browser_read:'Browser·read', browser_screenshot:'Browser·shot',
         browser_scroll:'Browser·scroll', browser_wait:'Browser·wait', browser_eval:'Browser·eval',
@@ -314,7 +314,7 @@ function actionHeader(name, args) {
         desktop_elements:'Desktop·elementos', desktop_click_element:'Desktop·click',
     };
     const label = nice[name] || name;
-    const argStr = args ? (args.path || args.pattern || args.command || args.target || args.url || args.selector || args.text || args.app || args.window || args.name || args.description || (args.todos ? `${args.todos.length} tarefas` : '') || (args.x != null ? `${args.x},${args.y}` : '') || args.key || JSON.stringify(args).slice(0,60)) : '';
+    const argStr = args ? (args.consulta || args.path || args.pattern || args.command || args.target || args.url || args.selector || args.text || args.app || args.window || args.name || args.description || (args.todos ? `${args.todos.length} tarefas` : '') || (args.x != null ? `${args.x},${args.y}` : '') || args.key || JSON.stringify(args).slice(0,60)) : '';
     return `  ${c.dim('⎿')} ${c.brand(label)}${argStr ? ' '+c.muted(argStr) : ''}`;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "7.15.0",
+  "version": "7.16.0",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Modelos grátis. Cria arquivos, roda comandos, controla navegador e desktop: abre apps, clica em botões e ícones pelo nome, digita e usa atalhos.",
   "main": "bin/primocode.js",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "start": "node bin/primocode.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 && node test/desktop.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 && node test/desktop.test.js && node test/effort.test.js"
   },
   "engines": {
     "node": ">=18.17.0"