@neetru/cli 2.31.0 → 2.32.0

package/dist/lib/cli-write.js

@@ -20,6 +20,9 @@ import { requireToken, handleApiError } from './cli-read.js';
 import { CliApiError } from './api-client.js';
 import { log } from '../utils/logger.js';
 import { safeExit } from '../utils/safe-exit.js';
+import { EXIT_CODES, NeetruCliError } from '../cli-kit/errors.js';
+import { adviseCommand, adviseFlag, declaredFlags } from '../cli-kit/command-context.js';
+import { exitWithCliError } from './cli-error.js';
 export { requireToken, handleApiError };
 function getMfaSessionFilePath() {
     return join(homedir(), '.config', 'neetru-cli', 'mfa-session.json');
@@ -89,6 +92,55 @@ export async function clearMfaSession() {
         // Ignora — arquivo já inexistente ou sem permissão.
     }
 }
+/**
+ * uid dono de um token de sessão MFA. O Core emite
+ * `<uid_base64url>.<issuedAt_hex>.<hmac_sha256_hex>` (`createCliMfaSessionToken`
+ * em `src/lib/auth-mfa-session.ts`): o uid é a parte ASSINADA, não segredo — o
+ * servidor só aceita a sessão se ele bater com o uid do Bearer. `null` se o
+ * formato não for reconhecido.
+ */
+export function mfaSessionOwnerUid(token) {
+    const parts = token.split('.');
+    if (parts.length !== 3 || !parts[0])
+        return null;
+    try {
+        const uid = Buffer.from(parts[0], 'base64url').toString('utf8');
+        return /^[\x21-\x7e]+$/.test(uid) ? uid : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Descarta a sessão MFA salva quando ela não é do `uid` que acabou de logar.
+ *
+ * A8 (2026-10-13): `neetru login` com outra conta trocava o Bearer mas deixava
+ * o `mfa-session.json` da conta anterior. O Core recusa sessão de outro uid,
+ * então TODO comando destrutivo tomava 401 `mfa_required` por até 1h (e, antes
+ * do conserto da precedência em `resolveStepUp`, nem `--mfa-token` salvava).
+ * Sessão de dono desconhecido (arquivo corrompido, formato não reconhecido)
+ * também sai — o servidor recusaria do mesmo jeito. Sessão do MESMO uid fica
+ * (re-login na mesma conta não deve exigir TOTP de novo). Retorna `true` se
+ * apagou.
+ */
+export async function discardMfaSessionOfOtherUid(uid) {
+    const path = getMfaSessionFilePath();
+    if (!existsSync(path))
+        return false;
+    let owner = null;
+    try {
+        const data = JSON.parse(readFileSync(path, 'utf8'));
+        if (typeof data.mfaSessionToken === 'string')
+            owner = mfaSessionOwnerUid(data.mfaSessionToken);
+    }
+    catch {
+        // corrompido → dono desconhecido → descarta
+    }
+    if (owner !== null && owner === uid)
+        return false;
+    await clearMfaSession();
+    return true;
+}
 /**
  * Pede uma confirmação interativa `y/N` no terminal. Resolve `true` se o
  * operador digitou `y`/`yes` (case-insensitive); `false` caso contrário.
@@ -108,6 +160,31 @@ function promptYesNo(question) {
         });
     });
 }
+/** As flags que pulam a confirmação, na ordem em que o conselho as cita. */
+const FLAGS_DE_CONFIRMACAO = ['--yes', '--force'];
+/**
+ * O que dizer quando a confirmação não pode ser perguntada (P105 /
+ * bug_89d2497e). Cita só as flags de confirmação que o comando EM EXECUÇÃO
+ * declara: o texto fixo "use --yes (ou --force)" chegava a 8 comandos que
+ * declaram `--yes` mas não `--force` (medido na árvore do Commander em
+ * 2026-10-18: `servers pgbouncer sync-userlist`, `products memory set`,
+ * `vm memory set`, `db move start|abort|decommission`, `promote execute`,
+ * `mobile revoke`) — quem seguisse com `--force` tomava "unknown option".
+ * Sem nenhuma das duas (ou fora do Commander, como no menu), não cita flag.
+ */
+export function confirmationAdvice(modo) {
+    const flags = declaredFlags(FLAGS_DE_CONFIRMACAO);
+    if (modo === 'json') {
+        return flags.length > 0
+            ? `Operação destrutiva em modo --json exige ${flags[0]}.`
+            : 'Operação destrutiva em modo --json exige confirmação, e este comando não tem como confirmar sem perguntar.';
+    }
+    if (flags.length === 0) {
+        return 'Terminal não-interativo: esta operação destrutiva só pode ser confirmada num terminal interativo.';
+    }
+    const lista = flags.length > 1 ? `${flags[0]} (ou ${flags[1]})` : flags[0];
+    return `Terminal não-interativo: use ${lista} para confirmar operações destrutivas.`;
+}
 /**
  * Gate de confirmação pra operações DESTRUTIVAS (suspend, deactivate, delete,
  * rollback, archive, yank). Se `--yes`/`--force` foi passado, retorna sem
@@ -129,7 +206,7 @@ export async function confirmDestructive(message, opts) {
         console.log(JSON.stringify({
             ok: false,
             error: 'confirmation_required',
-            message: 'Operação destrutiva em modo --json exige --yes.',
+            message: confirmationAdvice('json'),
         }));
         safeExit(1);
     }
@@ -137,7 +214,7 @@ export async function confirmDestructive(message, opts) {
     const confirmed = await promptYesNo('Confirmar?');
     if (!confirmed) {
         if (!process.stdin.isTTY) {
-            log.error('Terminal não-interativo: use --yes (ou --force) para confirmar operações destrutivas.');
+            log.error(confirmationAdvice('nao-interativo'));
         }
         else {
             log.dim('Operação cancelada.');
@@ -157,21 +234,56 @@ function promptLine(question) {
         });
     });
 }
+/**
+ * O step-up que dá pra mandar SEM interação, na ordem de precedência:
+ *   1. `--mfa-token` explícito → `X-Neetru-MFA-Token`;
+ *   2. sessão de 1h salva (`~/.config/neetru-cli/mfa-session.json`) →
+ *      `X-Neetru-MFA-Session` (salvo `skipSession`).
+ * `{}` se não houver nenhum dos dois (aí o caller prompta ou falha fechado).
+ *
+ * A8 (2026-10-13): o código explícito VENCE a sessão. Antes `resolveStepUp`
+ * olhava a sessão primeiro e devolvia só `X-Neetru-MFA-Session`, descartando o
+ * `--mfa-token` em silêncio — enquanto `withStepUpRetry` fazia o contrário.
+ * Depois de `neetru login` com outra conta (sessão do uid anterior no disco,
+ * que o Core recusa), ~40 comandos destrutivos davam 401 por até 1h MESMO com
+ * `--mfa-token`. Quem digita o código está pedindo que ele seja usado. As duas
+ * funções agora decidem por aqui — uma regra só.
+ */
+function nonInteractiveStepUp(opts) {
+    const code = (opts.mfaToken ?? '').trim();
+    const savedSession = opts.skipSession ? null : loadMfaSession();
+    // Código explícito + sessão salva: manda OS DOIS (revisão do #78). O Core
+    // (`requireCliStepUpMfa`) tenta a sessão primeiro e só usa o TOTP se ela não
+    // servir — e o TOTP é de USO ÚNICO (`mfa-lockout`). Mandar só o código gastava
+    // o código à toa quando a sessão era válida, e o 2º comando com o mesmo código
+    // (agente com o código ditado, script) falhava com mfa_invalid. Com os dois, a
+    // sessão de OUTRA conta (o caso do A8) cai e o código ainda salva o pedido.
+    if (code) {
+        return savedSession
+            ? { 'X-Neetru-MFA-Token': code, 'X-Neetru-MFA-Session': savedSession }
+            : { 'X-Neetru-MFA-Token': code };
+    }
+    if (savedSession)
+        return { 'X-Neetru-MFA-Session': savedSession };
+    return {};
+}
 /**
  * Resolve o que uma operação destrutiva TOP-TIER precisa mandar pro servidor:
- *  - `headers`: `X-Neetru-MFA-Session` (sessão de 1h) OU `X-Neetru-MFA-Token`
- *    (TOTP fresco) e/ou `X-Neetru-Dry-Run`.
+ *  - `headers`: `X-Neetru-MFA-Token` (TOTP fresco) OU `X-Neetru-MFA-Session`
+ *    (sessão de 1h) e/ou `X-Neetru-Dry-Run`.
  *
  * Ordem de preferência:
  *   1. dry-run: sem MFA, só `X-Neetru-Dry-Run: true`.
- *   2. Sessão de 1h salva localmente (`~/.config/neetru-cli/mfa-session.json`):
- *      usa `X-Neetru-MFA-Session` sem pedir TOTP. Silencioso — o operador
- *      não precisa saber que a sessão está ativa.
- *   3. TOTP fresco: do flag `--mfa-token` ou prompt interativo.
- *      Em terminal não-interativo sem `--mfa-token`, encerra com instrução
- *      clara — o servidor recusaria de qualquer forma (fail-closed).
+ *   2. `--mfa-token` explícito: manda `X-Neetru-MFA-Token` — e também a sessão
+ *      salva, se houver (o Core tenta a sessão antes e não gasta o TOTP à toa).
+ *      O código NUNCA é descartado em favor da sessão (A8).
+ *   3. Sessão de 1h salva localmente: usa `X-Neetru-MFA-Session` sem pedir
+ *      TOTP. Silencioso — o operador não precisa saber que a sessão está ativa.
+ *   4. Prompt interativo do TOTP. Em `--json`/não-interativo sem código nem
+ *      sessão, encerra com instrução clara — o servidor recusaria de qualquer
+ *      forma (fail-closed).
  *
- * feature mfa-session (2026-06-12): o item 2 elimina o re-prompt TOTP a cada
+ * feature mfa-session (2026-06-12): o item 3 elimina o re-prompt TOTP a cada
  * comando destrutivo quando o operador já rodou `neetru auth mfa-session`.
  */
 export async function resolveStepUp(opts) {
@@ -180,34 +292,35 @@ export async function resolveStepUp(opts) {
         headers['X-Neetru-Dry-Run'] = 'true';
         return { headers };
     }
-    // ── Prioridade 2: sessão de 1h salva localmente ─────────────────────────
-    // Verifica ANTES de pedir TOTP — se há sessão válida, usa sem interação.
-    const savedSession = opts.skipSession ? null : loadMfaSession();
-    if (savedSession) {
-        headers['X-Neetru-MFA-Session'] = savedSession;
-        return { headers };
-    }
-    // ── Prioridade 3: TOTP fresco (flag ou prompt) ─────────────────────────
-    let code = (opts.mfaToken ?? '').trim();
-    if (!code) {
-        // bug auditoria 2026-06-30: em --json o prompt interativo de TOTP NÃO pode
-        // rodar NEM com TTY — ele escreveria a pergunta no stdout (corrompe o JSON)
-        // e penduraria um consumidor programático. Fail-CLOSED em --json OU sem TTY;
-        // só promptar em terminal interativo humano (não-json + TTY).
-        if (opts.json || opts.nonInteractive || !process.stdin.isTTY) {
-            const msg = 'Operação destrutiva top-tier exige step-up MFA: passe --mfa-token <código TOTP> ' +
-                '(modo --json/não-interativo) ou rode `neetru auth mfa-session` para obter uma sessão de 1h.';
-            if (opts.json) {
-                console.log(JSON.stringify({ ok: false, error: 'mfa_required', message: msg }));
-            }
-            else {
-                log.error(msg);
-            }
-            safeExit(1);
-            return { headers }; // safeExit não retorna em prod; satisfaz o tipo + testes
-        }
-        code = await promptLine('Código MFA (TOTP) para confirmar:');
+    // ── Prioridades 2 e 3: código explícito, depois sessão de 1h ────────────
+    const ready = nonInteractiveStepUp(opts);
+    if (Object.keys(ready).length > 0)
+        return { headers: ready };
+    // ── Prioridade 4: prompt do TOTP ─────────────────────────────────────────
+    // bug auditoria 2026-06-30: em --json o prompt interativo de TOTP NÃO pode
+    // rodar NEM com TTY — ele escreveria a pergunta no stdout (corrompe o JSON)
+    // e penduraria um consumidor programático. Fail-CLOSED em --json OU sem TTY;
+    // só promptar em terminal interativo humano (não-json + TTY).
+    if (opts.json || opts.nonInteractive || !process.stdin.isTTY) {
+        // bug_89d2497e: o conselho só cita `--mfa-token` se o comando em execução
+        // declara a flag (mesmo defeito do bug_757b9746, do lado do step-up). O
+        // código de saída segue 1 e o JSON segue `{ ok, error:'mfa_required', message }`.
+        // P105: o comando alternativo (`neetru auth mfa-session`) também só é
+        // citado se existe na árvore do Commander.
+        const sessao = (withCommand, withoutCommand) => adviseCommand({ command: 'auth mfa-session', withCommand, withoutCommand });
+        const msg = adviseFlag({
+            flag: '--mfa-token',
+            withFlag: sessao('Operação destrutiva top-tier exige step-up MFA: passe --mfa-token <código TOTP> ' +
+                '(modo --json/não-interativo) ou rode `neetru auth mfa-session` para obter uma sessão de 1h.', 'Operação destrutiva top-tier exige step-up MFA: passe --mfa-token <código TOTP> ' +
+                '(modo --json/não-interativo).'),
+            withoutFlag: sessao('Operação destrutiva top-tier exige step-up MFA: rode `neetru auth mfa-session` ' +
+                'para obter uma sessão de 1h e repita o comando.', 'Operação destrutiva top-tier exige step-up MFA, e esta CLI não tem, neste comando, ' +
+                'como enviá-lo em modo --json/não-interativo.'),
+        });
+        exitWithCliError(new NeetruCliError(msg, { code: 'mfa_required', exit: EXIT_CODES.client }), opts.json);
+        return { headers }; // safeExit não retorna em prod; satisfaz o tipo + testes
     }
+    const code = await promptLine('Código MFA (TOTP) para confirmar:');
     if (!code) {
         log.error('Código MFA não fornecido — operação cancelada.');
         safeExit(1);
@@ -237,13 +350,9 @@ export function isMfaRequiredError(error) {
 export async function withStepUpRetry(opts, doRequest, onError, 
 /** Chamado antes do prompt TOTP do retry (ex.: parar o spinner). */
 beforePrompt) {
-    const first = {};
-    const code = (opts.mfaToken ?? '').trim();
-    const savedSession = code ? null : loadMfaSession();
-    if (code)
-        first['X-Neetru-MFA-Token'] = code;
-    else if (savedSession)
-        first['X-Neetru-MFA-Session'] = savedSession;
+    // Mesma precedência do `resolveStepUp` (A8): código explícito, depois sessão.
+    const first = nonInteractiveStepUp(opts);
+    const code = first['X-Neetru-MFA-Token'];
     let firstError;
     try {
         return await doRequest(first);

package/dist/lib/config-schema.d.ts

@@ -114,6 +114,10 @@ export declare const neetruConfigSchema: z.ZodObject<{
     slug: string;
     runtime: "nextjs" | "node-api";
     $schema?: string | undefined;
+    deploy?: z.objectOutputType<{
+        region: z.ZodOptional<z.ZodString>;
+        serviceName: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
     tenantId?: string | undefined;
     docs?: z.objectOutputType<{
         protocolVersion: z.ZodOptional<z.ZodNumber>;
@@ -131,10 +135,6 @@ export declare const neetruConfigSchema: z.ZodObject<{
         ctaHref?: string | undefined;
         ctaLabel?: string | undefined;
     } | undefined;
-    deploy?: z.objectOutputType<{
-        region: z.ZodOptional<z.ZodString>;
-        serviceName: z.ZodOptional<z.ZodString>;
-    }, z.ZodTypeAny, "passthrough"> | undefined;
     database?: {
         engine?: "firestore-instance" | "vm-postgres-single" | "vm-mysql-single" | "nosql-vm" | undefined;
         dbId?: string | undefined;
@@ -144,6 +144,10 @@ export declare const neetruConfigSchema: z.ZodObject<{
     slug: string;
     runtime: "nextjs" | "node-api";
     $schema?: string | undefined;
+    deploy?: z.objectInputType<{
+        region: z.ZodOptional<z.ZodString>;
+        serviceName: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
     tenantId?: string | undefined;
     docs?: z.objectInputType<{
         protocolVersion: z.ZodOptional<z.ZodNumber>;
@@ -161,10 +165,6 @@ export declare const neetruConfigSchema: z.ZodObject<{
         ctaHref?: string | undefined;
         ctaLabel?: string | undefined;
     } | undefined;
-    deploy?: z.objectInputType<{
-        region: z.ZodOptional<z.ZodString>;
-        serviceName: z.ZodOptional<z.ZodString>;
-    }, z.ZodTypeAny, "passthrough"> | undefined;
     database?: {
         engine?: "firestore-instance" | "vm-postgres-single" | "vm-mysql-single" | "nosql-vm" | undefined;
         dbId?: string | undefined;

package/dist/lib/db-local/db-json.d.ts

@@ -1,4 +1,4 @@
-import type { NeetruEnv } from './env.js';
+import { type NeetruEnv } from './env.js';
 /** Mapa de IDs de banco por ambiente canônico. */
 export type DbJsonIds = Partial<Record<NeetruEnv, string>>;
 /** Uma entrada de banco lógico no registry. */

package/dist/lib/db-local/db-json.js

@@ -11,6 +11,8 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { randomBytes } from 'node:crypto';
+import { avisarSobraDeTemporario, removerArquivo } from '../fs-seguro.js';
+import { NEETRU_ENVS } from './env.js';
 /** Registry v2 vazio — usado quando o arquivo ainda não existe. */
 function emptyDbJson() {
     return { version: 2, databases: [] };
@@ -18,7 +20,8 @@ function emptyDbJson() {
 // ---------------------------------------------------------------------------
 // migrateDbJson — qualquer entrada → v2 canônico
 // ---------------------------------------------------------------------------
-const VALID_ENV_KEYS = ['dev-local', 'staging', 'production'];
+// P105: as chaves de `ids` são o alfabeto de banco — a mesma lista que valida.
+const VALID_ENV_KEYS = NEETRU_ENVS;
 function isPlainObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -144,12 +147,17 @@ export function writeDbJson(filePath, data) {
         fs.renameSync(tmpPath, filePath);
     }
     catch (err) {
-        // Best-effort: remove o temp pra não deixar lixo se algo falhou.
+        // Best-effort: remove o temp pra não deixar lixo se algo falhou. Não usa
+        // `fs.rmSync`: com acento no caminho (`C:\Users\João\...`), no Node 24 do
+        // Windows ele volta sem erro e não apaga (ver `lib/fs-seguro.ts`).
+        // `removerArquivo` apaga e confere; se ainda assim falhar, o erro que
+        // importa é o original, que segue abaixo — e a sobra vira aviso no stderr
+        // com o caminho, em vez de sumir calada (revisão do #79).
         try {
-            fs.rmSync(tmpPath, { force: true });
+            removerArquivo(tmpPath);
         }
-        catch {
-            /* ignora — limpeza best-effort */
+        catch (limpeza) {
+            avisarSobraDeTemporario(tmpPath, limpeza);
         }
         throw err;
     }

package/dist/lib/db-local/env.d.ts

@@ -23,8 +23,20 @@
  * Ref: glossário 0.1.4 exporta normalizeEnvId() que usa 'prod' — use-o para
  * queries inter-sistema quando disponível.
  */
-/** Os 3 ambientes canônicos persistidos no `.neetru/db.json`. */
-export type NeetruEnv = 'dev-local' | 'staging' | 'production';
+import type { NeetruCliError } from '../../cli-kit/errors.js';
+/**
+ * Os 3 ambientes canônicos persistidos no `.neetru/db.json`. Fonte única: a
+ * validação e a lista de "valores válidos" das mensagens saem daqui
+ * (bug_89d2497e — antes a lista era copiada à mão em 5 mensagens).
+ */
+export declare const NEETRU_ENVS: readonly ["dev-local", "staging", "production"];
+export type NeetruEnv = (typeof NEETRU_ENVS)[number];
+/**
+ * Erro de `--env` inválido nos comandos de banco (bug_89d2497e): os valores
+ * válidos saem de `NEETRU_ENVS` e os apelidos de `ENV_ALIASES` — as mesmas
+ * fontes que validam. Sai como erro do cliente (exit 1), código `invalid_env`.
+ */
+export declare function erroAmbienteBancoInvalido(input: unknown): NeetruCliError;
 /**
  * Normaliza um nome de ambiente para um dos 3 valores canônicos.
  *
@@ -32,6 +44,6 @@ export type NeetruEnv = 'dev-local' | 'staging' | 'production';
  * no stderr listando o valor canônico. Nunca normaliza silenciosamente.
  *
  * Faz lowercase + trim antes do lookup. Entrada não-string, vazia ou
- * desconhecida lança um `Error` que lista os valores aceitos.
+ * desconhecida lança o `NeetruCliError` de `erroAmbienteBancoInvalido`.
  */
 export declare function normalizeEnv(input: string): NeetruEnv;

package/dist/lib/db-local/env.js

@@ -23,6 +23,13 @@
  * Ref: glossário 0.1.4 exporta normalizeEnvId() que usa 'prod' — use-o para
  * queries inter-sistema quando disponível.
  */
+import { invalidChoiceError } from '../../cli-kit/choices.js';
+/**
+ * Os 3 ambientes canônicos persistidos no `.neetru/db.json`. Fonte única: a
+ * validação e a lista de "valores válidos" das mensagens saem daqui
+ * (bug_89d2497e — antes a lista era copiada à mão em 5 mensagens).
+ */
+export const NEETRU_ENVS = ['dev-local', 'staging', 'production'];
 /** Mapa de aliases aceitos → valor canônico. */
 const ENV_ALIASES = {
     dev: 'dev-local',
@@ -43,6 +50,31 @@ const ALIAS_NOTICE = {
     stg: 'staging',
     prod: 'production',
 };
+/** `dev/local → dev-local, stg → staging, prod → production` — de `ENV_ALIASES`. */
+function apelidosLegiveis() {
+    const porDestino = new Map();
+    for (const [apelido, destino] of Object.entries(ENV_ALIASES)) {
+        if (apelido === destino)
+            continue;
+        porDestino.set(destino, [...(porDestino.get(destino) ?? []), apelido]);
+    }
+    return [...porDestino].map(([destino, apelidos]) => `${apelidos.join('/')} → ${destino}`).join(', ');
+}
+/**
+ * Erro de `--env` inválido nos comandos de banco (bug_89d2497e): os valores
+ * válidos saem de `NEETRU_ENVS` e os apelidos de `ENV_ALIASES` — as mesmas
+ * fontes que validam. Sai como erro do cliente (exit 1), código `invalid_env`.
+ */
+export function erroAmbienteBancoInvalido(input) {
+    return invalidChoiceError({
+        flag: '--env',
+        value: typeof input === 'string' ? input : `(${typeof input})`,
+        valid: NEETRU_ENVS,
+        subject: 'Ambiente',
+        code: 'invalid_env',
+        hint: `Apelidos aceitos: ${apelidosLegiveis()}.`,
+    });
+}
 /**
  * Normaliza um nome de ambiente para um dos 3 valores canônicos.
  *
@@ -50,20 +82,15 @@ const ALIAS_NOTICE = {
  * no stderr listando o valor canônico. Nunca normaliza silenciosamente.
  *
  * Faz lowercase + trim antes do lookup. Entrada não-string, vazia ou
- * desconhecida lança um `Error` que lista os valores aceitos.
+ * desconhecida lança o `NeetruCliError` de `erroAmbienteBancoInvalido`.
  */
 export function normalizeEnv(input) {
-    if (typeof input !== 'string') {
-        throw new Error(`normalizeEnv: ambiente inválido (esperava string, recebeu ${typeof input}). ` +
-            `Valores aceitos: dev-local, staging, production.`);
-    }
+    if (typeof input !== 'string')
+        throw erroAmbienteBancoInvalido(input);
     const key = input.trim().toLowerCase();
     const canonical = ENV_ALIASES[key];
-    if (!canonical) {
-        throw new Error(`normalizeEnv: ambiente "${input}" não reconhecido. ` +
-            `Valores aceitos: dev-local, staging, production. ` +
-            `Aliases aceitos: dev/local → dev-local, stg → staging, prod → production.`);
-    }
+    if (!canonical)
+        throw erroAmbienteBancoInvalido(input);
     // D-4: aviso explícito quando alias não-canônico é usado
     const notice = ALIAS_NOTICE[key];
     if (notice) {

package/dist/lib/db-pipeline/build-deps.d.ts

@@ -1,6 +1,10 @@
 import { type RehearseEngine } from './rehearse.js';
 import type { PipelineDeps } from './types.js';
-export declare function generateSql(schemaPath: string, engine?: RehearseEngine): Promise<string>;
+export interface OpcoesGenerateSql {
+    /** Remove o `--out` temporário. Injetável só para teste. */
+    remover?: (dir: string) => Promise<void>;
+}
+export declare function generateSql(schemaPath: string, engine?: RehearseEngine, { remover }?: OpcoesGenerateSql): Promise<string>;
 /**
  * Constrói o conjunto de `PipelineDeps` de PRODUÇÃO.
  *

package/dist/lib/db-pipeline/build-deps.js

@@ -25,6 +25,7 @@ import * as path from 'node:path';
 import { spawn } from 'node:child_process';
 import { classifyMigration } from '@neetru/db-classifier';
 import { apiRequest } from '../api-client.js';
+import { avisarSobraDeTemporario, removerDiretorio } from '../fs-seguro.js';
 import { buildRehearseInContainer, buildDockerExecFn, } from './rehearse.js';
 /**
  * Prova em COMPILE-TIME que `classifyMigration` do `@neetru/db-classifier` é
@@ -273,7 +274,7 @@ function makeTableAndIndexIdempotent(sql) {
         .replace(/CREATE TABLE (?!IF NOT EXISTS\b)/g, 'CREATE TABLE IF NOT EXISTS ')
         .replace(/CREATE (UNIQUE )?INDEX (?!IF NOT EXISTS\b)/g, (_match, unique) => `CREATE ${unique ?? ''}INDEX IF NOT EXISTS `);
 }
-export function generateSql(schemaPath, engine = 'postgres') {
+export function generateSql(schemaPath, engine = 'postgres', { remover = removerDiretorio } = {}) {
     const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'neetru-drizzle-'));
     return new Promise((resolve, reject) => {
         const child = spawn('npx', [
@@ -333,8 +334,27 @@ export function generateSql(schemaPath, engine = 'postgres') {
                 reject(new Error(`falha lendo o .sql gerado em ${tmpDir}: ${err.message}`));
             }
         });
-    }).finally(() => {
-        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }).then(
+    // Limpa o --out temporário. Não usa `fs.rmSync`: o `os.tmpdir()` de quem tem
+    // acento na home (`C:\Users\João\AppData\Local\Temp`) faz o rmSync do
+    // Node 24 no Windows voltar sem erro e não apagar nada — um `neetru-drizzle-*`
+    // perdido por geração. `removerDiretorio` apaga e confere (ver `lib/fs-seguro.ts`).
+    //
+    // A falha da limpeza nunca derruba o resultado nem esconde o erro da
+    // geração, mas também não some calada: vira aviso no stderr com o caminho
+    // que sobrou (revisão do #79).
+    async (sql) => {
+        try {
+            await remover(tmpDir);
+        }
+        catch (limpeza) {
+            avisarSobraDeTemporario(tmpDir, limpeza);
+        }
+        return sql;
+    }, async (err) => {
+        // O erro da geração é o que importa: falha na limpeza não pode escondê-lo.
+        await remover(tmpDir).catch((limpeza) => avisarSobraDeTemporario(tmpDir, limpeza));
+        throw err;
     });
 }
 /**

package/dist/lib/db-pipeline/types.d.ts

@@ -16,12 +16,16 @@
  * Postgres e sem rede. A fiação real (drizzle-kit / container / HTTP) vive
  * no `buildPipelineDeps()`.
  */
+import type { NeetruEnv } from '../db-local/env.js';
 /** As 5 fases do pipeline, na ordem de execução. */
 export type PipelinePhase = 'fingerprint' | 'generate' | 'rehearse' | 'classify' | 'push';
 /** Severidade global da migração — espelha o `@neetru/db-classifier`. */
 export type MigrationSeverity = 'aditiva' | 'destrutiva';
-/** Os 3 ambientes canônicos do `neetru db apply`. */
-export type ApplyEnv = 'dev-local' | 'staging' | 'production';
+/**
+ * Os 3 ambientes canônicos do `neetru db apply` — o alfabeto de BANCO
+ * (`NEETRU_ENVS`, `db-local/env.ts`). P105: era a união escrita à mão.
+ */
+export type ApplyEnv = NeetruEnv;
 /**
  * Relatório de classificação — subconjunto estrutural do `ClassificationReport`
  * do `@neetru/db-classifier`. Tipado localmente pra que o orquestrador e seus

package/dist/lib/db-pipeline/types.js

@@ -1,20 +1,2 @@
-/**
- * `@neetru/db-pipeline` — contratos do orquestrador do `neetru db apply`.
- *
- * O pipeline roda CLIENT-SIDE as fases 1-5 do `neetru db apply`:
- *  1. `fingerprint` — hash determinístico do schema.
- *  2. `generate`    — `drizzle-kit generate` produz o `.sql`.
- *  3. `rehearse`    — ensaia o `.sql` num Postgres efêmero real.
- *  4. `classify`    — `@neetru/db-classifier` marca aditiva/destrutiva.
- *  5. `push`        — adquire lock + envia o artefato validado pro Core.
- *
- * O pipeline NÃO decide política — ele produz um `.sql` validado e
- * classificado e o envia. A decisão de aplicar (ou exigir confirmação numa
- * migração destrutiva) é do Core.
- *
- * Tudo aqui é deps-injetado: o orquestrador é unit-testável sem Docker, sem
- * Postgres e sem rede. A fiação real (drizzle-kit / container / HTTP) vive
- * no `buildPipelineDeps()`.
- */
 export {};
 //# sourceMappingURL=types.js.map