primocode 7.15.0 → 7.17.0

package/bin/primocode.js

@@ -22,7 +22,7 @@ const cfg = require('../lib/config');
 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 +48,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
@@ -56,7 +56,6 @@ ${c.bold('Comandos')}
   ${c.brand('/read')} <arquivo>       mostra um arquivo
   ${c.brand('/run')} <comando>        executa no shell do projeto
   ${c.brand('/open')} <arquivo|url>   abre no navegador
-  ${c.brand('/streaming')}            painel ao vivo — veja o agente mexendo no computador
   ${c.brand('/status')}               checa o servidor
   ${c.brand('/name')} <nome>          como o Primo te chama
   ${c.brand('/mascot')} <estilo>      mascote: primo|fox|cat
@@ -80,14 +79,14 @@ ${c.bold('Onde ele trabalha')}
 
 // ── Autopreenchimento dos comandos (estilo Claude Code) ────────────────
 // Metade do comando já serve: Tab completa, e um prefixo único executa
-// direto — "/str" vira "/streaming" sozinho. A lista é só a dos nomes
+// direto — "/eff" vira "/effort" sozinho. A lista é só a dos nomes
 // canônicos; os apelidos (/cd, /stream…) continuam valendo por extenso.
 const SLASH_COMANDOS = [
     ['/help', 'todos os 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'],
@@ -96,7 +95,6 @@ const SLASH_COMANDOS = [
     ['/read', 'mostra um arquivo'],
     ['/run', 'roda um comando'],
     ['/open', 'abre no navegador'],
-    ['/streaming', 'painel ao vivo — vídeo dele trabalhando'],
     ['/status', 'checa o servidor'],
     ['/name', 'como ele te chama'],
     ['/mascot', 'primo | fox | cat'],
@@ -117,12 +115,111 @@ 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) {
         console.log(`  ${c.brand(ui.padRight(nome, 12))}${c.muted(desc)}`);
     }
-    console.log(c.dim('\n  Tab completa · metade do comando já serve: /str vira /streaming'));
+    console.log(c.dim('\n  Tab completa · metade do comando já serve: /eff vira /effort'));
 }
 
 let rl = null;
@@ -309,6 +406,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 +562,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]) {
-                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.
+            if (m.includes('/')) {
                 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;
         }
 
@@ -552,33 +664,6 @@ async function handleSlash(text) {
             break;
         }
 
-        // Painel ao vivo: um servidorzinho local mostra cada ação do agente na
-        // tela + a foto tirada logo depois dela. Liga/desliga; /streaming on|off
-        // também funciona.
-        case 'streaming': case 'stream': case 'live': {
-            const pedido = rest.toLowerCase();
-            const ligar = pedido === 'on' ? true : pedido === 'off' ? false : !streaming.isOn();
-
-            if (!ligar) {
-                if (streaming.isOn()) { streaming.stop(); console.log(c.ok('Streaming desligado.')); }
-                else console.log(c.muted('O streaming já estava desligado.'));
-                break;
-            }
-            if (streaming.isOn()) {
-                console.log(c.muted(`Já está ligado: ${streaming.url()}`));
-                break;
-            }
-            try {
-                const url = await streaming.start();
-                console.log(c.ok('Streaming ligado: ') + c.white(url));
-                console.log(c.muted('  Dê uma instrução e veja cada passo dele aí, ao vivo. /streaming de novo desliga.'));
-                await tools.openInBrowser(url);
-            } catch (e) {
-                console.log(c.err(`Não consegui ligar o streaming: ${e.message}`));
-            }
-            break;
-        }
-
         case 'name': {
             if (!rest) { console.log(c.muted(`  Nome atual: ${state.config.userName || '(nenhum)'}`)); break; }
             state.config.userName = rest;
@@ -613,7 +698,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}`));
@@ -654,7 +740,7 @@ async function handleSlash(text) {
         case 'exit': case 'quit': if (rl) rl.close(); break;
         default: {
             // "/" sozinho abre o menu; um prefixo único autopreenche e executa
-            // ("/str" → /streaming); prefixo ambíguo mostra as opções.
+            // ("/eff" → /effort); prefixo ambíguo mostra as opções.
             if (!cmd) { mostrarMenuSlash(); break; }
             const casam = SLASH_COMANDOS.map(([nome]) => nome.slice(1)).filter((n) => n.startsWith(cmd.toLowerCase()));
             if (casam.length === 1) {
@@ -733,6 +819,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 +853,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 +872,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

@@ -15,10 +15,6 @@ const tools = require('./tools');
 const api = require('./api');
 const cfg = require('./config');
 const catalogo = require('./catalogo');
-// "painel", não "streaming": dentro do runAct existe um `let streaming` (a
-// flag de texto chegando em stream) que SOMBREARIA este módulo — e o step()
-// viraria TypeError engolido pelo catch. Foi um bug real, pego em teste.
-const painel = require('./streaming');
 
 const MAX_ITERATIONS = 15;
 const MAX_PROFUNDIDADE = 2; // principal + 1 nível de subagente
@@ -105,6 +101,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 +172,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.
@@ -193,11 +197,6 @@ async function runAct(userPrompt, opts) {
 
     let finalText = '';
 
-    // O pedido do usuário aparece na barra de comando do painel, digitado
-    // letra a letra — só o pedido principal; sub-tarefa de agente não é
-    // instrução de gente.
-    if (!subagent) { try { painel.instrucao(userPrompt); } catch {} }
-
     // Pedido novo zera o pedido de parada anterior.
     if (!subagent) PARAR = false;
 
@@ -210,7 +209,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) {
@@ -300,10 +299,6 @@ async function runAct(userPrompt, opts) {
             const result = await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual });
             logResult(tc.name, result, profundidade);
 
-            // Painel ao vivo (/streaming): registra o passo e fotografa a tela.
-            // Nunca pode derrubar o loop — falha de foto é problema do painel.
-            try { painel.step(tc.name, tc.arguments, result); } catch {}
-
             // Uma escrita bem-sucedida limpa a dívida: o agente se corrigiu.
             if (result && result.ok === false) falhasPendentes.push(`${tc.name}(${tc.arguments?.path || ''}): ${result.error}`);
             else if (['write_file', 'edit_file'].includes(tc.name)) falhasPendentes.length = 0;

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

@@ -659,8 +659,8 @@ function clickElement(nome, opts = {}) {
 }
 
 // ── Screenshot ────────────────────────────────────────
-// A ferramenta do Linux é resolvida UMA vez: o vídeo do /streaming chama isto
-// várias vezes por segundo, e um `which` por frame seria desperdício.
+// A ferramenta do Linux é resolvida UMA vez: um `which` a cada screenshot
+// seria desperdício.
 let LINUX_SHOT;
 function linuxShot() {
     if (LINUX_SHOT === undefined) LINUX_SHOT = firstCmd(['scrot', 'maim', 'gnome-screenshot', 'spectacle', 'import']);
@@ -669,8 +669,8 @@ function linuxShot() {
 
 /**
  * O comando de shell que fotografa a tela para `filename` — ou null quando a
- * plataforma não tem como. Existe separado do screenshot() para o painel do
- * /streaming capturar em LOOP, assíncrono, sem travar o agente.
+ * plataforma não tem como. Existe separado do screenshot() para quem precisa
+ * capturar de forma assíncrona, sem travar o processo.
  */
 function screenshotCommand(filename) {
     if (PLATFORM === 'darwin') return `screencapture -x "${filename}"`;

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 };