@neetru/cli 2.32.1 → 2.34.0

package/dist/index.js

@@ -8,6 +8,8 @@ import { CliApiError } from './lib/api-client.js';
 import { NeetruCliError } from './cli-kit/errors.js';
 import { installCommandContext, getCurrentCommand } from './cli-kit/command-context.js';
 import { emitCliError } from './lib/cli-error.js';
+import { AJUDA_DEPLOY_NA_VM } from './lib/deploy-vm-um-app.js';
+import { MODELOS_DO_AI_NA_TELA, NOMES_DOS_PROVEDORES, PROVEDORES_IA, } from './lib/ai/provedores.js';
 // UV_HANDLE_CLOSING no Windows (bug_818cf6d): o double-destroy de stdin (handler
 // 'exit' redundante) foi removido em 2026-07-15 (ddd479f), MAS isso não bastou
 // — a causa dominante é o `uv_async_t` do undici (fetch) ainda vivo quando o
@@ -114,7 +116,9 @@ installCommandContext(program);
 const aiCommand = program
     .command('ai')
     .description('Abrir REPL de IA Neetru-aware (BYOK ou AI Gateway)')
-    .option('-m, --model <model>', 'modelo: claude | openai | gemini | groq | nvidia | gateway | auto', 'auto')
+    // Sem valor padrão de propósito: sem `-m`, o `runAiRepl` usa o `defaultModel`
+    // da config (que começa em `auto`). Um padrão aqui o esconderia.
+    .option('-m, --model <model>', `modelo: ${MODELOS_DO_AI_NA_TELA} (sem -m: o defaultModel da config, que começa em auto)`)
     .action(async (opts) => {
     const { runAiRepl } = await import('./commands/ai.js');
     await runAiRepl({ model: opts.model });
@@ -125,7 +129,7 @@ const aiCommand = program
 // por `neetru code`.
 aiCommand
     .command('models [id]')
-    .description('Lista o catalogo de modelos curados (Groq/NVIDIA/OpenAI); com [id] fixa como default')
+    .description(`Lista o catalogo de modelos curados (${NOMES_DOS_PROVEDORES}); com [id] fixa como default`)
     .action(async (id) => {
     const { runAiModelsList, runAiModelsUse } = await import('./commands/ai-models.js');
     if (id)
@@ -138,7 +142,7 @@ program
     .command('code [prompt...]')
     .description('Abrir assistente local de codigo via Neetru AI Gateway (Groq/NVIDIA)')
     .option('-m, --model <model>', 'modelo do AI Gateway (default: llama-3.3-70b-versatile) — veja "neetru ai models"')
-    .option('--provider <provider>', 'forca o provider (groq|nvidia|openai) — necessario p/ modelo nativo de um catalogo especifico')
+    .option('--provider <provider>', `forca o provider (${PROVEDORES_IA.join('|')}) — necessario p/ modelo nativo de um catalogo especifico`)
     .option('--cwd <dir>', 'repo/diretorio alvo (default: cwd atual)')
     .option('-f, --file <path>', 'inclui arquivo no contexto inicial (repetivel)', (value, previous) => previous.concat(value), [])
     .option('--max-turns <n>', 'maximo de rodadas tool/read antes de parar', '8')
@@ -222,10 +226,12 @@ program
     });
 });
 // ── neetru auth ───────────────────────────────────────────────────────
-// Wave D — detecta Claude Code/Codex/Gemini instalados e reaproveita creds.
+// Wave D — reaproveita chave já existente na máquina. bug_19d312f3: os
+// provedores são os da lista única (`lib/ai/provedores.ts`); Anthropic e Gemini
+// saíram (vetados).
 const authCmd = program
     .command('auth')
-    .description('Gerenciar credenciais de IA (Claude, Codex, Gemini)');
+    .description(`Gerenciar credenciais de IA (${NOMES_DOS_PROVEDORES})`);
 authCmd
     .command('status')
     .description('Listar provedores detectados e estado das credenciais')
@@ -244,7 +250,7 @@ authCmd
 });
 authCmd
     .command('pull')
-    .description('Copiar creds dos CLIs detectados pra config do Neetru')
+    .description('Copiar pra config do Neetru a chave achada no arquivo do Codex (as do ambiente já são lidas direto)')
     .option('--json', 'saída JSON')
     .action(async (opts) => {
     const { runAuthPull } = await import('./commands/auth.js');
@@ -459,6 +465,8 @@ program
 program
     .command('deploy')
     .description('Deployar produto via pipeline do Neetru Core')
+    // bug_6d92ef71: um app por produto e ambiente na VM, e como ter dois.
+    .addHelpText('after', AJUDA_DEPLOY_NA_VM)
     .option('--product <slug>', 'slug do produto')
     .option('--version <version>', 'versão a deployar')
     .option('--stack <stack>', 'node | nextjs | docker | php-apache | static (gera Dockerfile automático para node/nextjs)')
@@ -854,6 +862,7 @@ serversCmd
     .option('--yes', 'pula a confirmação interativa (modo script)')
     .option('--mfa-token <code>', 'código TOTP para step-up MFA (ou use `neetru auth mfa-session`)')
     .option('--dry-run', 'valida e retorna o efeito sem aplicar (sem MFA)')
+    .option('--confirm-instance-id <id>', 'id numérico da VM no Google Cloud que você conferiu — só quando o Core pedir (servidor sem o id da VM registrado)')
     .option('--json', 'saída em JSON')
     .action(async (id, opts) => {
     const { runServersForceCleanup } = await import('./commands/servers.js');
@@ -862,6 +871,7 @@ serversCmd
         yes: !!opts.yes,
         mfaToken: opts.mfaToken,
         dryRun: !!opts.dryRun,
+        confirmInstanceId: opts.confirmInstanceId,
         json: !!opts.json,
     });
 });
@@ -1962,6 +1972,36 @@ envCmd
         json: !!opts.json,
     });
 });
+// ── neetru environments ───────────────────────────────────────────────
+// Ambientes (staging/prod) de um produto no Core. Separado de `neetru env`, que
+// cuida do NEETRU_ENV local e das variáveis do Cloud Run.
+const environmentsCmd = program
+    .command('environments')
+    .description('Ambientes (staging/prod) de um produto no Core');
+// bug_7446f7f2: re-apontar a VM do ambiente sem PATCH manual no Firestore.
+environmentsCmd
+    .command('repoint <slug> <env>')
+    .description('Re-apontar o ambiente (staging|prod) para outra VM — só o ponteiro; o app muda no próximo deploy ' +
+    '(POST /api/cli/v1/products/[slug]/environments/[env]/server — exige MFA)')
+    .requiredOption('--to <serverId>', 'VM nova (id do servidor)')
+    .requiredOption('--expect-from <serverId>', 'VM que o ambiente aponta hoje (se mudou, nada é gravado)')
+    .requiredOption('--reason <text>', 'motivo (vai para o registro de auditoria)')
+    .option('--dry-run', 'só confere os requisitos (não altera nada, sem MFA)')
+    .option('-y, --yes', 'pula a confirmação interativa (modo script)')
+    .option('--mfa-token <code>', 'código TOTP step-up MFA (ou use `neetru auth mfa-session`)')
+    .option('--json', 'saída em JSON estruturado')
+    .action(async (slug, env, opts) => {
+    const { runEnvironmentsRepoint } = await import('./commands/environments-repoint.js');
+    await runEnvironmentsRepoint(slug, env, {
+        to: opts.to,
+        expectFrom: opts.expectFrom,
+        reason: opts.reason,
+        dryRun: !!opts.dryRun,
+        yes: !!opts.yes,
+        mfaToken: opts.mfaToken,
+        json: !!opts.json,
+    });
+});
 // ── neetru db ─────────────────────────────────────────────────────────
 // M1 — árvore completa de banco por produto.
 // Subcomandos novos: list, status, apply, migrations list/confirm/cancel.
@@ -2161,7 +2201,9 @@ dbCmd
     .option('--backup-id <id>', 'ID do backup a restaurar (pula o prompt; obrigatório em --json)')
     .option('-y, --yes', 'pula a confirmação textual "RESTAURAR" (obrigatório em --json)')
     // Flag canônica `--mfa-token`; `--mfa` como alias oculto (retrocompat).
-    .option('--mfa-token <token>', 'código TOTP step-up MFA (obrigatório — operação destrutiva)')
+    // bug_757b9746: deixou de ser obrigatória — com a sessão de 1h ativa o
+    // restore vai sem código, como os outros comandos destrutivos.
+    .option('--mfa-token <token>', 'código TOTP step-up MFA (ou use `neetru auth mfa-session`)')
     .addOption(new Option('--mfa <token>').hideHelp())
     .option('--json', 'saída em JSON')
     .action(async (dbId, opts) => {
@@ -2281,6 +2323,60 @@ dbMoveCmd
         json: !!opts.json,
     });
 });
+// ── neetru db frontdoor ───────────────────────────────────────────────
+// Porta de entrada PRIVADA de um banco Postgres em VM para um app em OUTRA VM,
+// sem mover o banco (Core #727, bug_5c0e7738). O Core prepara o PgBouncer na
+// VM do banco, testa a partir da VM do app e na própria VM do banco, e só então
+// grava o novo endereço. `enable` repetido RETOMA a mesma operação.
+const dbFrontdoorCmd = dbCmd
+    .command('frontdoor')
+    .description('Porta de entrada privada do banco para um app em outra VM da rede interna (sem mover o banco)');
+dbFrontdoorCmd
+    .command('enable <dbId>')
+    .description('Ligar a porta de entrada para a VM do app (POST /api/cli/v1/db/[id]/frontdoor — exige MFA; repetir retoma)')
+    .requiredOption('--app-server <serverId>', 'VM onde o app roda ou vai rodar (recebe a liberação na rede interna)')
+    .requiredOption('--reason <text>', 'motivo (vai para o registro de auditoria)')
+    .option('--dry-run', 'só confere os requisitos (não altera nada, sem MFA)')
+    .option('-y, --yes', 'pula a confirmação interativa (modo script)')
+    .option('--mfa-token <code>', 'código TOTP step-up MFA (ou use `neetru auth mfa-session`)')
+    .option('--json', 'saída em JSON estruturado')
+    .action(async (dbId, opts) => {
+    const { runDbFrontdoorEnable } = await import('./commands/db-frontdoor.js');
+    await runDbFrontdoorEnable(dbId, {
+        appServer: opts.appServer,
+        reason: opts.reason,
+        dryRun: !!opts.dryRun,
+        yes: !!opts.yes,
+        mfaToken: opts.mfaToken,
+        json: !!opts.json,
+    });
+});
+dbFrontdoorCmd
+    .command('status <dbId>')
+    .description('Estado da porta de entrada e da última operação (GET /api/cli/v1/db/[id]/frontdoor)')
+    .option('--json', 'saída em JSON')
+    .action(async (dbId, opts) => {
+    const { runDbFrontdoorStatus } = await import('./commands/db-frontdoor.js');
+    await runDbFrontdoorStatus(dbId, { json: !!opts.json });
+});
+dbFrontdoorCmd
+    .command('disable <dbId>')
+    .description('Desligar a porta de entrada — o app volta ao endereço local da VM do banco (POST /api/cli/v1/db/[id]/frontdoor/disable — exige MFA)')
+    .requiredOption('--reason <text>', 'motivo (vai para o registro de auditoria)')
+    .option('--force', 'obrigatório para desligar uma porta ligada (o desfazer normal) ou quando não se sabe onde o app roda: o app volta ao endereço local da VM do banco e, se ele roda em outra VM, fica sem banco')
+    .option('-y, --yes', 'pula a confirmação interativa (modo script)')
+    .option('--mfa-token <code>', 'código TOTP step-up MFA (ou use `neetru auth mfa-session`)')
+    .option('--json', 'saída em JSON')
+    .action(async (dbId, opts) => {
+    const { runDbFrontdoorDisable } = await import('./commands/db-frontdoor.js');
+    await runDbFrontdoorDisable(dbId, {
+        reason: opts.reason,
+        force: !!opts.force,
+        yes: !!opts.yes,
+        mfaToken: opts.mfaToken,
+        json: !!opts.json,
+    });
+});
 // ── neetru db where ───────────────────────────────────────────────────
 // READ-ONLY: onde o banco de um produto VIVE hoje (VM/serverId + endpoint).
 // Complementa `neetru db status <dbId>` (que exige o dbId) aceitando --product.

package/dist/lib/ai/auth-discovery.d.ts

@@ -1,8 +1,11 @@
-export type Provider = 'anthropic' | 'openai' | 'gemini' | 'groq' | 'nvidia';
+import { type ProvedorIa } from './provedores.js';
+export type Provider = ProvedorIa;
 export interface ProviderStatus {
     provider: Provider;
-    binary: string;
-    npmPackage: string;
+    /** Programa de terceiro que guarda a chave (hoje só o `codex`). Ausente = provedor só de chave. */
+    binary?: string;
+    /** Pacote npm desse programa (hoje só `@openai/codex`). */
+    npmPackage?: string;
     installed: boolean;
     credentialSource: 'env' | 'config-file' | 'binary-config' | null;
     credentialPath?: string;
@@ -10,18 +13,12 @@ export interface ProviderStatus {
     hint: string;
 }
 /**
- * Detecta todos os providers conhecidos. Read-only — não escreve nada,
- * não chama API. Seguro pra rodar em startup do `neetru ai`.
- *
- * Cobre só os providers que têm CLI concorrente (claude/codex/gemini) — o
- * wizard de setup usa esta lista pra ofertar install/login per-binário.
- * Groq e NVIDIA NIM são API-key-only (sem CLI pra instalar); a descoberta
- * deles vive em `discoveredKeys` (env direto).
+ * Estado de cada provedor da lista única, na ordem dela. Read-only — não
+ * escreve nada, não chama API. Seguro pra rodar em startup do `neetru ai`.
  */
 export declare function detectAllProviders(): ProviderStatus[];
 /**
- * Conveniência: retorna apenas providers com apiKey extraída (pronta pra usar).
- * Inclui os CLI-discoverable (claude/codex/gemini) + os API-key-only (groq/nvidia).
+ * Conveniência: retorna apenas os provedores com chave achada (pronta pra usar).
  */
 export declare function discoveredKeys(): Partial<Record<Provider, string>>;
 /**

package/dist/lib/ai/auth-discovery.js

@@ -1,33 +1,33 @@
 /**
- * Auth auto-discovery — detecta Claude Code, Codex (OpenAI) e Gemini CLIs
- * já instalados na máquina e tenta extrair credenciais existentes.
+ * Auth auto-discovery — procura chave já existente na máquina para cada
+ * provedor da lista única (`provedores.ts`), sem mexer em nada (read-only).
  *
- * Motivação: usuário não deveria precisar setar `anthropicApiKey` na mão se
- * ele já tem `claude` (Claude Code) ou `codex` (OpenAI Codex CLI) ou `gemini`
- * (Google Gemini CLI) instalados e logados. CLI Neetru reaproveita as creds
- * pra ligar o `neetru ai` direto.
+ * - Groq e NVIDIA NIM: só chave de API, lida do ambiente (GROQ_API_KEY,
+ *   NVIDIA_API_KEY). Não há programa para instalar.
+ * - OpenAI: a variável OPENAI_API_KEY ou o arquivo do Codex (`codex`, o
+ *   programa de linha de comando da OpenAI) em ~/.codex/auth.json.
  *
- * Estratégia (cross-platform Windows/macOS/Linux):
- *   1. Detectar binário no PATH (`where` no Windows, `command -v` no POSIX).
- *   2. Olhar locais conhecidos de config (~/.claude, ~/.codex, ~/.config/gemini).
- *   3. Olhar env vars (ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY).
- *   4. Reporta o que está disponível sem mexer em nada (read-only).
+ * bug_19d312f3: a descoberta lia também ANTHROPIC_API_KEY, GEMINI_API_KEY,
+ * GOOGLE_API_KEY e os arquivos do Claude Code e do Gemini, e o `neetru ai` saía
+ * usando essas chaves sem o dev escolher. Anthropic e Gemini estão vetados pela
+ * casa e saíram da lista; a descoberta não procura mais as chaves deles.
  *
- * O `setup wizard` (em commands/auth.ts) usa essa detecção pra ofertar
- * install + login per-provider.
+ * O assistente do `neetru auth setup` (commands/auth.ts) usa esta detecção
+ * para mostrar o estado de cada provedor e pedir a chave que falta.
  */
 import { execSync, execFileSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { homedir, platform } from 'node:os';
 import { join } from 'node:path';
+import { CHAVE_DO_PROVEDOR, PROVEDORES_IA, VARIAVEL_DO_PROVEDOR, } from './provedores.js';
 const IS_WINDOWS = platform() === 'win32';
 /**
  * Checa se um binário existe no PATH. Cross-platform via `where` (Windows)
  * e `command -v` (POSIX). Silencioso — captura erro e retorna false.
  */
 function binaryExists(name) {
-    // Defesa em profundidade: hoje `name` vem de uma lista interna fixa
-    // (claude/codex/gemini), mas validamos o formato e evitamos o shell para que
+    // Defesa em profundidade: hoje `name` vem de uma constante interna
+    // (`codex`), mas validamos o formato e evitamos o shell para que
     // isto NUNCA permita injeção de comando, mesmo se a fonte do nome mudar.
     if (!/^[A-Za-z0-9._-]+$/.test(name))
         return false;
@@ -64,60 +64,6 @@ function readJsonSafe(path) {
         return null;
     }
 }
-/**
- * Anthropic / Claude Code.
- * - Binário: `claude` (instalado via npm i -g @anthropic-ai/claude-code)
- * - Config: ~/.claude/.credentials.json (oauth token OU api key)
- * - Env: ANTHROPIC_API_KEY
- */
-function detectAnthropic() {
-    const home = homedir();
-    const installed = binaryExists('claude');
-    // Prioridade 1: env var (mais simples — Anthropic SDK aceita direto)
-    const envKey = process.env.ANTHROPIC_API_KEY;
-    if (envKey && envKey.startsWith('sk-ant-')) {
-        return {
-            provider: 'anthropic',
-            binary: 'claude',
-            npmPackage: '@anthropic-ai/claude-code',
-            installed,
-            credentialSource: 'env',
-            apiKey: envKey,
-            hint: 'usando ANTHROPIC_API_KEY do ambiente',
-        };
-    }
-    // Prioridade 2: arquivo de credentials do Claude Code
-    const credsPath = join(home, '.claude', '.credentials.json');
-    const creds = readJsonSafe(credsPath);
-    if (creds) {
-        // Claude Code armazena `apiKey` ou tokens OAuth. Só populamos apiKey se for sk-ant.
-        const maybeKey = typeof creds.apiKey === 'string' && creds.apiKey.startsWith('sk-ant-')
-            ? creds.apiKey
-            : undefined;
-        return {
-            provider: 'anthropic',
-            binary: 'claude',
-            npmPackage: '@anthropic-ai/claude-code',
-            installed,
-            credentialSource: 'binary-config',
-            credentialPath: credsPath,
-            apiKey: maybeKey,
-            hint: maybeKey
-                ? `extraindo apiKey de ${credsPath}`
-                : `Claude Code logado via OAuth (sem apiKey plaintext) — rode "claude /login" e setting ANTHROPIC_API_KEY ou use "neetru config set anthropicApiKey"`,
-        };
-    }
-    return {
-        provider: 'anthropic',
-        binary: 'claude',
-        npmPackage: '@anthropic-ai/claude-code',
-        installed,
-        credentialSource: null,
-        hint: installed
-            ? 'Claude Code instalado mas sem credenciais — rode "claude" pra logar'
-            : 'instalar: npm i -g @anthropic-ai/claude-code',
-    };
-}
 /**
  * OpenAI / Codex CLI.
  * - Binário: `codex` (npm i -g @openai/codex)
@@ -172,96 +118,48 @@ function detectOpenAI() {
     };
 }
 /**
- * Google / Gemini CLI.
- * - Binário: `gemini` (npm i -g @google/gemini-cli)
- * - Config: ~/.config/gemini/auth.json (Linux/macOS) ou %APPDATA%\gemini\auth.json (Windows)
- * - Env: GEMINI_API_KEY ou GOOGLE_API_KEY
+ * Groq e NVIDIA NIM — provedores OpenAI-compatible, só de chave de API. A
+ * descoberta lê só a variável de ambiente (GROQ_API_KEY / NVIDIA_API_KEY). O
+ * valor PODE ser um pool separado por vírgula; aqui vai cru e o orchestrator
+ * separa.
  */
-function detectGemini() {
-    const home = homedir();
-    const installed = binaryExists('gemini');
-    const envKey = process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY;
-    if (envKey) {
+function detectApenasChave(provider) {
+    const variavel = VARIAVEL_DO_PROVEDOR[provider];
+    const valor = process.env[variavel];
+    if (valor) {
         return {
-            provider: 'gemini',
-            binary: 'gemini',
-            npmPackage: '@google/gemini-cli',
-            installed,
+            provider,
+            installed: false,
             credentialSource: 'env',
-            apiKey: envKey,
-            hint: 'usando GEMINI_API_KEY (ou GOOGLE_API_KEY) do ambiente',
-        };
-    }
-    const candidates = IS_WINDOWS
-        ? [
-            join(process.env.APPDATA ?? join(home, 'AppData', 'Roaming'), 'gemini', 'auth.json'),
-            join(home, '.config', 'gemini', 'auth.json'),
-        ]
-        : [join(home, '.config', 'gemini', 'auth.json')];
-    for (const path of candidates) {
-        const auth = readJsonSafe(path);
-        if (!auth)
-            continue;
-        const maybeKey = typeof auth.apiKey === 'string'
-            ? auth.apiKey
-            : typeof auth.GEMINI_API_KEY === 'string'
-                ? auth.GEMINI_API_KEY
-                : undefined;
-        return {
-            provider: 'gemini',
-            binary: 'gemini',
-            npmPackage: '@google/gemini-cli',
-            installed,
-            credentialSource: 'binary-config',
-            credentialPath: path,
-            apiKey: maybeKey,
-            hint: maybeKey
-                ? `extraindo apiKey de ${path}`
-                : `Gemini logado mas sem apiKey plaintext — rode "gemini auth" com --api-key ou exporte GEMINI_API_KEY`,
+            apiKey: valor,
+            hint: `usando ${variavel} do ambiente`,
         };
     }
     return {
-        provider: 'gemini',
-        binary: 'gemini',
-        npmPackage: '@google/gemini-cli',
-        installed,
+        provider,
+        installed: false,
         credentialSource: null,
-        hint: installed
-            ? 'Gemini instalado mas sem credenciais — rode "gemini auth"'
-            : 'instalar: npm i -g @google/gemini-cli',
+        hint: `sem chave — exporte ${variavel} ou rode "neetru config set ${CHAVE_DO_PROVEDOR[provider]} <chave>"`,
     };
 }
 /**
- * Detecta todos os providers conhecidos. Read-only — não escreve nada,
- * não chama API. Seguro pra rodar em startup do `neetru ai`.
- *
- * Cobre só os providers que têm CLI concorrente (claude/codex/gemini) — o
- * wizard de setup usa esta lista pra ofertar install/login per-binário.
- * Groq e NVIDIA NIM são API-key-only (sem CLI pra instalar); a descoberta
- * deles vive em `discoveredKeys` (env direto).
+ * Um detector por provedor da lista única. O `Record<ProvedorIa, …>` faz o tsc
+ * recusar provedor novo em `PROVEDORES_IA` sem detector aqui.
  */
-export function detectAllProviders() {
-    return [detectAnthropic(), detectOpenAI(), detectGemini()];
-}
+const DETECTORES = {
+    groq: () => detectApenasChave('groq'),
+    nvidia: () => detectApenasChave('nvidia'),
+    openai: detectOpenAI,
+};
 /**
- * Groq + NVIDIA NIM — providers OpenAI-compatible, API-key-only. Descoberta
- * só por env var (GROQ_API_KEY / NVIDIA_API_KEY). O env PODE conter um pool
- * comma-separated; aqui devolvemos o valor cru e o orchestrator parseia.
- * Não disrupta o wizard de binários (detectAllProviders).
+ * Estado de cada provedor da lista única, na ordem dela. Read-only — não
+ * escreve nada, não chama API. Seguro pra rodar em startup do `neetru ai`.
  */
-function discoverApiOnlyKeys() {
-    const out = {};
-    const groq = process.env.GROQ_API_KEY;
-    const nvidia = process.env.NVIDIA_API_KEY;
-    if (groq)
-        out.groq = groq;
-    if (nvidia)
-        out.nvidia = nvidia;
-    return out;
+export function detectAllProviders() {
+    return PROVEDORES_IA.map((p) => DETECTORES[p]());
 }
 /**
- * Conveniência: retorna apenas providers com apiKey extraída (pronta pra usar).
- * Inclui os CLI-discoverable (claude/codex/gemini) + os API-key-only (groq/nvidia).
+ * Conveniência: retorna apenas os provedores com chave achada (pronta pra usar).
  */
 export function discoveredKeys() {
     const out = {};
@@ -269,7 +167,7 @@ export function discoveredKeys() {
         if (p.apiKey)
             out[p.provider] = p.apiKey;
     }
-    return { ...out, ...discoverApiOnlyKeys() };
+    return out;
 }
 /**
  * Tenta instalar globalmente um pacote via npm. Bloqueante, com output

package/dist/lib/ai/orchestrator.d.ts

@@ -1,6 +1,7 @@
-export type ModelId = 'claude' | 'openai' | 'gemini' | 'groq' | 'nvidia' | 'gateway' | 'auto';
+import { type ModeloDoAi, type ProvedorIa } from './provedores.js';
+export type ModelId = ModeloDoAi;
 /** Modelo concreto já resolvido (sem 'auto'). */
-export type ResolvedModel = 'claude' | 'openai' | 'gemini' | 'groq' | 'nvidia' | 'gateway';
+export type ResolvedModel = ProvedorIa | 'gateway';
 export interface Message {
     role: 'user' | 'assistant';
     content: string;
@@ -32,10 +33,16 @@ export declare function parseKeyPool(raw: string | undefined | null): string[];
  *
  * Heurísticas (em ordem):
  *   1. Se user forçou um modelo (!= auto), respeita — desde que tenha cred.
- *   2. Code generation pesado → OpenAI (gpt-4.1); senão NVIDIA NIM (llama-70b).
- *   3. Sumarização rápida / Q&A factual → Groq (mais rápido); senão Gemini.
- *   4. Default: Claude (arquitetura, análise, raciocínio longo).
- *   5. Fallback: primeiro provider com cred (claude > openai > gemini > groq > nvidia).
+ *   2. Code generation pesado → NVIDIA NIM (llama-70b, gratuito).
+ *   3. Sumarização rápida / Q&A factual → Groq (mais rápido).
+ *   4. Fallback: primeiro provider com cred, gratuitos primeiro
+ *      (groq > nvidia > openai).
+ *
+ * bug_19d312f3: o default era Claude (API da Anthropic) e o Q&A rápido caía no
+ * Gemini quando faltava o Groq. Os dois saíram da lista única (vetados).
+ * Revisão do #104: o `auto` preferia a OpenAI (paga) na geração de código e no
+ * fallback, à frente do Groq e da NVIDIA. Agora ela só entra no `auto` quando
+ * nenhum provedor gratuito tem chave; quem a quer antes pede com `-m openai`.
  */
 export declare function routeModel(input: string, preferred: ModelId): ResolvedModel;
 /**