@neetru/cli 2.32.1 → 2.34.0

package/dist/commands/auth.js

@@ -1,33 +1,47 @@
 /**
  * `neetru auth` — gerencia credenciais dos provedores de IA usados pelo
- * `neetru ai` (Anthropic, OpenAI, Gemini).
+ * `neetru ai`: os da lista única (`lib/ai/provedores.ts` — Groq, NVIDIA NIM e
+ * OpenAI). O AI Gateway da Neetru não precisa de chave: basta `neetru login`.
  *
  * Sub-comandos:
- *   neetru auth status   → lista provedores detectados (binário + creds)
- *   neetru auth setup    → wizard interativo: detecta, instala faltantes,
- *                          guia login
- *   neetru auth pull     → puxa creds dos CLIs concorrentes pra config do Neetru
+ *   neetru auth status   → estado de cada provedor (chave achada ou não)
+ *   neetru auth setup    → wizard interativo: mostra o estado e pede a chave
+ *                          que falta
+ *   neetru auth pull     → copia pra config do Neetru a chave achada no
+ *                          arquivo do Codex (a do ambiente já é lida direto)
  *
- * Objetivo: zerar fricção do "anthropicApiKey não configurada". Se user
- * já tem Claude Code/Codex/Gemini, reaproveita.
+ * bug_19d312f3: o wizard oferecia Claude (Anthropic) e Gemini (Google), vetados
+ * pela casa, e não oferecia Groq nem NVIDIA. Agora ele percorre a lista única.
  */
 import chalk from 'chalk';
 import * as readline from 'readline/promises';
 import inquirer from 'inquirer';
 import { detectAllProviders, installGlobal, } from '../lib/ai/auth-discovery.js';
+import { CHAVE_DO_PROVEDOR, NOME_DO_PROVEDOR, PROVEDORES_IA } from '../lib/ai/provedores.js';
 import { config } from '../lib/config.js';
 import { log } from '../utils/logger.js';
-import { saveMfaSession } from '../lib/cli-write.js';
-const PROVIDER_TO_CONFIG = {
-    anthropic: 'anthropicApiKey',
-    openai: 'openaiApiKey',
-    gemini: 'geminiApiKey',
-    groq: 'groqApiKey',
-    nvidia: 'nvidiaApiKey',
-};
-function badge(s) {
-    if (s.apiKey)
+import { loadMfaSession, saveMfaSession } from '../lib/cli-write.js';
+/**
+ * Chave achada na máquina que pode ser copiada para a config do Neetru.
+ *
+ * A do ambiente (GROQ_API_KEY, NVIDIA_API_KEY, OPENAI_API_KEY) NÃO é copiada:
+ * a CLI já a lê direto da variável a cada uso, e a cópia passaria a valer mais
+ * que ela (a config vem primeiro) — trocar a chave na variável deixaria a CLI
+ * usando a antiga, com 401 sem pista de onde ela vem (revisão do #104). A do
+ * arquivo do Codex continua sendo copiada, como antes.
+ */
+function chaveCopiavel(s) {
+    return s.credentialSource === 'env' ? undefined : s.apiKey;
+}
+function badge(s, naConfig = false) {
+    // Chave gravada na config do Neetru também conta como pronto (revisão do
+    // #104: o assistente mostrava "sem chave" e pedia de novo um provedor já
+    // configurado com `neetru config set`).
+    if (s.apiKey || naConfig)
         return chalk.green('✓ pronto');
+    // Provedor só de chave (Groq, NVIDIA): não há programa para instalar.
+    if (!s.binary)
+        return chalk.dim('- sem chave');
     if (s.installed && s.credentialSource)
         return chalk.yellow('! login parcial');
     if (s.installed)
@@ -35,31 +49,14 @@ function badge(s) {
     return chalk.dim('- não instalado');
 }
 function rowName(p) {
-    switch (p) {
-        case 'anthropic':
-            return 'Claude (Anthropic)';
-        case 'openai':
-            return 'Codex (OpenAI)';
-        case 'gemini':
-            return 'Gemini (Google)';
-        case 'groq':
-            return 'Groq';
-        case 'nvidia':
-            return 'NVIDIA NIM';
-    }
+    return NOME_DO_PROVEDOR[p];
 }
 /**
  * `neetru auth status` — pura leitura, mostra tabela.
  */
 export async function runAuthStatus(opts = {}) {
     const providers = detectAllProviders();
-    const configured = {
-        anthropic: !!config.get('anthropicApiKey'),
-        openai: !!config.get('openaiApiKey'),
-        gemini: !!config.get('geminiApiKey'),
-        groq: !!config.get('groqApiKey'),
-        nvidia: !!config.get('nvidiaApiKey'),
-    };
+    const configured = Object.fromEntries(PROVEDORES_IA.map((p) => [p, !!config.get(CHAVE_DO_PROVEDOR[p])]));
     if (opts.json) {
         console.log(JSON.stringify({
             providers: providers.map((p) => ({
@@ -72,33 +69,46 @@ export async function runAuthStatus(opts = {}) {
     }
     console.log(chalk.bold('\nNeetru Auth — status dos provedores de IA\n'));
     for (const p of providers) {
-        const configuredHere = configured[p.provider] ? chalk.green('(neetru config OK)') : '';
-        console.log(`  ${badge(p)}  ${chalk.bold(rowName(p.provider))}  ${configuredHere}`);
-        console.log(`        ${chalk.dim(p.hint)}`);
+        const naConfig = configured[p.provider];
+        const configuredHere = naConfig ? chalk.green('(neetru config OK)') : '';
+        console.log(`  ${badge(p, naConfig)}  ${chalk.bold(rowName(p.provider))}  ${configuredHere}`);
+        // A chave da config vem antes da achada na máquina (`resolveKeyPool` no
+        // orchestrator): com ela gravada, é ela que a CLI usa.
+        const dica = naConfig ? 'usando a chave gravada na config do Neetru' : p.hint;
+        console.log(`        ${chalk.dim(dica)}`);
     }
     console.log();
     console.log(chalk.dim('Para configurar tudo de uma vez: neetru auth setup'));
 }
 /**
- * `neetru auth pull` — sem perguntar, copia toda apiKey extraída dos CLIs
- * concorrentes pra config do Neetru. Útil pra CI/script.
+ * `neetru auth pull` — sem perguntar, copia pra config do Neetru a chave achada
+ * no arquivo do Codex. A do ambiente não é copiada: a CLI já a lê direto da
+ * variável (ver `chaveCopiavel`). Não sobrescreve chave já configurada.
  */
 export async function runAuthPull(opts = {}) {
     const providers = detectAllProviders();
     const copied = [];
+    const doAmbiente = [];
     for (const p of providers) {
-        if (!p.apiKey)
+        const chave = chaveCopiavel(p);
+        if (!chave) {
+            if (p.apiKey)
+                doAmbiente.push(p.provider);
             continue;
-        const cfgKey = PROVIDER_TO_CONFIG[p.provider];
+        }
+        const cfgKey = CHAVE_DO_PROVEDOR[p.provider];
         if (config.get(cfgKey))
             continue; // não sobrescreve
-        config.set(cfgKey, p.apiKey);
+        config.set(cfgKey, chave);
         copied.push(p.provider);
     }
     if (opts.json) {
         console.log(JSON.stringify({ copied }, null, 2));
         return;
     }
+    if (doAmbiente.length) {
+        log.dim(`Lidas direto do ambiente, sem cópia: ${doAmbiente.map(rowName).join(', ')}.`);
+    }
     if (copied.length === 0) {
         log.info('Nenhuma cred nova para copiar (ou já estão configuradas).');
         return;
@@ -126,28 +136,32 @@ export async function runAuthSetup(opts = {}) {
         // Modo não-interativo: só roda pull silencioso.
         return runAuthPull(opts);
     }
+    const naConfig = (p) => !!config.get(CHAVE_DO_PROVEDOR[p.provider]);
     console.log(chalk.bold('\nNeetru Auth — wizard de configuração\n'));
     console.log(chalk.dim('Detectado:\n'));
     for (const p of providers) {
-        console.log(`  ${badge(p)}  ${rowName(p.provider)}`);
+        console.log(`  ${badge(p, naConfig(p))}  ${rowName(p.provider)}`);
     }
     console.log();
-    // Pull silencioso de tudo que já tá pronto.
+    // Pull silencioso do que dá para copiar (o arquivo do Codex). A chave do
+    // ambiente não é copiada: a CLI já a lê direto (ver `chaveCopiavel`).
     const autoConfigured = [];
     for (const p of providers) {
-        if (!p.apiKey)
+        const chave = chaveCopiavel(p);
+        if (!chave)
             continue;
-        const cfgKey = PROVIDER_TO_CONFIG[p.provider];
+        const cfgKey = CHAVE_DO_PROVEDOR[p.provider];
         if (!config.get(cfgKey)) {
-            config.set(cfgKey, p.apiKey);
+            config.set(cfgKey, chave);
             autoConfigured.push(p.provider);
         }
     }
     if (autoConfigured.length) {
         log.success(`Reaproveitadas creds de: ${autoConfigured.join(', ')}`);
     }
-    // Identifica provedores que precisam de ação (sem cred ou sem binário).
-    const needsAction = providers.filter((p) => !p.apiKey);
+    // Identifica provedores que precisam de ação: sem chave achada na máquina E
+    // sem chave na config do Neetru.
+    const needsAction = providers.filter((p) => !p.apiKey && !naConfig(p));
     if (needsAction.length === 0) {
         log.success('Todos os provedores prontos. Você pode rodar `neetru ai`.');
         return;
@@ -167,8 +181,9 @@ export async function runAuthSetup(opts = {}) {
         }
         for (const p of wanted) {
             console.log(chalk.bold(`\n→ ${rowName(p.provider)}`));
-            // Instalar binário se ausente.
-            if (!p.installed) {
+            // Instalar binário se ausente. Provedor só de chave (Groq, NVIDIA) não
+            // tem programa: vai direto pedir a chave.
+            if (p.npmPackage && !p.installed) {
                 const install = await confirm(rl, `  Instalar ${p.npmPackage} globalmente?`, true);
                 if (install) {
                     log.info(`Rodando: npm install -g ${p.npmPackage}`);
@@ -184,10 +199,10 @@ export async function runAuthSetup(opts = {}) {
                     continue;
                 }
             }
-            else {
+            else if (p.binary) {
                 log.dim(`  ${p.binary} já instalado.`);
             }
-            // Pedir api key direto (mais simples que mandar usuário pro `claude /login`).
+            // Pedir api key direto (mais simples que mandar o usuário logar no programa).
             const provideKey = await confirm(rl, `  Colar API key agora? (alternativa: ${p.hint.replace(/^.*— /, '')})`, true);
             if (provideKey) {
                 // Auditoria UX 2026-09: a API key é SEGREDO — não pode ecoar na tela/
@@ -206,16 +221,19 @@ export async function runAuthSetup(opts = {}) {
                     rl.resume();
                 }
                 if (key) {
-                    config.set(PROVIDER_TO_CONFIG[p.provider], key);
+                    config.set(CHAVE_DO_PROVEDOR[p.provider], key);
                     log.success(`${rowName(p.provider)} configurado.`);
                 }
                 else {
                     log.warn('Vazio — não configurado.');
                 }
             }
-            else {
+            else if (p.binary) {
                 log.dim(`Use o login do ${p.binary} ou rode "neetru auth pull" depois pra puxar.`);
             }
+            else {
+                log.dim(`Depois, ${p.hint.replace(/^.*— /, '')}.`);
+            }
         }
         console.log();
         log.success('Wizard finalizado. Rode `neetru ai` pra testar.');
@@ -292,6 +310,27 @@ export async function runAuthMfaSession(opts = {}) {
     }
     // Salva o token localmente para uso automático em operações destrutivas.
     await saveMfaSession(res.mfaSessionToken, res.expiresAt);
+    // bug_757b9746: `saveMfaSession` engole a falha de gravação, e este comando
+    // respondia `saved: true` + "usarão esta sessão automaticamente" sem conferir
+    // nada — se a gravação falhasse, o comando destrutivo seguinte pedia o TOTP de
+    // novo e a mensagem tinha mentido. Confere lendo de volta pelo MESMO caminho
+    // que os comandos destrutivos usam (`loadMfaSession`): pega a gravação que
+    // falhou e também o `expiresAt` que o relógio desta máquina já dá por vencido.
+    if (loadMfaSession() !== res.mfaSessionToken) {
+        const msg = 'A sessão MFA foi aberta no Core, mas não ficou gravada nesta máquina ' +
+            '(~/.config/neetru-cli/mfa-session.json) ou o relógio daqui já a dá por vencida. ' +
+            'Os comandos destrutivos vão pedir o código TOTP de novo. Confira a permissão ' +
+            'dessa pasta e a hora do sistema, e rode `neetru auth mfa-session` outra vez com um código novo.';
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: false, error: 'mfa_session_not_saved', message: msg, saved: false }));
+        }
+        else {
+            log.error(msg);
+        }
+        const { safeExit } = await import('../utils/safe-exit.js');
+        safeExit(1);
+        return;
+    }
     if (opts.json) {
         console.log(JSON.stringify({
             ok: true,

package/dist/commands/build.js

@@ -30,12 +30,13 @@ import { safeExit } from '../utils/safe-exit.js';
 import { normalizeTarget } from './env.js';
 import { RUNTIME_ENVIRONMENT_IDS } from '../lib/envs.js';
 import { formatChoices } from '../cli-kit/choices.js';
+import { adviseFlag } from '../cli-kit/command-context.js';
 import { registerSpinner, unregisterSpinner } from '../utils/spinner-registry.js';
 import { CodificacaoInvalida, decodificarUtf8, semBomInicial } from '../lib/texto-utf8.js';
 import { variaveisDoEnvFile } from '../lib/env-file-do-build.js';
 // bug_678ddc98: detecção de alvo — diretório do app, gerenciador de pacote e
 // layout do standalone (possivelmente aninhado). Ver `src/lib/build-targets.ts`.
-import { detectPackageManager, comandoInstall, comandoRunScript, comandoExecBin, resolveStandaloneLayout, baseDeInjecaoNoTar, } from '../lib/build-targets.js';
+import { detectPackageManager, comandoInstall, comandoRunScript, comandoExecBin, resolveStandaloneLayout, lerRelativeAppDir, baseDeInjecaoNoTar, } from '../lib/build-targets.js';
 const CONFIG_FILENAMES = ['neetru.config.json', '.neetru.json'];
 function fileExists(p) {
     try {
@@ -542,12 +543,20 @@ pm = { name: 'npm', rootDir: cwd, source: 'default' }) {
                 }
             }
             else {
-                lg.dim(`  --no-cache ignorado: ${pm.name} não tem \`cache clean --force\`.`);
+                lg.dim(`  --no-cache ignorado: ${pm.name} não tem equivalente ao \`npm cache clean --force\`.`);
             }
         }
         if (process.platform === 'win32') {
+            // bug_89d2497e (etapa 1): o `neetru deploy` chega aqui pelo `runBuild`
+            // (sem artefato pronto) e não declara --no-install — quem seguia o
+            // conselho batia em "unknown option". Só o `neetru build` ouve a flag; o
+            // deploy recebe só o pedido de pausar o dev server.
             lg.warn(`Se houver \`next dev\` ativo na pasta, ele pode conflitar com o ${install.cmd} install (file locks).\n` +
-                `  Pause o dev server antes do build, ou use --no-install pra pular esta etapa.`);
+                adviseFlag({
+                    flag: '--no-install',
+                    withFlag: '  Pause o dev server antes do build, ou use --no-install pra pular esta etapa.',
+                    withoutFlag: '  Pause o dev server antes de continuar.',
+                }));
         }
         // bug_678ddc98: o install roda na RAIZ do workspace (onde mora o lockfile),
         // não no diretório do app — `pnpm install` dentro de `apps/web` sem o
@@ -620,9 +629,31 @@ pm = { name: 'npm', rootDir: cwd, source: 'default' }) {
     // Next.js aninha o app dentro do standalone (`apps/web/server.js`) e esse
     // caminho fixo apontava pro vazio. Agora vem do layout real pós-build.
     if (standalone && isStandaloneBuildDir(cwd) && !layout) {
+        // bug_678ddc98: quando o Next.js declarou o lugar do app
+        // (`relativeAppDir`), o motivo do aborto é outro e a mensagem diz qual.
+        const declarado = lerRelativeAppDir(cwd);
+        if (declarado.tipo === 'declarado') {
+            const prefixo = declarado.prefixo;
+            throw new Error(`O Next.js registrou o app ${prefixo ? `em \`${prefixo}\`` : 'na raiz do standalone'} ` +
+                '(campo `relativeAppDir` de `.next/required-server-files.json`), ' +
+                `mas \`.next/standalone/${prefixo ? `${prefixo}/` : ''}server.js\` não existe. ` +
+                'Isso costuma indicar uma pasta `.next` com restos de builds diferentes: apague a pasta `.next` do app, ' +
+                'rode o build de novo e confira se `output: "standalone"` está ativo. ' +
+                'Abortando: um tarball sem entrypoint sobe e nunca inicia.');
+        }
+        if (declarado.tipo === 'invalido') {
+            throw new Error(`O campo \`relativeAppDir\` de \`.next/required-server-files.json\` vale "${declarado.valor}" ` +
+                'e aponta para fora do standalone: o `outputFileTracingRoot` do next.config precisa ser uma pasta ' +
+                'ACIMA do app (no monorepo, a raiz do repositório). ' +
+                'Abortando: um tarball sem entrypoint sobe e nunca inicia.');
+        }
         throw new Error('Existe `.next/standalone` mas nenhum `server.js` foi encontrado dentro dele. ' +
             'Num monorepo o Next.js aninha o app sob o `outputFileTracingRoot` (ex: `apps/web/server.js`) — ' +
-            'confira se o build rodou no diretório certo (use `--app <dir>`) e se `output: "standalone"` está ativo. ' +
+            // bug_89d2497e (etapa 1): o `neetru deploy` chega aqui pelo `runBuild` e
+            // não declara --app; o conselho cita o `neetru build` inteiro. O artefato
+            // sai no diretório de onde o build roda, que é onde o deploy o procura.
+            'confira se o build rodou no diretório certo (rode `neetru build --app <dir>` no diretório de onde vai rodar o deploy) ' +
+            'e se `output: "standalone"` está ativo. ' +
             'Abortando: um tarball sem entrypoint sobe e nunca inicia.');
     }
     if (layout?.appPrefix) {

package/dist/commands/chat.d.ts

@@ -1,5 +1,5 @@
 import type { Command } from 'commander';
-import type { NeetruCliError } from '../cli-kit/errors.js';
+import { NeetruCliError } from '../cli-kit/errors.js';
 type ActorType = 'agent_claude' | 'human' | 'cli';
 type ChatChannelType = 'global' | 'product' | 'custom';
 export interface ChatChannelsOptions {
@@ -55,8 +55,9 @@ export interface ChatIdentityOptions {
  * nome. Sem aviso: a saída era o mesmo "✓ Apelido definido" do caminho feliz.
  *
  * Agora `show`/`ver` lê, `set`/`definir` grava o resto, `clear`/`limpar` limpa,
- * e o posicional antigo (`identity "PDV · IA"`) segue funcionando. O preço: não
- * dá pra ter um apelido que seja SÓ uma dessas palavras.
+ * e o posicional antigo (`identity "PDV · IA"`) segue funcionando — REVOGADO em
+ * 22/10, ver DEFAULT INVERTIDO abaixo. O preço: não dá pra ter um apelido que
+ * seja SÓ uma dessas palavras.
  *
  * P105 (2026-10-18): o conserto acima cobria só as palavras que ele conhecia.
  * `identity describe` gravava "describe", `identity list` gravava "list",
@@ -72,6 +73,20 @@ export interface ChatIdentityOptions {
  * Os caminhos citados (`neetru chat identity …`, `neetru chat send --as`) saem
  * da árvore do Commander (`contextoDeIdentidadeDaArvore`), não de literal
  * (revisão do #87, BAIXO 5).
+ *
+ * DEFAULT INVERTIDO (2026-10-22, encerramento do bug_09574d4b derrubado): os
+ * dois consertos acima eram LISTA DE PERMISSÃO — recusavam as 18 palavras que
+ * conheciam e gravavam todo o resto. Medido na 2.33.0 publicada: `identity
+ * mostrar`, `identity status`, `identity whoami`, `identity atual`, `identity
+ * apelido` (o alias do próprio comando) e `identity "Dev Core"` gravavam o
+ * argumento como apelido da credencial COMPARTILHADA, com o mesmo "✓ Apelido
+ * definido" do caminho feliz. Allowlist de verbo nunca fecha esse padrão: a
+ * pessoa sempre acha mais um verbo. Agora o posicional solto NÃO grava nunca —
+ * qualquer primeira palavra fora de `show`/`set`/`clear` (e seus equivalentes)
+ * é recusada, lista os subcomandos e ensina `identity set "<texto>"`. As únicas
+ * portas de escrita são `identity set "Nome"`, `identity clear` e o `--as` do
+ * `send` (que avisa no stderr). O preço, aceito: `identity "Nome"` — a forma
+ * posicional da CH3 — deixou de gravar.
  */
 export type PedidoDeIdentidade = {
     acao: 'mostrar';
@@ -122,10 +137,13 @@ interface ChatIdentityResponse {
     email?: string;
 }
 /**
- * `neetru chat identity [apelido]` — apelido inerente à credencial (CH3).
+ * O que `neetru chat identity` faz depois de `interpretarArgsDeIdentidade`
+ * decidir — apelido inerente à credencial (CH3). Quem chega aqui com texto já
+ * passou por `identity set "Nome"`, `identity clear` ou `send --as`: o
+ * posicional solto não chega (default invertido, bug_09574d4b).
  *
- * Sem argumento: mostra o apelido atual (GET /api/cli/v1/chat/identity).
- * Com argumento: persiste o apelido na credencial (POST). A partir daí, TODA
+ * `undefined`: mostra o apelido atual (GET /api/cli/v1/chat/identity).
+ * Texto: persiste o apelido na credencial (POST). A partir daí, TODA
  * mensagem postada com este token aparece com este nome — a IA se identifica em
  * nome do dev dono do token. Apelido vazio ("") limpa (volta ao email).
  *

package/dist/commands/chat.js

@@ -33,7 +33,9 @@ import { log } from '../utils/logger.js';
 import { safeExit } from '../utils/safe-exit.js';
 import { fmtTimestamp } from '../lib/render.js';
 import { exitWithCliError } from '../lib/cli-error.js';
-import { isSubcommandVerb, reservedVerbError } from '../cli-kit/suggest.js';
+import { EXIT_CODES, NeetruCliError } from '../cli-kit/errors.js';
+import { formatChoices } from '../cli-kit/choices.js';
+import { isSubcommandVerb, reservedVerbError, suggestSubcommands } from '../cli-kit/suggest.js';
 import { commandDeclaresFlag, declaredFlags } from '../cli-kit/command-context.js';
 // ─── Helpers de display ───────────────────────────────────────────────────────
 function colorRole(role) {
@@ -305,7 +307,35 @@ export function interpretarArgsDeIdentidade(args, ctx = CONTEXTO_DE_IDENTIDADE_P
             ? `Para gravar "${texto}" como apelido: neetru ${ctx.comando} set "${texto}"`
             : comoGravarVerboComoApelido(primeiro.trim(), ctx));
     }
-    return { acao: 'definir', apelido: args.join(' ') };
+    // Default INVERTIDO: o que não é subcomando de `identity` é recusado — nunca
+    // gravado como apelido (ver o bloco acima de `PedidoDeIdentidade`).
+    return subcomandoDesconhecido(args, ctx);
+}
+/**
+ * `identity <qualquer outra coisa>`: recusa SEM escrever. Não diz que a palavra
+ * é "de comando" (`Dev Core` não é) — diz que não é subcomando de `identity`,
+ * lista os que existem e ensina a forma explícita de gravar o mesmo texto.
+ * Sugestão só quando passa o piso do gcloud (`suggestSubcommands`).
+ */
+function subcomandoDesconhecido(args, ctx) {
+    const texto = args.join(' ');
+    const sugestoes = suggestSubcommands(args[0].trim(), VERBOS_DE_IDENTIDADE).map((s) => `neetru ${ctx.comando} ${s}`);
+    const linhas = [
+        `"${texto}" não é subcomando de \`neetru ${ctx.comando}\` — e o argumento solto não grava apelido.`,
+    ];
+    if (sugestoes.length > 0)
+        linhas.push(`Você quis dizer: ${sugestoes.map((s) => `\`${s}\``).join(' ou ')}?`);
+    linhas.push(`Subcomandos de \`neetru ${ctx.comando}\`: ${formatChoices(VERBOS_DE_IDENTIDADE)} ` +
+        `(sem subcomando, \`neetru ${ctx.comando}\` mostra o apelido atual).`);
+    linhas.push(texto.trim()
+        ? `Para gravar "${texto.trim()}" como apelido: neetru ${ctx.comando} set "${texto.trim()}"`
+        : `Para limpar o apelido: neetru ${ctx.comando} clear`);
+    const erro = new NeetruCliError(linhas.join('\n  '), {
+        code: 'uso_invalido',
+        exit: EXIT_CODES.client,
+        details: { value: texto, suggestions: sugestoes, valid: [...VERBOS_DE_IDENTIDADE] },
+    });
+    return { acao: 'erro', mensagem: erro.message, erro };
 }
 function subcomandosIrmaos(command) {
     const irmaos = command?.parent?.commands ?? [];
@@ -360,10 +390,13 @@ function respondeuEmModoMaquina(res, opts) {
     return false;
 }
 /**
- * `neetru chat identity [apelido]` — apelido inerente à credencial (CH3).
+ * O que `neetru chat identity` faz depois de `interpretarArgsDeIdentidade`
+ * decidir — apelido inerente à credencial (CH3). Quem chega aqui com texto já
+ * passou por `identity set "Nome"`, `identity clear` ou `send --as`: o
+ * posicional solto não chega (default invertido, bug_09574d4b).
  *
- * Sem argumento: mostra o apelido atual (GET /api/cli/v1/chat/identity).
- * Com argumento: persiste o apelido na credencial (POST). A partir daí, TODA
+ * `undefined`: mostra o apelido atual (GET /api/cli/v1/chat/identity).
+ * Texto: persiste o apelido na credencial (POST). A partir daí, TODA
  * mensagem postada com este token aparece com este nome — a IA se identifica em
  * nome do dev dono do token. Apelido vazio ("") limpa (volta ao email).
  *
@@ -617,7 +650,9 @@ export async function runChatHistory(opts) {
         console.log(JSON.stringify({ ok: true, count: messages.length, messages }));
         return;
     }
-    const janela = initialSinceMs !== undefined ? 'desde o cursor --since' : `últimas ${sinceHours}h`;
+    // bug_89d2497e (etapa 1): o `neetru chat` também chama este runner e não tem
+    // --since; o rótulo descreve a janela sem citar a flag.
+    const janela = initialSinceMs !== undefined ? 'desde o cursor informado' : `últimas ${sinceHours}h`;
     console.log(chalk.bold(`\nHistórico — ${label} (${janela} · ${messages.length} msg)\n`));
     if (messages.length === 0) {
         log.dim('Nenhuma mensagem no período.');
@@ -825,7 +860,8 @@ export function registerChatCommand(program) {
         .command('identity [args...]')
         .alias('apelido')
         .description('Apelido da credencial no chat (persiste por token). ' +
-        '`identity` ou `identity show` lê; `identity set "Nome"` grava; `identity clear` limpa.')
+        '`identity` ou `identity show` lê; `identity set "Nome"` grava; `identity clear` limpa. ' +
+        'Qualquer outra palavra é recusada — nunca vira apelido.')
         .option('--json', 'saída em JSON')
         .action(async (args, _cmdOpts, command) => {
         // O `--json` vai pro pai `chat` (ver `opcaoHerdada`): ler só `cmdOpts.json`

package/dist/commands/code.js

@@ -11,6 +11,7 @@ import { parseToolRequests, extractPatch } from '../lib/code-agent-protocol.js';
 import { applyUnifiedPatch, checkPatchApplies, getGitDiff, getProjectOverview, listFiles, readFileContext, renderColoredDiff, runCodeTool, truncateForGateway, } from '../lib/code-agent-files.js';
 import { compactCodeHistory, compactHistoryToFit, MAX_HISTORY_TOTAL_CHARS, saveCodeSession, autoSaveCodeSession, listCodeSessions, loadCodeSession, logAppliedPatch, CodeAgentStateMachine, } from '../lib/code-agent-session.js';
 import { DEFAULT_CODE_MAX_TOKENS, DEFAULT_CODE_MAX_TURNS, DEFAULT_CODE_TEMPERATURE, ULTRACODE_EFFORT, ULTRACODE_MAX_TOKENS, ULTRACODE_MAX_TURNS, parseBoundedNumber, resolveCodeEffort, resolveCodeModel, resolveCodeProvider, } from '../lib/code-agent-settings.js';
+import { PROVEDORES_IA, ehProvedorIa } from '../lib/ai/provedores.js';
 import { callGateway, streamGatewayChat, AI_GATEWAY_CHAT_PATH } from '../lib/code-agent-gateway.js';
 import { createBudgetTracker, decideBudgetAction, MAX_CONSECUTIVE_PATCH_REPAIRS, MAX_TOOLS_PER_TURN, SINGLE_ACTION_TOOLS, } from '../lib/code-agent-budget.js';
 import { CliApiError } from '../lib/api-client.js';
@@ -45,7 +46,15 @@ export function resolveSettings(opts) {
         envModel: process.env.NEETRU_CODE_MODEL,
         configuredGatewayModel: config.get('gatewayModel'),
     });
-    const provider = resolveCodeProvider(asOptionalString(opts.provider), config.get('gatewayProvider'), model.model);
+    const pedidoDeProvider = asOptionalString(opts.provider);
+    const provider = resolveCodeProvider(pedidoDeProvider, config.get('gatewayProvider'), model.model);
+    // Revisão do #104 (bug_19d312f3): `--provider gemini` (ou qualquer nome fora
+    // da lista única) era ignorado calado e o pedido seguia sem provedor forçado.
+    // Continua seguindo (fail-open, ver `resolveCodeProvider`), mas avisa.
+    const avisoDeProvider = pedidoDeProvider && !ehProvedorIa(pedidoDeProvider)
+        ? `--provider "${pedidoDeProvider}" não existe; use ${PROVEDORES_IA.join(' | ')}. ` +
+            'Seguindo sem provedor forçado: o AI Gateway escolhe.'
+        : undefined;
     const ultracode = opts.ultracode === true;
     const objectiveMode = opts.goal === true || opts.objective === true || ultracode;
     const effort = ultracode
@@ -56,7 +65,7 @@ export function resolveSettings(opts) {
         files: normalizeFiles(opts.file),
         model: model.model,
         provider,
-        modelWarning: model.warning,
+        modelWarning: [model.warning, avisoDeProvider].filter(Boolean).join('\n') || undefined,
         // GAP-M1-18: `--ultracode` sobrepoe `--max-turns`/`--max-tokens`
         // explicitos — e um preset "tudo pra cima", nao so um default alternativo.
         maxTurns: ultracode

package/dist/commands/config.js

@@ -1,22 +1,16 @@
 import chalk from 'chalk';
 import { config } from '../lib/config.js';
+import { CHAVE_DE_MODELO_DO_PROVEDOR, CHAVE_DO_PROVEDOR, MODELOS_DO_AI_NA_TELA, PROVEDORES_IA, ehModeloDoAi, } from '../lib/ai/provedores.js';
 import { classifyApiUrl, isOverrideEnabled } from '../lib/url-allowlist.js';
 import { log } from '../utils/logger.js';
 import { safeExit } from '../utils/safe-exit.js';
 const SETTABLE_KEYS = [
-    'anthropicApiKey',
-    'openaiApiKey',
-    'geminiApiKey',
-    // Groq + NVIDIA NIM (OpenAI-compatible). Valor pode ser pool comma-separated.
-    'groqApiKey',
-    'nvidiaApiKey',
-    'groqModel',
-    'nvidiaModel',
-    // Override de modelo por provider primário (claude/openai/gemini) — eram
-    // documentados mas faltavam aqui → `config set` rejeitava (auditoria 2026-06-20).
-    'claudeModel',
-    'openaiModel',
-    'geminiModel',
+    // bug_19d312f3: chave de API e override de modelo de cada provedor vêm da
+    // lista única (`provedores.ts` — Groq, NVIDIA NIM, OpenAI). O valor da chave
+    // pode ser um pool separado por vírgula. `anthropicApiKey`, `geminiApiKey`,
+    // `claudeModel` e `geminiModel` saíram (Anthropic e Gemini vetados).
+    ...PROVEDORES_IA.map((p) => CHAVE_DO_PROVEDOR[p]),
+    ...PROVEDORES_IA.map((p) => CHAVE_DE_MODELO_DO_PROVEDOR[p]),
     // AI Gateway do Core (`neetru login` + `defaultModel=gateway`) — sem chave
     // própria, só override do modelo enviado no body de `/api/cli/v1/ai/chat`.
     'gatewayModel',
@@ -36,6 +30,14 @@ export function configSet(key, value, opts = {}) {
         log.error(`Chave inválida: "${key}". Chaves disponíveis: ${SETTABLE_KEYS.join(', ')}`);
         safeExit(1);
     }
+    // bug_19d312f3: o schema da config não tem mais `enum` em `defaultModel`
+    // (para um valor antigo como `claude` não derrubar a leitura) — a conferência
+    // do valor gravado fica aqui.
+    if (key === 'defaultModel' && !ehModeloDoAi(value)) {
+        log.error(`Valor inválido para defaultModel: "${value}". Use: ${MODELOS_DO_AI_NA_TELA}.`);
+        safeExit(1);
+        return;
+    }
     // MASTER-HIGH-048 (2.11.0): set manual de `neetruApiKey` está deprecated.
     // O storage canonico agora é `~/.config/neetru-cli/auth.json` (via `neetru login`).
     // O Conf storage será removido em @neetru/cli@2.12.