@neetru/cli 2.31.0 → 2.32.0

package/dist/commands/mobile.js

@@ -11,11 +11,12 @@
  *   GET    /api/cli/v1/products/{slug}/mobile-apps             — role admin|operator
  *   DELETE /api/cli/v1/products/{slug}/mobile-apps/{appId}     — role admin ONLY + step-up MFA
  *
- * `redirectUri` PRECISA ser `https://` (Universal Link/App Link, RFC 8252) —
- * o Core rejeita custom scheme (`meuapp://`) com 400. Isso é decisão de
- * segurança do owner, não limitação temporária — a CLI valida o mesmo
- * localmente pra falhar rápido com mensagem clara, mas NUNCA oferece
- * custom scheme como alternativa.
+ * `redirectUri` PRECISA ser `https://` (Universal Link/App Link, RFC 8252)
+ * ou `http://localhost`/`http://127.0.0.1` (loopback de dev) — mesma regra
+ * do Core (`validateRedirectUris`). O Core rejeita custom scheme
+ * (`meuapp://`) com 400. Isso é decisão de segurança do owner, não
+ * limitação temporária — a CLI valida o mesmo localmente pra falhar rápido
+ * com mensagem clara, mas NUNCA oferece custom scheme como alternativa.
  *
  * O `id` retornado pelo Core é `<slug>__<platform>` — o app é PKCE público
  * (Authorization Code + PKCE, sem client secret).
@@ -42,6 +43,28 @@ const MOBILE_JSON_REL = '.neetru/mobile.json';
 function jsonError(message, error = 'error') {
     console.log(JSON.stringify({ ok: false, error, message }));
 }
+/**
+ * bug_afcf958a (low): espelha EXATAMENTE a regra de `redirectUri` do Core
+ * (`_oidc-clients-core.ts` → `validateRedirectUris`, usada também pelo
+ * registro de apps mobile em `_product-mobile-apps-core.ts`): aceita
+ * `https://` ou `http://` com host `localhost`/`127.0.0.1` (loopback de
+ * dev, RFC 8252). NUNCA custom scheme (`meuapp://`) — isso o Core rejeita
+ * com 400, decisão de segurança do owner, e a CLI não pode ser MAIS
+ * permissiva que o servidor que vai validar de novo.
+ */
+function isAcceptableMobileRedirectUri(uri) {
+    let parsed;
+    try {
+        parsed = new URL(uri);
+    }
+    catch {
+        return false;
+    }
+    if (parsed.protocol === 'https:')
+        return true;
+    return (parsed.protocol === 'http:' &&
+        (parsed.hostname === 'localhost' || parsed.hostname === '127.0.0.1'));
+}
 function mobileStatusColor(status) {
     switch (status) {
         case 'active': return chalk.green(status);
@@ -82,8 +105,9 @@ export async function runMobileInit(opts = {}) {
         safeExit(1);
         return;
     }
-    if (!redirectUri.startsWith('https://')) {
-        const msg = `--redirect-uri precisa ser https:// (Universal Link/App Link). ` +
+    if (!isAcceptableMobileRedirectUri(redirectUri)) {
+        const msg = `--redirect-uri precisa ser https:// (Universal Link/App Link) ou http://localhost ` +
+            `(ou http://127.0.0.1) para dev — mesma regra do Core. ` +
             `Custom scheme (ex: meuapp://) NÃO é aceito — decisão de segurança do owner (RFC 8252), ` +
             `não é limitação temporária. Recebido: "${redirectUri}"`;
         if (opts.json) {
@@ -269,7 +293,7 @@ export async function runMobileList(opts = {}) {
         return;
     }
     renderTable([
-        { header: 'ID', value: (r) => r.id, maxWidth: 30 },
+        { header: 'ID', value: (r) => r.id, identificador: true },
         { header: 'Platform', value: (r) => r.platform, maxWidth: 10 },
         {
             header: 'Bundle/Package',
@@ -277,7 +301,7 @@ export async function runMobileList(opts = {}) {
             maxWidth: 30,
         },
         { header: 'Status', value: (r) => mobileStatusColor(r.status), maxWidth: 14 },
-        { header: 'OIDC Client ID', value: (r) => r.oidcClientId, maxWidth: 34 },
+        { header: 'OIDC Client ID', value: (r) => r.oidcClientId, identificador: true },
     ], resp.apps);
 }
 /**

package/dist/commands/new.d.ts

@@ -1,6 +1,10 @@
 export interface NewMacroOptions {
     productSlug?: string;
-    env?: 'dev' | 'staging' | 'prod';
+    /**
+     * bug_7dcb68e2666a43f69ef362d2cbff94ed: era `'dev' | 'staging' | 'prod'`.
+     * `'dev'` não existe no enum do Core — ver `../lib/envs.ts`.
+     */
+    env?: string;
     tier?: 'dev' | 'standard' | 'enterprise';
     customer?: string;
     /** Pula scaffold local (útil quando o repo já existe). */
@@ -28,4 +32,28 @@ export interface NewMacroOptions {
     semDocs?: boolean;
     json?: boolean;
 }
+/**
+ * Decisão PURA de qual `customerId` a macro deve usar.
+ *
+ * bug_7dcb68e2666a43f69ef362d2cbff94ed — antes a macro assumia `'self'` em
+ * silêncio. `'self'` é um sentinel que o Core só aceita para produto
+ * **Neetru-owned** (`resolveDefaultCustomer`); para qualquer outro produto ele
+ * recusa a criação do workspace. Como a macro cria o produto no passo [1/5] e
+ * o workspace no [2/5], o resultado era um produto órfão no Core e um erro
+ * incompreensível no meio da macro.
+ *
+ * Agora a macro exige `--customer` explícito quando o produto não é
+ * Neetru-owned — e diz isso, em vez de deixar o Core recusar depois.
+ */
+export declare function decidirCustomerDaMacro(entrada: {
+    fromFlag?: string;
+    produtoEhNeetru: boolean;
+    slug: string;
+}): {
+    ok: true;
+    customerId: string;
+} | {
+    ok: false;
+    mensagem: string;
+};
 export declare function runNewMacro(name: string, opts?: NewMacroOptions): Promise<void>;

package/dist/commands/new.js

@@ -27,6 +27,8 @@ import { runInit } from './init.js';
 import { runDbInit } from './db.js';
 import { requireToken } from '../lib/cli-read.js';
 import { config } from '../lib/config.js';
+import { isNeetruOwnedProduct, isNeetruOwnedSlug } from '../lib/pickers.js';
+import { DEFAULT_TENANT_ENVIRONMENT_ID, resolverAmbienteTenant, } from '../lib/envs.js';
 import { safeExit } from '../utils/safe-exit.js';
 /**
  * Captura erro de um passo do macro como mensagem human-readable.
@@ -140,15 +142,65 @@ function buildDashboardUrl(productId) {
     const baseUrl = String(config.get('neetruCoreUrl') ?? 'https://core.neetru.com').replace(/\/+$/, '');
     return `${baseUrl}/products/${encodeURIComponent(productId)}`;
 }
+/**
+ * Decisão PURA de qual `customerId` a macro deve usar.
+ *
+ * bug_7dcb68e2666a43f69ef362d2cbff94ed — antes a macro assumia `'self'` em
+ * silêncio. `'self'` é um sentinel que o Core só aceita para produto
+ * **Neetru-owned** (`resolveDefaultCustomer`); para qualquer outro produto ele
+ * recusa a criação do workspace. Como a macro cria o produto no passo [1/5] e
+ * o workspace no [2/5], o resultado era um produto órfão no Core e um erro
+ * incompreensível no meio da macro.
+ *
+ * Agora a macro exige `--customer` explícito quando o produto não é
+ * Neetru-owned — e diz isso, em vez de deixar o Core recusar depois.
+ */
+export function decidirCustomerDaMacro(entrada) {
+    const informado = entrada.fromFlag?.trim();
+    if (informado)
+        return { ok: true, customerId: informado };
+    // Produto da própria Neetru → o Core injeta o customer interno sozinho.
+    if (entrada.produtoEhNeetru)
+        return { ok: true, customerId: 'self' };
+    return {
+        ok: false,
+        mensagem: `O produto "${entrada.slug}" não é Neetru-owned — o Core exige um customer explícito.\n\n` +
+            '  Customer = a entidade comercial (PJ) que vai operar o ambiente.\n' +
+            '  Sem ele o Core recusa a criação do workspace, e o `neetru new` não\n' +
+            '  tem como adivinhar qual é.\n\n' +
+            '  Rode de novo informando o customer:\n' +
+            `    neetru new "${entrada.slug}" --customer <customerId>\n\n` +
+            '  Para descobrir ou criar um customerId:\n' +
+            '    neetru customers list\n' +
+            '    neetru customers create --name "..." --email "..."\n' +
+            '    • Painel: https://core.neetru.com/customers\n',
+    };
+}
+/**
+ * Descobre se o produto alvo é Neetru-owned ANTES de criar qualquer coisa.
+ * Se o slug já existe no Core, pergunta ao Core; se ainda não existe, só o
+ * espelho de slugs conhecidos pode responder.
+ */
+async function produtoDoSlugEhNeetru(token, slug) {
+    if (isNeetruOwnedSlug(slug))
+        return true;
+    const existente = await lookupProductBySlug(token, slug);
+    if (!existente)
+        return false;
+    return isNeetruOwnedProduct(token, existente.id);
+}
 export async function runNewMacro(name, opts = {}) {
     if (!name || !name.trim()) {
         log.error('Uso: neetru new <name>');
         safeExit(1);
     }
     let slug = (opts.productSlug ?? deriveSlug(name)) || deriveSlug(name);
-    const env = opts.env ?? 'dev';
+    // bug_7dcb68e2666a43f69ef362d2cbff94ed: o padrão era 'dev', token que o Core
+    // não conhece — a macro morria no passo [2/5] com 400 validation_failed.
+    const env = opts.env
+        ? resolverAmbienteTenant(opts.env, opts.json)
+        : DEFAULT_TENANT_ENVIRONMENT_ID;
     const tier = opts.tier ?? 'standard';
-    const customer = opts.customer ?? 'self';
     if (!opts.json) {
         log.banner();
         log.heading(`neetru new ${name}`);
@@ -158,6 +210,28 @@ export async function runNewMacro(name, opts = {}) {
     const summary = [];
     // ─── Autenticar (obrigatório para lookup de conflito e criação) ──────────
     const token = await requireToken(opts.json);
+    // ─── Customer — resolvido ANTES do passo [1/5] ───────────────────────────
+    // Falhar aqui evita o pior cenário do bug: produto criado no Core e macro
+    // abortada no passo seguinte, deixando lixo que o dev precisa limpar à mão.
+    const decisaoCustomer = decidirCustomerDaMacro({
+        fromFlag: opts.customer,
+        produtoEhNeetru: await produtoDoSlugEhNeetru(token, slug),
+        slug,
+    });
+    if (!decisaoCustomer.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({
+                ok: false,
+                error: 'customer_required',
+                message: decisaoCustomer.mensagem,
+            }));
+        }
+        else {
+            log.error(decisaoCustomer.mensagem);
+        }
+        safeExit(1);
+    }
+    const customer = decisaoCustomer.customerId;
     // ─── Step 1 — Criar produto (com tratamento de conflito de slug) ─────────
     let product;
     let isLinked = false;
@@ -184,14 +258,23 @@ export async function runNewMacro(name, opts = {}) {
                         console.log();
                         log.success(`[1/5] Vinculado ao produto existente: ${resolution.product.id} (${resolution.product.slug ?? slug})`);
                     }
+                    // Produto VINCULADO, não criado — nada aqui veio do servidor. Antes
+                    // este objeto chutava `planTemplate: 'free'` e
+                    // `environments: ['dev','prod']`: a mesma mentira do bug
+                    // bug_db50b21f84e8400f9c3f6286b69c353b, agora inventada localmente
+                    // sobre um produto preexistente que pode ter qualquer configuração.
+                    // `null` + não-confirmado é o que de fato sabemos.
                     product = {
                         ok: true,
                         productId: resolution.product.id,
                         slug: resolution.product.slug ?? slug,
                         name: resolution.product.name ?? name,
                         ownerTeam: 'neetru-eng',
-                        planTemplate: 'free',
-                        environments: ['dev', 'prod'],
+                        planTemplate: null,
+                        environments: null,
+                        environmentsRequested: [],
+                        environmentsConfirmed: false,
+                        planTemplateConfirmed: false,
                         createdAt: null,
                         dashboardUrl: buildDashboardUrl(resolution.product.id),
                     };
@@ -284,6 +367,11 @@ export async function runNewMacro(name, opts = {}) {
     // Use `--open` para abrir explicitamente. Útil em dev local; indesejável em CI.
     const dashboardUrl = buildWorkspaceDashboardUrl(workspaceId);
     if (opts.open) {
+        // bug_d414f21c: este `try/catch` dá falso conforto. A falha de `spawn` por
+        // binário ausente (WSL/container sem `xdg-open`) chega como evento 'error'
+        // ASSÍNCRONO, depois que `openBrowser` já retornou — catch nenhum aqui pega.
+        // Quem segura isso é o listener dentro de `safeOpenUrl` (open.ts); sem ele o
+        // processo morria neste passo [4/5] e o passo [5/5] (`runDbInit`) nunca rodava.
         try {
             openBrowser(dashboardUrl);
             if (!opts.json)

package/dist/commands/open.js

@@ -35,20 +35,30 @@ export function safeOpenUrl(url) {
         log.warn(`URL inválida (protocolo não permitido): ${url}`);
         return;
     }
+    const avisarFallback = () => {
+        log.warn(`Não consegui abrir browser. Acesse manualmente: ${url}`);
+    };
     try {
         if (process.platform === 'win32') {
             // rundll32 url.dll,FileProtocolHandler não passa pelo shell — sem injeção.
+            // `spawnSync` falha de forma SÍNCRONA, então o `catch` abaixo já cobre.
             spawnSync('rundll32', ['url.dll,FileProtocolHandler', url], { shell: false });
             return;
         }
-        if (process.platform === 'darwin') {
-            spawn('open', [url], { detached: true, stdio: 'ignore', shell: false }).unref();
-            return;
-        }
-        spawn('xdg-open', [url], { detached: true, stdio: 'ignore', shell: false }).unref();
+        // bug_d414f21c: `spawn` com binário ausente (WSL/container sem `xdg-open`)
+        // emite 'error' (ENOENT) de forma ASSÍNCRONA. Sem listener o Node promove
+        // isso a exceção não capturada e DERRUBA o processo — o `try/catch` daqui
+        // não pega nada, porque a falha chega depois do `return`. O 59c13b8 colocou
+        // o listener no `openBrowser` do login e deixou este helper (usado por
+        // `neetru open`, `docs open`, `workspaces open` e `new --open`) sem ele.
+        const filho = process.platform === 'darwin'
+            ? spawn('open', [url], { detached: true, stdio: 'ignore', shell: false })
+            : spawn('xdg-open', [url], { detached: true, stdio: 'ignore', shell: false });
+        filho.on('error', avisarFallback);
+        filho.unref();
     }
     catch (_e) {
-        log.warn(`Não consegui abrir browser. Acesse manualmente: ${url}`);
+        avisarFallback();
     }
 }
 /** @deprecated Use safeOpenUrl — mantido para compatibilidade interna. */

package/dist/commands/ops.js

@@ -145,7 +145,7 @@ export async function runOpsSmokeObservability(opts) {
 export async function runOpsRegToken(serverId, opts) {
     const token = await requireToken(opts.json);
     // H5 (auditoria cli/v1 2026-09-29): o token dá credencial de agente pra
-    // QUALQUER server — o Core exige step-up MFA (sessão 1h → --mfa-token → prompt).
+    // QUALQUER server — o Core exige step-up MFA (--mfa-token → sessão 1h → prompt).
     const { headers } = await resolveStepUp({ mfaToken: opts.mfaToken, json: opts.json });
     const spinner = opts.json ? null : ora({ text: `Gerando registration token para ${serverId}…`, color: 'blue' }).start();
     let res;

package/dist/commands/products-db.d.ts

@@ -34,6 +34,7 @@ export declare function runDbRotate(id: string | undefined, opts: {
 export declare function runDbDelete(id: string | undefined, opts: {
     json?: boolean;
     force?: boolean;
+    mfaToken?: string;
 }): Promise<void>;
 export declare function runDbEngines(opts: {
     json?: boolean;

package/dist/commands/products-db.js

@@ -23,6 +23,12 @@ import { pickDatabase, pickProductId, pickServer, promptChoice, promptText, } fr
 import { log } from '../utils/logger.js';
 // bug_863ae5: pre-flight IAM check antes de operações de provisionamento.
 import { assertIamReady } from '../lib/iam-preflight.js';
+// QUINTA cópia do defeito do `--env` (bug_7dcb68e2): este comando oferecia e
+// usava `'dev'` por padrão, token que o Core recusa. A fonte única do alfabeto
+// de BANCO é `db-local/env.js` — NÃO `lib/envs.js`, que é o alfabeto de
+// tenant/workspace/deployment e usa `'prod'` onde o banco usa `'production'`.
+import { normalizeEnv, erroAmbienteBancoInvalido, NEETRU_ENVS, } from '../lib/db-local/env.js';
+import { exitWithCliError } from '../lib/cli-error.js';
 function colorStatus(s) {
     if (s === 'active')
         return chalk.green(s);
@@ -62,8 +68,8 @@ export async function runDbList(opts) {
     }
     log.heading(`Bancos de dados (${res.count})`);
     renderTable([
-        { header: 'ID', value: (r) => r.id, maxWidth: 20 },
-        { header: 'PRODUTO', value: (r) => r.productId, maxWidth: 18 },
+        { header: 'ID', value: (r) => r.id, identificador: true },
+        { header: 'PRODUTO', value: (r) => r.productId, identificador: true },
         { header: 'LABEL', value: (r) => r.label, maxWidth: 22 },
         { header: 'ENGINE', value: (r) => r.engine, maxWidth: 20 },
         { header: 'ENV', value: (r) => r.environment },
@@ -74,6 +80,7 @@ export async function runDbCreate(opts) {
     const token = await requireToken(opts.json);
     const productId = await pickProductId(token, {
         fromFlag: opts.productId,
+        inputs: ['--product-id'],
         json: opts.json,
         message: 'Produto do banco:',
     });
@@ -89,15 +96,27 @@ export async function runDbCreate(opts) {
             { name: 'vm-mysql-cluster', value: 'vm-mysql-cluster' },
             { name: 'nosql-vm (MongoDB)', value: 'nosql-vm' },
         ], { default: 'firestore-instance', json: opts.json }));
-    const environment = opts.env ??
-        (await promptChoice('Ambiente:', [
-            { name: 'dev', value: 'dev' },
-            { name: 'staging', value: 'staging' },
-            { name: 'production', value: 'production' },
-        ], { default: 'dev', json: opts.json }));
+    // bug_7dcb68e2 (5ª cópia): o prompt oferecia `'dev'` E o usava como padrão.
+    // `_createProductDatabaseCore` (neetru-core:337) valida por igualdade estrita
+    // contra ['dev-local','staging','production'] — quem aceitava o padrão
+    // sugerido pela própria ferramenta tomava erro. `normalizeEnv` colapsa os
+    // apelidos (dev→dev-local, prod→production) e avisa no stderr, em vez de
+    // reescrever em silêncio.
+    let environment;
+    try {
+        environment = opts.env
+            ? normalizeEnv(opts.env)
+            : (await promptChoice('Ambiente:', 
+            // bug_89d2497e: o que a CLI OFERECE sai da mesma lista que valida.
+            NEETRU_ENVS.map((v) => ({ name: v === 'dev-local' ? 'dev-local (padrão)' : v, value: v })), { default: 'dev-local', json: opts.json }));
+    }
+    catch {
+        return exitWithCliError(erroAmbienteBancoInvalido(opts.env), opts.json);
+    }
     const serverId = opts.serverId ??
         (engine.startsWith('vm-')
             ? await pickServer(token, {
+                inputs: ['--server-id'],
                 json: opts.json,
                 status: 'online',
                 capacity: true,
@@ -294,11 +313,25 @@ export async function runDbDelete(id, opts) {
         json: opts.json,
         message: 'Banco para arquivar:',
     });
+    // bug_757b9746 (2026-10-11): `/delete` exige step-up MFA no Core
+    // (`requireCliStepUpMfa`), mas este comando chamava `apiRequest` SEM header
+    // nenhum — nem `X-Neetru-MFA-Token`, nem `X-Neetru-MFA-Session`. A sessão de
+    // 1h ERA gravada e ERA carregada; `admin database delete` é que nunca pedia
+    // por ela. O Core devolvia 401 mesmo com sessão ativa, e o hint do
+    // `handleApiError` mandava passar `--mfa-token` — flag que o subcomando nem
+    // declarava. Resultado: impossível arquivar banco pela CLI, e o anti-replay
+    // do Core recusava o mesmo TOTP nas tentativas seguintes.
+    // Mesmo hotfix que `runDbRotate` levou em 2026-08-16, pelo mesmo motivo.
+    const { headers: mfaHeaders } = await resolveStepUp({
+        mfaToken: opts.mfaToken,
+        json: opts.json,
+    });
     try {
         const res = await apiRequest(`/api/cli/v1/db/${encodeURIComponent(databaseId)}/delete`, {
             token,
             method: 'POST',
             body: { force: !!opts.force },
+            headers: mfaHeaders,
         });
         if (opts.json) {
             console.log(JSON.stringify(res));

package/dist/commands/products.d.ts

@@ -39,7 +39,13 @@ export interface ProductsCreateOptions {
     description?: string;
     ownerTeam?: string;
     planTemplate?: string;
-    /** CSV de envs (ex: "dev,prod"). */
+    /**
+     * CSV de envs (ex: "dev,prod").
+     *
+     * ATENÇÃO (bug bug_db50b21f84e8400f9c3f6286b69c353b): hoje o Core NÃO honra
+     * esse campo — ver `AMBIENTES_AUTO_PROVISIONADOS` abaixo. Continua aceito pra
+     * não quebrar script existente, mas a saída marca que o pedido foi ignorado.
+     */
     env?: string;
     /** Pula prompts — exige pelo menos `name`. */
     yes?: boolean;
@@ -51,8 +57,16 @@ export interface ProductCreatedResult {
     slug: string;
     name: string;
     ownerTeam: string;
-    planTemplate: ProductPlanTemplate;
-    environments: string[];
+    /** Plano-template CONFIRMADO pelo servidor. `null` quando ele não devolveu. */
+    planTemplate: ProductPlanTemplate | null;
+    /** Ambientes CONFIRMADOS pelo servidor. `null` quando ele não devolveu. */
+    environments: string[] | null;
+    /** O que o usuário pediu (`--env` ou default). Pedido ≠ gravado. */
+    environmentsRequested: string[];
+    /** `true` só quando a resposta do servidor trouxe `environments`. */
+    environmentsConfirmed: boolean;
+    /** `true` só quando a resposta do servidor trouxe `planTemplate`. */
+    planTemplateConfirmed: boolean;
     createdAt: string | number | null;
     dashboardUrl: string;
 }

package/dist/commands/products.js

@@ -17,6 +17,7 @@ import { requireToken, handleApiError } from '../lib/cli-read.js';
 import { printWriteResult } from '../lib/cli-write.js';
 import { renderTable } from '../lib/render.js';
 import { pickProductSlug } from '../lib/pickers.js';
+import { TENANT_ENVIRONMENT_IDS, VOCABULARIOS_DE_AMBIENTE } from '../lib/envs.js';
 import { log } from '../utils/logger.js';
 import { safeExit } from '../utils/safe-exit.js';
 // ─── Erros tipados ─────────────────────────────────────────────────────────
@@ -82,7 +83,7 @@ export async function runProductsList(opts) {
     }
     log.heading(`Produtos (${res.count})`);
     renderTable([
-        { header: 'ID', value: (r) => r.id, maxWidth: 22 },
+        { header: 'ID', value: (r) => r.id, identificador: true },
         { header: 'NOME', value: (r) => r.name ?? '—', maxWidth: 26 },
         { header: 'SLUG', value: (r) => r.slug ?? '—', maxWidth: 22 },
         { header: 'STATUS', value: (r) => colorStatus(r.status) },
@@ -101,6 +102,7 @@ async function runProductsPublishToggle(slug, published, opts) {
     const token = await requireToken(opts.json);
     const productSlug = await pickProductSlug(token, {
         fromFlag: slug,
+        inputs: ['<slug>'],
         json: opts.json,
         message: published ? 'Produto a publicar:' : 'Produto a despublicar:',
     });
@@ -128,6 +130,25 @@ export async function runProductsUnpublish(slug, opts) {
     return runProductsPublishToggle(slug, false, opts);
 }
 const VALID_PLAN_TEMPLATES = ['free', 'starter', 'pro'];
+/**
+ * Ambientes que o Core cria sozinho ao criar o produto.
+ *
+ * Não é escolha da CLI: `_products-core.ts` (Core) chama `_ensureEnvironmentCore`
+ * pra 'staging' e 'prod' logo depois de gravar o doc do produto, e deixa
+ * 'dev-local' de fora de propósito (é local, não existe no servidor).
+ * Serve só pra EXPLICAR por que o `--env` do usuário não valeu — não é promessa
+ * de que os dois ambientes existem, porque lá a criação é best-effort.
+ *
+ * P105: derivado do alfabeto do Core (todos menos o local) em vez de escrito à mão.
+ */
+const AMBIENTES_AUTO_PROVISIONADOS = TENANT_ENVIRONMENT_IDS.filter((e) => e !== 'dev-local');
+/**
+ * O `environments` que a CLI manda quando o `--env` não vem. O Core IGNORA o
+ * campo (ver acima); o valor de sempre (`dev`, `prod`) é o vocabulário do
+ * `--env` do deploy para `dev-local` e `prod`, e agora sai da tabela
+ * `VOCABULARIOS_DE_AMBIENTE` em vez de uma lista à mão (P105) — mesmo payload.
+ */
+const AMBIENTES_PEDIDOS_POR_PADRAO = TENANT_ENVIRONMENT_IDS.filter((e) => e !== 'staging').map((id) => VOCABULARIOS_DE_AMBIENTE[id].deploy);
 /**
  * Deriva um slug `kebab-case` a partir do `name`. Mantém apenas [a-z0-9-]
  * + colapsa hífens + corta hífens nas pontas. Não verifica unicidade — isso é
@@ -164,7 +185,9 @@ export async function runProductsCreate(opts) {
     let description = opts.description ?? '';
     let ownerTeam = opts.ownerTeam?.trim() || 'neetru-eng';
     let planTemplate = (opts.planTemplate ?? 'free').toLowerCase();
-    let environments = parseEnvCsv(opts.env, ['dev', 'prod']);
+    // Só o que o usuário PEDIU. O nome deixa explícito que isso nunca é resposta
+    // do servidor — ver bug bug_db50b21f84e8400f9c3f6286b69c353b.
+    const environmentsRequested = parseEnvCsv(opts.env, [...AMBIENTES_PEDIDOS_POR_PADRAO]);
     const interactive = !opts.yes && !opts.json && process.stdin.isTTY;
     if (interactive) {
         const answers = await inquirer.prompt([
@@ -204,13 +227,11 @@ export async function runProductsCreate(opts) {
                 choices: VALID_PLAN_TEMPLATES,
                 default: 'free',
             },
-            {
-                type: 'input',
-                name: 'env',
-                message: 'Ambientes (csv):',
-                when: () => !opts.env,
-                default: environments.join(','),
-            },
+            // Não existe mais pergunta de "Ambientes (csv)" aqui.
+            // Motivo (bug bug_db50b21f84e8400f9c3f6286b69c353b): a resposta era
+            // descartada pelo servidor e ainda assim impressa como se tivesse valido.
+            // Perguntar algo que não é honrado é pior que não perguntar — o Core
+            // auto-provisiona staging+prod sozinho.
         ]);
         if (answers.name)
             name = answers.name.trim();
@@ -222,8 +243,6 @@ export async function runProductsCreate(opts) {
             ownerTeam = answers.ownerTeam.trim();
         if (answers.planTemplate)
             planTemplate = answers.planTemplate;
-        if (answers.env)
-            environments = parseEnvCsv(answers.env, environments);
     }
     // Validação final
     if (!name) {
@@ -271,8 +290,13 @@ export async function runProductsCreate(opts) {
                 slug,
                 description: description || undefined,
                 ownerTeam,
+                // `planTemplate` e `environments` continuam no corpo de propósito: o dia
+                // que o Core declarar esses campos no `cliProductCreateSchema` e
+                // devolvê-los na resposta, a CLI passa a reportar o valor REAL sem novo
+                // deploy. Enquanto isso o zod do Core os descarta em silêncio — por isso
+                // nada abaixo trata o que mandamos como se tivesse sido gravado.
                 planTemplate,
-                environments,
+                environments: environmentsRequested,
             },
         });
         spinner?.stop();
@@ -292,14 +316,30 @@ export async function runProductsCreate(opts) {
         handleApiError(error, opts.json);
     }
     const productId = res.productId ?? res.id ?? slug;
+    // BUG bug_db50b21f84e8400f9c3f6286b69c353b — POR QUE isto deixou de ser
+    // `res.environments ?? environments`:
+    // o POST /api/cli/v1/products do Core valida o corpo com `cliProductCreateSchema`,
+    // que NÃO declara `environments` nem `planTemplate`; o zod (não-strict) descarta
+    // chave desconhecida em silêncio, sem 400. A resposta também não devolve esses
+    // campos. O fallback antigo caía no valor PEDIDO e a tabela imprimia como se
+    // fosse o gravado — quem usou `--env dev,prod` saía convencido de ter escolhido
+    // ambientes que nunca existiram. Agora só é verdade o que o servidor devolveu;
+    // o resto vai marcado como não confirmado, aqui e no `--json`.
+    const environmentsConfirmed = Array.isArray(res.environments);
+    const planTemplateConfirmed = typeof res.planTemplate === 'string';
+    // `name` e `ownerTeam` seguem com fallback porque o schema do Core ACEITA os
+    // dois — eles foram gravados, o servidor só não os ecoa de volta.
     const result = {
         ok: true,
         productId,
         slug: res.slug ?? slug,
         name: res.name ?? name,
         ownerTeam: res.ownerTeam ?? ownerTeam,
-        planTemplate: res.planTemplate ?? planTemplate,
-        environments: res.environments ?? environments,
+        planTemplate: planTemplateConfirmed ? res.planTemplate : null,
+        environments: environmentsConfirmed ? res.environments : null,
+        environmentsRequested,
+        environmentsConfirmed,
+        planTemplateConfirmed,
         createdAt: res.createdAt ?? null,
         dashboardUrl: buildDashboardUrl(productId),
     };
@@ -316,12 +356,40 @@ export async function runProductsCreate(opts) {
         { k: 'slug', v: chalk.cyan(result.slug) },
         { k: 'name', v: result.name },
         { k: 'ownerTeam', v: result.ownerTeam },
-        { k: 'planTemplate', v: chalk.yellow(result.planTemplate) },
-        { k: 'environments', v: result.environments.join(', ') },
+        {
+            k: 'planTemplate',
+            v: result.planTemplate
+                ? chalk.yellow(result.planTemplate)
+                : chalk.dim('— (não confirmado pelo servidor)'),
+        },
+        {
+            k: 'environments',
+            v: result.environments
+                ? result.environments.join(', ')
+                : // Curto de propósito: a coluna trunca em 60 e o recado longo some
+                    // num `…`. A explicação inteira vai na linha abaixo da tabela.
+                    chalk.dim(`${AMBIENTES_AUTO_PROVISIONADOS.join(', ')} (não confirmados)`),
+        },
         { k: 'createdAt', v: result.createdAt ? String(result.createdAt) : '—' },
         { k: 'dashboardUrl', v: chalk.blue(result.dashboardUrl) },
     ]);
     console.log();
+    // Estas duas linhas existem por causa do bug: o usuário precisa sair do
+    // comando sabendo o que NÃO foi decidido por ele.
+    // (Só no caminho humano: `log.warn`/`log.dim` escrevem em stdout e sujariam
+    // o `--json`, que já carrega `environmentsConfirmed` pra quem é máquina.)
+    if (!result.environmentsConfirmed) {
+        log.dim(`environments: o Core provisiona ${AMBIENTES_AUTO_PROVISIONADOS.join(' e ')} por conta própria ` +
+            `e não devolve o campo nesta resposta — confira o que existe de fato com ` +
+            `"neetru workspaces list --product ${result.productId}".`);
+    }
+    // Quem digitou `--env` merece saber que o pedido foi pro lixo, em vez de
+    // descobrir depois procurando um ambiente que nunca foi criado.
+    if (!result.environmentsConfirmed && opts.env) {
+        log.warn(`--env (${result.environmentsRequested.join(', ')}) foi IGNORADO pelo Core — ele não aceita escolha de ambientes na criação do produto.`);
+    }
+    if (!result.environmentsConfirmed)
+        console.log();
     log.dim(`Abra no painel:  neetru workspaces open ${result.productId}`);
     return result;
 }