@neetru/cli 2.31.0 → 2.32.0

package/dist/commands/chat.js

@@ -32,6 +32,9 @@ import { requireToken, handleApiError } from '../lib/cli-read.js';
 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 { commandDeclaresFlag, declaredFlags } from '../cli-kit/command-context.js';
 // ─── Helpers de display ───────────────────────────────────────────────────────
 function colorRole(role) {
     if (role === 'operator')
@@ -227,6 +230,135 @@ export async function runChatSend(message, opts) {
     }
     log.success(`Mensagem enviada (id: ${res.id}).`);
 }
+const LER = new Set(['show', 'ver', 'get']);
+const DEFINIR = new Set(['set', 'definir']);
+const LIMPAR = new Set(['clear', 'limpar']);
+/** Todos os verbos que `identity` entende — a lista que decide a recusa. */
+const TODOS_OS_VERBOS_DE_IDENTIDADE = [...LER, ...DEFINIR, ...LIMPAR];
+/** Os verbos de `identity` que a sugestão oferece — um por ação acima. */
+const VERBOS_DE_IDENTIDADE = ['show', 'set', 'clear'];
+/** Caminho do comando na árvore, sem o `neetru` (ex.: `'chat channels create'`). */
+export function caminhoDoComando(cmd) {
+    const partes = [];
+    for (let c = cmd; c && c.parent; c = c.parent)
+        partes.unshift(c.name());
+    return partes.join(' ');
+}
+/** O que a árvore de verdade dá hoje — travado por teste contra `registerChatCommand`. */
+export const CONTEXTO_DE_IDENTIDADE_PADRAO = {
+    comando: 'chat identity',
+    definirViaSend: 'chat send',
+};
+/** Deriva o contexto do nó `identity` do Commander (o que o `.action()` recebe). */
+export function contextoDeIdentidadeDaArvore(identity) {
+    const send = identity.parent?.commands.find((c) => c.name() === 'send');
+    return {
+        comando: caminhoDoComando(identity),
+        definirViaSend: send && commandDeclaresFlag(send, '--as') ? caminhoDoComando(send) : null,
+    };
+}
+function verboComoApelido(verbo, ctx, escapeHint) {
+    const erro = reservedVerbError({
+        verb: verbo,
+        command: ctx.comando,
+        what: 'apelido',
+        subcommands: VERBOS_DE_IDENTIDADE,
+        escapeHint,
+    });
+    return { acao: 'erro', mensagem: erro.message, erro };
+}
+/** Como gravar um apelido que É um verbo: só pelo `--as` (quando a árvore o tem). */
+function comoGravarVerboComoApelido(apelido, ctx) {
+    if (!ctx.definirViaSend)
+        return undefined;
+    return (`Para usar "${apelido}" como apelido: neetru ${ctx.definirViaSend} --as "${apelido}" "<mensagem>" ` +
+        '(grava o apelido na credencial e envia a mensagem).');
+}
+export function interpretarArgsDeIdentidade(args, ctx = CONTEXTO_DE_IDENTIDADE_PADRAO) {
+    if (args.length === 0)
+        return { acao: 'mostrar' };
+    const [primeiro, ...resto] = args;
+    const palavra = primeiro.trim().toLowerCase();
+    if (args.length === 1 && LER.has(palavra))
+        return { acao: 'mostrar' };
+    if (args.length === 1 && LIMPAR.has(palavra))
+        return { acao: 'definir', apelido: '' };
+    if (DEFINIR.has(palavra)) {
+        if (resto.length === 0) {
+            return {
+                acao: 'erro',
+                mensagem: `Uso: neetru ${ctx.comando} set "Seu Apelido"  (para limpar: neetru ${ctx.comando} clear)`,
+            };
+        }
+        const apelido = resto.join(' ');
+        // `identity set show` grava o verbo do mesmo jeito que `identity show` gravava.
+        if (isSubcommandVerb(apelido, TODOS_OS_VERBOS_DE_IDENTIDADE)) {
+            return verboComoApelido(apelido.trim(), ctx, comoGravarVerboComoApelido(apelido.trim(), ctx));
+        }
+        return { acao: 'definir', apelido };
+    }
+    // Verbo na 1ª posição nunca é o começo de um apelido: é a pessoa achando que
+    // aquilo é subcomando (`identity describe`, `identity show Fulano`).
+    if (isSubcommandVerb(palavra, TODOS_OS_VERBOS_DE_IDENTIDADE)) {
+        const texto = args.join(' ');
+        return verboComoApelido(primeiro.trim(), ctx, args.length > 1
+            ? `Para gravar "${texto}" como apelido: neetru ${ctx.comando} set "${texto}"`
+            : comoGravarVerboComoApelido(primeiro.trim(), ctx));
+    }
+    return { acao: 'definir', apelido: args.join(' ') };
+}
+function subcomandosIrmaos(command) {
+    const irmaos = command?.parent?.commands ?? [];
+    const apelidos = {};
+    for (const c of irmaos)
+        for (const a of c.aliases())
+            apelidos[a] = c.name();
+    return { nomes: irmaos.map((c) => c.name()), apelidos };
+}
+/**
+ * Texto livre POSICIONAL de uma palavra só que é SUBCOMANDO irmão (nome,
+ * apelido ou sinônimo): recusa (P105). `neetru chat send history` postava
+ * "history" no canal global achando que listava; `neetru chat channels create
+ * close` criava o canal "close". Os subcomandos e o caminho citados saem do
+ * nó do Commander em execução (`command`), não de literal.
+ *
+ * `null` quando o texto pode seguir: resposta comum (`show`, `ok`, `top`,
+ * `beleza`, `valeu`, `sim`, `blz` — revisão do #87, BAIXO 6) e frase que só
+ * começa com uma palavra de comando ("history do dia").
+ */
+export function verboComoTextoPosicional(input) {
+    const t = input.texto.trim();
+    const irmaos = subcomandosIrmaos(input.command);
+    if (!t || /\s/.test(t) || !isSubcommandVerb(t, [...irmaos.nomes, ...Object.keys(irmaos.apelidos)]))
+        return null;
+    return reservedVerbError({
+        verb: t,
+        command: caminhoDoComando(input.command),
+        parent: caminhoDoComando(input.command.parent),
+        what: input.oQue,
+        subcommands: irmaos.nomes,
+        aliases: irmaos.apelidos,
+        escapeHint: input.escapeHint,
+    });
+}
+/**
+ * Saída de máquina do `runChatIdentity`, a mesma na leitura e na gravação:
+ * `quiet` não imprime nada e `json` imprime a linha do contrato. Devolve `true`
+ * quando já respondeu — aí o chamador não imprime o texto humano.
+ *
+ * `quiet` ANTES de `json` (2026-10-12): era o contrário, e `send --as --json`
+ * imprimia DUAS linhas JSON no stdout (a da identidade e a do envio), onde o
+ * contrato de máquina é uma.
+ */
+function respondeuEmModoMaquina(res, opts) {
+    if (opts.quiet)
+        return true;
+    if (opts.json) {
+        console.log(JSON.stringify(res));
+        return true;
+    }
+    return false;
+}
 /**
  * `neetru chat identity [apelido]` — apelido inerente à credencial (CH3).
  *
@@ -250,17 +382,15 @@ export async function runChatIdentity(displayName, opts = {}) {
             handleApiError(error, opts.json);
             return;
         }
-        if (opts.json) {
-            console.log(JSON.stringify(res));
-            return;
-        }
+        if (respondeuEmModoMaquina(res, opts))
+            return res;
         if (res.displayName) {
             log.info(`Apelido atual: ${chalk.bold(res.displayName)}`);
         }
         else {
             log.info(`Sem apelido — suas mensagens usam o email${res.email ? ` (${res.email})` : ''}.`);
         }
-        return;
+        return res;
     }
     // Com argumento → persiste.
     const spinner = opts.json || opts.quiet ? null : ora({ text: 'Salvando apelido…', color: 'blue' }).start();
@@ -278,18 +408,56 @@ export async function runChatIdentity(displayName, opts = {}) {
         handleApiError(error, opts.json);
         return;
     }
-    if (opts.json) {
-        console.log(JSON.stringify(res));
-        return;
-    }
-    if (opts.quiet)
-        return;
+    if (respondeuEmModoMaquina(res, opts))
+        return res;
     if (res.displayName) {
         log.success(`Apelido definido: ${chalk.bold(res.displayName)} — suas mensagens no chat aparecem com este nome.`);
     }
     else {
         log.success('Apelido limpo — suas mensagens voltam a usar o email.');
     }
+    return res;
+}
+/**
+ * `chat send --as <apelido>`.
+ *
+ * O Core NÃO tem apelido por mensagem — o nome vem da credencial
+ * (`cli_api_keys/{keyId}.displayName`). Então `--as` só pode PERSISTIR. O defeito
+ * (bug_09574d4b) não era persistir: era persistir CALADO — e o help da versão
+ * publicada dizia só "antes de enviar", então quem lia concluía, com razão, que
+ * valia para aquela mensagem. Credencial compartilhada entre sessões fazia uma
+ * renomear a outra sem ninguém ver.
+ *
+ * Agora: se o apelido já é o pedido, nada muda (nem chamada de escrita); se muda,
+ * o aviso vai pro STDERR dizendo de quem para quem e que vale para as próximas
+ * mensagens da credencial. STDERR porque em `--json` o stdout é contrato de uma
+ * linha.
+ */
+export async function aplicarApelidoDoSend(apelidoBruto, json) {
+    // O Core guarda o apelido aparado; sem o trim, `--as "Dev Core "` gravava e
+    // avisava a CADA envio, porque nunca batia com o que voltava.
+    const apelido = apelidoBruto.trim();
+    const token = await requireToken(json);
+    // Leitura MELHOR-ESFORÇO (revisão do #76): se falhar (rede, 5xx), o envio não
+    // pode morrer aqui — antes deste PR a mensagem saía. `null` = não sei.
+    let antes = null;
+    try {
+        const atual = await apiRequest('/api/cli/v1/chat/identity', { token });
+        const nome = (atual?.displayName ?? '').trim();
+        // Sem apelido, o Core devolve o E-MAIL no `displayName` (`resolveDisplayName`
+        // = `name || actor.email`). Isso é "sem apelido", não um apelido.
+        antes = nome && nome !== atual?.email ? nome : '';
+    }
+    catch {
+        process.stderr.write('⚠ --as: não consegui ler o apelido atual da credencial; gravando mesmo assim.\n');
+    }
+    if (antes !== null && antes === apelido)
+        return;
+    await runChatIdentity(apelido, { quiet: true, json });
+    const de = antes === null ? '(não lido)' : antes || '(email)';
+    process.stderr.write(`⚠ --as MUDOU o apelido da credencial: "${de}" → "${apelido || '(email)'}".\n` +
+        '  Vale para TODAS as próximas mensagens deste token — e de quem compartilha a mesma\n' +
+        '  credencial. Para assinar só esta mensagem, escreva o nome no corpo.\n');
 }
 /** Extrai epoch ms do createdAt serializado (Timestamp/ISO/ms). 0 se inválido. */
 function createdAtMs(createdAt) {
@@ -549,6 +717,25 @@ export async function runChatLoop(opts) {
     }
 }
 // ─── Registro do comando `chat` em program ────────────────────────────────────
+/**
+ * Valor de uma opção que o pai `chat` TAMBÉM declara (`--json`, `--product`…).
+ *
+ * Sem `enablePositionalOptions`, o commander 12 entrega a opção ao PRIMEIRO
+ * ancestral que a conhece — o `chat` — em qualquer posição da linha, e o
+ * subcomando recebe `undefined`. Foi o bug_71f42072 em `history`/`send`; a
+ * revisão do #76 achou o mesmo em `identity` (`identity set --json` saía em
+ * texto) e a varredura achou em `channels`, `channels create` (com `--product`
+ * criava canal `custom`) e `channels close`. Prefere o subcomando e sobe pelos
+ * pais — `channels create` é NETO do `chat`.
+ */
+function opcaoHerdada(command, nome) {
+    for (let c = command; c; c = c.parent) {
+        const valor = c.opts()[nome];
+        if (valor !== undefined)
+            return valor;
+    }
+    return undefined;
+}
 /**
  * Registra o comando `neetru chat` no programa Commander.
  *
@@ -602,9 +789,9 @@ export function registerChatCommand(program) {
         .command('channels')
         .description('Canais de chat: listar (default), criar, fechar')
         .option('--json', 'saída em JSON')
-        .action(async (cmdOpts) => {
+        .action(async (_cmdOpts, command) => {
         // Sem subcomando → lista os canais abertos.
-        await runChatChannels({ json: !!cmdOpts.json });
+        await runChatChannels({ json: !!opcaoHerdada(command, 'json') });
     });
     channelsCmd
         .command('create <name>')
@@ -612,29 +799,55 @@ export function registerChatCommand(program) {
         .option('--product <slug>', 'vincula o canal a um produto (type=product)')
         .option('--type <tipo>', 'product|custom (default: product se --product, senão custom)')
         .option('--json', 'saída em JSON')
-        .action(async (name, cmdOpts) => {
+        .action(async (name, cmdOpts, command) => {
+        // P105: `channels create close` criava o canal "close" para todo mundo.
+        const recusa = verboComoTextoPosicional({ texto: name, command, oQue: 'nome de canal' });
+        if (recusa) {
+            exitWithCliError(recusa, !!opcaoHerdada(command, 'json'));
+            return;
+        }
         await runChatChannelCreate(name, {
-            product: cmdOpts.product,
+            product: opcaoHerdada(command, 'product'),
             type: cmdOpts.type,
-            json: !!cmdOpts.json,
+            json: !!opcaoHerdada(command, 'json'),
         });
     });
     channelsCmd
         .command('close <id>')
         .description('Fechar um canal (o Global não pode ser fechado)')
         .option('--json', 'saída em JSON')
-        .action(async (id, cmdOpts) => {
-        await runChatChannelClose(id, { json: !!cmdOpts.json });
+        .action(async (id, _cmdOpts, command) => {
+        await runChatChannelClose(id, { json: !!opcaoHerdada(command, 'json') });
     });
     // ── chat identity (CH3) ─────────────────────────────────────────────────────
     // Apelido inerente à credencial: a IA se identifica em nome do dev dono do token.
     chatCmd
-        .command('identity [apelido]')
+        .command('identity [args...]')
         .alias('apelido')
-        .description('Ver/definir o apelido da credencial no chat (persiste por token). Vazio limpa. CH3.')
+        .description('Apelido da credencial no chat (persiste por token). ' +
+        '`identity` ou `identity show` lê; `identity set "Nome"` grava; `identity clear` limpa.')
         .option('--json', 'saída em JSON')
-        .action(async (apelido, cmdOpts) => {
-        await runChatIdentity(apelido, { json: !!cmdOpts.json });
+        .action(async (args, _cmdOpts, command) => {
+        // O `--json` vai pro pai `chat` (ver `opcaoHerdada`): ler só `cmdOpts.json`
+        // deixava este ramo — e o erro de uso em JSON — inalcançável.
+        const json = !!opcaoHerdada(command, 'json');
+        const pedido = interpretarArgsDeIdentidade(args ?? [], contextoDeIdentidadeDaArvore(command));
+        if (pedido.acao === 'erro' && pedido.erro) {
+            // P105: verbo reservado como apelido — o erro tipado leva as sugestões.
+            exitWithCliError(pedido.erro, json);
+            return;
+        }
+        if (pedido.acao === 'erro') {
+            if (json) {
+                console.log(JSON.stringify({ ok: false, error: 'uso_invalido', message: pedido.mensagem }));
+            }
+            else {
+                log.error(pedido.mensagem);
+            }
+            safeExit(1);
+            return;
+        }
+        await runChatIdentity(pedido.acao === 'mostrar' ? undefined : pedido.apelido, { json });
     });
     // ── chat send ──────────────────────────────────────────────────────────────
     // Mensagem pode vir como argumento posicional OU via --mensagem/--message.
@@ -652,15 +865,34 @@ export function registerChatCommand(program) {
         .option('--product <slug>', 'slug do produto — legado (retrocompat)')
         .option('--actor-type <tipo>', 'tipo do ator: cli|human|agent_claude (default: cli)', 'cli')
         .option('--product-id <id>', 'id interno do produto (opcional, legado)')
-        .option('--as <apelido>', 'definir o apelido da credencial antes de enviar (persiste — CH3)')
+        .option('--as <apelido>', 'MUDA o apelido da CREDENCIAL (persiste p/ as próximas mensagens; avisa no stderr). ' +
+        'O Core não tem apelido por mensagem.')
         .option('--json', 'saída em JSON')
         .action(async (mensagem, cmdOpts, command) => {
         // bug_71f42072: mesma colisão de --channel/--canal/--product entre o pai
         // `chat` e o subcomando. Prefere o subcomando, cai no pai.
         const parent = command?.parent?.opts?.() ?? {};
-        // CH3: --as persiste o apelido na credencial antes de postar (quiet).
+        const json = !!(cmdOpts.json || parent.json);
+        // P105: verbo sozinho no POSICIONAL não vai pro canal — antes de qualquer
+        // escrita (inclusive a do --as). A flag explícita continua mandando.
+        if (mensagem !== undefined) {
+            const flagDaMensagem = declaredFlags(['--mensagem', '--message'], command)[0];
+            const recusa = verboComoTextoPosicional({
+                texto: mensagem,
+                command,
+                oQue: 'mensagem posicional',
+                escapeHint: flagDaMensagem
+                    ? `Para enviar essa palavra como mensagem: neetru ${caminhoDoComando(command)} ${flagDaMensagem} ${mensagem.trim()}`
+                    : undefined,
+            });
+            if (recusa) {
+                exitWithCliError(recusa, json);
+                return;
+            }
+        }
+        // CH3: --as persiste o apelido na credencial — agora AVISANDO (bug_09574d4b).
         if (typeof cmdOpts.as === 'string') {
-            await runChatIdentity(cmdOpts.as, { quiet: true, json: !!(cmdOpts.json || parent.json) });
+            await aplicarApelidoDoSend(cmdOpts.as, json);
         }
         const msg = (mensagem ?? cmdOpts.message ?? cmdOpts.mensagem ?? '').toString();
         await runChatSend(msg, {
@@ -668,7 +900,7 @@ export function registerChatCommand(program) {
             product: cmdOpts.product ?? parent.product,
             actorType: cmdOpts.actorType,
             productId: cmdOpts.productId,
-            json: !!(cmdOpts.json || parent.json),
+            json,
         });
     });
     // ── chat history ───────────────────────────────────────────────────────────

package/dist/commands/customers.js

@@ -56,7 +56,7 @@ export async function runCustomersList(opts = {}) {
     }
     log.heading(`Customers (${res.count})`);
     renderTable([
-        { header: 'ID', value: (r) => r.id, maxWidth: 24 },
+        { header: 'ID', value: (r) => r.id, identificador: true },
         { header: 'NOME', value: (r) => r.name ?? '—', maxWidth: 28 },
         { header: 'EMAIL', value: (r) => r.contactEmail ?? '—', maxWidth: 30 },
         { header: 'CNPJ/CPF', value: (r) => r.cnpj ?? '—', maxWidth: 18 },

package/dist/commands/db-move.js

@@ -11,7 +11,7 @@
  *     (`rolled_back`/`failed`) são reportados EXPLICITAMENTE como "o produto
  *     seguiu na origem" (fail-closed pro estado atual) e saem com exit != 0.
  *   - `move` é destrutivo sobre banco de produção → confirmação interativa
- *     (pulável com --yes) + step-up MFA (resolveStepUp: sessão 1h → --mfa-token
+ *     (pulável com --yes) + step-up MFA (resolveStepUp: --mfa-token → sessão 1h
  *     → prompt). `--dry-run` roda só o preflight (sem MFA, sem confirmação).
  *
  * SEGURANÇA por construção (iteração 2 — abort/decommission NÃO podem apagar dado
@@ -1004,11 +1004,11 @@ export async function runDbWhere(opts = {}) {
     }
     log.heading(`Bancos do produto "${opts.product}" (${dbs.length})`);
     renderTable([
-        { header: 'ID', value: (r) => r.id, maxWidth: 24 },
+        { header: 'ID', value: (r) => r.id, identificador: true },
         { header: 'ENGINE', value: (r) => r.engine ?? '—', maxWidth: 20 },
         { header: 'ENV', value: (r) => r.environment ?? r.env ?? '—', maxWidth: 12 },
         { header: 'STATUS', value: (r) => r.status ?? '—', maxWidth: 14 },
-        { header: 'VM (onde vive)', value: (r) => r.serverId ?? '—', maxWidth: 20 },
+        { header: 'VM (onde vive)', value: (r) => r.serverId ?? '—', identificador: true },
     ], dbs);
 }
 //# sourceMappingURL=db-move.js.map

package/dist/commands/db.js

@@ -30,6 +30,10 @@ import { apiRequest, CliApiError } from '../lib/api-client.js';
 import { handleApiError } from '../lib/api-error.js';
 import { renderTable, fmtTimestamp } from '../lib/render.js';
 import { readDbJson, writeDbJson, normalizeEnv, } from '../lib/db-local/index.js';
+// Direto do módulo (não do index): testes mockam `db-local/index.js` só com
+// `normalizeEnv`, e o erro de `--env` precisa existir mesmo assim.
+import { erroAmbienteBancoInvalido } from '../lib/db-local/env.js';
+import { exitWithCliError } from '../lib/cli-error.js';
 import { safeExit } from '../utils/safe-exit.js';
 import { runApplyPipeline, runExecSqlPipeline, buildPipelineDeps, isPipelineError, } from '../lib/db-pipeline/index.js';
 import { resolveStepUp } from '../lib/cli-write.js';
@@ -159,8 +163,8 @@ export async function runDbList(opts = {}) {
     }
     log.heading(`Bancos (${resp.count})`);
     renderTable([
-        { header: 'ID', value: (r) => r.id, maxWidth: 28 },
-        { header: 'Produto', value: (r) => r.productId, maxWidth: 20 },
+        { header: 'ID', value: (r) => r.id, identificador: true },
+        { header: 'Produto', value: (r) => r.productId, identificador: true },
         { header: 'Label', value: (r) => r.label ?? '—', maxWidth: 24 },
         { header: 'Engine', value: (r) => r.engine, maxWidth: 22 },
         // gestovendas #11 fix: Core retorna `environment`; `env` é alias legado.
@@ -428,8 +432,9 @@ export async function runDbInit(opts = {}) {
         env = opts.env ? normalizeEnv(opts.env) : 'dev-local';
     }
     catch {
-        log.error(`Ambiente inválido: "${opts.env}". Use dev-local, staging ou production.`);
-        safeExit(1);
+        // bug_89d2497e: valores válidos da fonte real (`NEETRU_ENVS`); com --json,
+        // sai o JSON `invalid_env` como em `db apply`/`db exec-sql`.
+        exitWithCliError(erroAmbienteBancoInvalido(opts.env), opts.json);
         return;
     }
     // ── bug_062f7fea (pdv-agiliza): engines vm-* (+ nosql-vm) exigem serverId ──
@@ -753,14 +758,8 @@ export async function runDbApply(opts = {}) {
         env = normalizeEnv(opts.env ?? 'dev-local');
     }
     catch {
-        const msg = `Ambiente inválido: "${opts.env}". Use dev-local, staging ou production.`;
-        if (opts.json) {
-            jsonError(msg, 'invalid_env');
-        }
-        else {
-            log.error(msg);
-        }
-        safeExit(1);
+        // bug_89d2497e: valores válidos da fonte real (`NEETRU_ENVS`), não copiados.
+        exitWithCliError(erroAmbienteBancoInvalido(opts.env), opts.json);
         return;
     }
     // Resolve schema path.
@@ -1103,14 +1102,8 @@ export async function runDbExecSql(opts = {}) {
         env = normalizeEnv(opts.env ?? 'dev-local');
     }
     catch {
-        const msg = `Ambiente inválido: "${opts.env}". Use dev-local, staging ou production.`;
-        if (opts.json) {
-            jsonError(msg, 'invalid_env');
-        }
-        else {
-            log.error(msg);
-        }
-        safeExit(1);
+        // bug_89d2497e: valores válidos da fonte real (`NEETRU_ENVS`), não copiados.
+        exitWithCliError(erroAmbienteBancoInvalido(opts.env), opts.json);
         return;
     }
     const canonicalEnv = env;
@@ -1263,8 +1256,8 @@ export async function runDbMigrationsList(opts = {}) {
     }
     log.heading(`Migrações (${resp.count})`);
     renderTable([
-        { header: 'ID', value: (r) => r.id, maxWidth: 28 },
-        { header: 'Banco', value: (r) => r.dbId ?? '—', maxWidth: 20 },
+        { header: 'ID', value: (r) => r.id, identificador: true },
+        { header: 'Banco', value: (r) => r.dbId ?? '—', identificador: true },
         { header: 'Status', value: (r) => r.status, maxWidth: 20 },
         { header: 'Severidade', value: (r) => severityColor(r.severity), maxWidth: 14 },
         { header: 'Aplicado', value: (r) => fmtTimestamp(r.appliedAt ?? r.createdAt), maxWidth: 18 },
@@ -1361,7 +1354,7 @@ export async function runDbBackups(dbId, opts = {}) {
     }
     log.heading(`Backups do banco ${chalk.bold(dbId)} (${resp.count})`);
     renderTable([
-        { header: 'ID', value: (r) => r.id, maxWidth: 28 },
+        { header: 'ID', value: (r) => r.id, identificador: true },
         { header: 'Status', value: (r) => statusColor(r.status), maxWidth: 16 },
         { header: 'Data/Hora', value: (r) => fmtTimestamp(r.timestamp), maxWidth: 22 },
         { header: 'Tamanho (MB)', value: (r) => r.sizeMb != null ? String(r.sizeMb) : '—', maxWidth: 14 },
@@ -1551,7 +1544,7 @@ export async function runDbHosts(opts = {}) {
     }
     log.heading(`VM Hosts de Banco (${resp.count})`);
     renderTable([
-        { header: 'ID', value: (r) => r.id, maxWidth: 20 },
+        { header: 'ID', value: (r) => r.id, identificador: true },
         { header: 'Nome', value: (r) => r.name ?? '—', maxWidth: 22 },
         { header: 'Região', value: (r) => r.region ?? '—', maxWidth: 14 },
         { header: 'Status', value: (r) => statusColor(r.status ?? '—'), maxWidth: 14 },

package/dist/commands/deploy.d.ts

@@ -1,3 +1,5 @@
+import { type RuntimeEnvironmentId } from '../lib/envs.js';
+import { type BuildManifest } from './build.js';
 import { type PublicSecretOverrideRecord } from '../lib/public-secret-scan.js';
 /**
  * bug_a5786e03 (2026-05-31): o Core/agente só conhecem os stacks canônicos
@@ -134,28 +136,91 @@ export declare function runPublicSecretGate(source: {
     allowReason?: string;
     json?: boolean;
 }): Promise<PublicSecretGateResult>;
+/**
+ * bug_678ddc98 (elo que faltava): decide se este deploy precisa DIZER ao Core
+ * qual é o entrypoint, em vez de deixar o agente adivinhar.
+ *
+ * O #68 ensinou o `neetru build` a empacotar monorepo e a calcular o entrypoint
+ * aninhado (`apps/web/server.js`), mas a cadeia parava no `manifest.json`:
+ * `manifest.entrypoint` nunca foi lido por ninguém — era campo write-only.
+ * Num monorepo o tarball fica assim:
+ *
+ *   <versionDir>/node_modules/…        ← tracejado, na RAIZ
+ *   <versionDir>/packages/ui/…         ← pacotes internos do workspace
+ *   <versionDir>/apps/web/server.js    ← entrypoint REAL
+ *   <versionDir>/apps/web/package.json ← o package.json DO APP mora aqui
+ *
+ * O agente (`neetru-agent-service-vm/src/lib/deploy-plan.ts:117-124`) infere o
+ * comando de start olhando SÓ a raiz do versionDir: `server.js` na raiz,
+ * `.next/` na raiz, `.next/standalone/server.js`, e `scripts.start` do
+ * `package.json` da raiz. Em monorepo os três primeiros não existem, e o
+ * quarto não ajuda: o Next.js escreve o package.json do app em
+ * `<appPrefix>/package.json` (`next/dist/build/utils.js:1197`), então o que
+ * houver na raiz é o package.json do WORKSPACE — que ou não tem `start`, ou
+ * tem um `start` de ferramenta de monorepo (`turbo start`), nunca
+ * `node apps/web/server.js`. Nos dois casos o agente erra: cai no fallback
+ * `'npm start'` (deploy-plan.ts:124) e o systemd entra em crash-loop.
+ *
+ * REGRA: só mandamos o entrypoint quando o agente NÃO consegue acertar sozinho,
+ * isto é quando o standalone está aninhado (`appPrefix` preenchido). Para app
+ * único o agente já resolve certo — e mandar `pkg.main`/`index.js` ali
+ * ATROPELARIA o `npm start` de produtos como o gestovendas, que dependem de
+ * `scripts.start`. Conserto que quebra o caso que funcionava não é conserto.
+ *
+ * Também não mandamos para stack não-node: ali `entrypoint` é `index.html` /
+ * `index.php` / referência de imagem, que não é "arquivo para o `node` rodar".
+ *
+ * ATENÇÃO — a cadeia ainda NÃO fecha só com isto: o Core descarta o campo hoje
+ * (`deployRequestSchema` não o declara, e objeto zod sem `.passthrough()` remove
+ * chave desconhecida em silêncio). Ver "o que falta no Core" na descrição do PR.
+ */
+export declare function entrypointParaDeploy(manifest: Pick<BuildManifest, 'entrypoint' | 'appPrefix' | 'stack'> | null | undefined): string | undefined;
 /** `true` pra `prod`/`production` (o Core normaliza `production`→`prod`). */
 export declare function isProdEnv(envName: string | undefined): boolean;
 /**
  * M7 (auditoria cli/v1 2026-09-29): `POST /api/cli/v1/deploy` com
  * `environmentId` prod exige step-up MFA no Core (mesmo gate de `promote`).
- * Resolve os headers (sessão 1h → --mfa-token → prompt TOTP; fail-closed em
+ * Resolve os headers (--mfa-token → sessão 1h → prompt TOTP; fail-closed em
  * --json/--non-interactive/sem TTY) só quando o alvo é prod. Chamado logo
  * antes do POST — depois do build/upload — pra o TOTP não vencer no meio.
  */
 export declare function resolveDeployStepUpHeaders(opts: Pick<DeployOptions, 'mfaToken' | 'json'>, envName: string, nonInteractive: boolean): Promise<Record<string, string>>;
+/**
+ * Mostra os `warnings[]` que o Core devolve no deploy.
+ *
+ * Medido em 2026-10-12: o Core devolve `warnings` nos TRES alvos e o comentario
+ * dele diz, literalmente, "`warnings[]` na resposta JSON (o CLI exibe pro
+ * operador)" (`cli/v1/deploy/route.ts:309`). `grep warnings` em `deploy.ts`
+ * devolvia ZERO — a promessa nunca foi cumprida.
+ *
+ * O caso que mais doia: a CLI manda o ambiente default e o Core normaliza, e o
+ * aviso de que `environmentId` foi ASSUMIDO disparava em todo deploy sem
+ * `--env` — e sumia 100% das vezes. O operador achava que tinha escolhido.
+ *
+ * Vai pro STDERR de proposito: em `--json` o stdout e contrato de maquina (uma
+ * linha JSON) e nao pode ser poluido. Quem le JSON ja recebe `warnings` no
+ * proprio corpo.
+ */
+export declare function mostrarAvisosDoCore(warnings: unknown, json?: boolean): void;
+/**
+ * `--env` do deploy workspace/cloud-run: fora do vocabulário, encerra com exit
+ * 1 e os valores válidos da MESMA lista que validou (`invalid_env`, com `flag`,
+ * `value` e `valid` no JSON). Exportada para teste.
+ */
+export declare function validarAmbienteDoDeploy(envName: string, json: boolean | undefined): void;
 /**
  * Mapeia o `envName` do deploy ('dev' | 'staging' | 'prod' — vocabulário do
  * `--env` deste comando) pro `targetEnv` que `neetru build` entende
  * ('dev' | 'workspace' | 'prod' — vocabulário de `BuildOptions`/SDK).
  * 'staging' vira 'workspace' (mesmo conceito de ambiente não-dev/não-prod).
  * Valor desconhecido cai em 'prod' (mesmo default conservador de `runBuild`).
+ * P105: a correspondência sai de `VOCABULARIOS_DE_AMBIENTE`, não de `if`s.
  *
  * Fix (2026-07-22, achado da revisão adversarial): sem isso, todo build
  * implícito de `neetru deploy --env dev`/`--env staging` (quando não há
  * artifact em cache) forçava NEXT_PUBLIC_NEETRU_ENV=prod incondicionalmente.
  */
-export declare function deployEnvToBuildTargetEnv(envName: string): 'dev' | 'workspace' | 'prod';
+export declare function deployEnvToBuildTargetEnv(envName: string): RuntimeEnvironmentId;
 /**
  * bug_5b6bb0d7 — segredos NÃO podem viajar por env no deploy.
  *
@@ -178,6 +243,30 @@ export declare function deployEnvToBuildTargetEnv(envName: string): 'dev' | 'wor
  * saírem de sincronia, mas exige atualização manual dos dois lados.
  */
 export declare const SECRET_ENVVAR_PATTERNS: RegExp[];
+/**
+ * Aviso do segredo descartado no `--env-file` de um deploy VM.
+ *
+ * bug_8b85353b (Parte 3): até aqui a mensagem mandava "usar o Secret Manager e
+ * referenciar por nome na VM" — mecanismo que NÃO existia para segredo do
+ * próprio produto (era a 4ª cópia do padrão que o core#632 corrigiu nas outras
+ * três). O caminho real é `neetru secrets set`, que grava no registro
+ * `product_secrets` do Core com o valor direto no Secret Manager. `env` é o
+ * `--env` do deploy, para o comando sugerido já sair com o ambiente certo.
+ *
+ * Revisão do #81 (M1): o comando só é sugerido quando o Core o aceitaria.
+ * Chave reservada (o Core já a entrega ao app: credencial SDK/OIDC/CLI,
+ * módulo, unit) é recusada em `assertValidProductSecretKey`, e nome fora de
+ * CAIXA_ALTA é recusado pela própria CLI (`problemaNaChave`) — sugerir
+ * `neetru secrets set` nesses casos mandava o dev para um caminho que falha.
+ */
+export declare function avisoSegredoDescartadoNaVm(chave: string, env: string | undefined): string;
+/**
+ * O aviso desta chave manda para `neetru secrets set`? Não manda quando o
+ * Core reserva a chave — aí o aviso de que o agente ainda não entrega
+ * segredos do produto também não cabe.
+ */
+export declare function segredoDescartadoApontaSecretsSet(chave: string): boolean;
+export declare function pickTarget(opts: DeployOptions, nonInteractive: boolean, runtime?: string): Promise<'cloud-run' | 'vm' | 'workspace'>;
 /** Verdicts de uma tentativa de probe. Só `healthy` é terminal-sucesso. */
 export type HealthProbeVerdict = 'healthy' | 'degraded' | 'warming' | 'unreachable' | 'unverifiable';
 export interface HealthProbeAttempt {