@neetru/cli 2.29.0 → 2.32.0

package/dist/commands/deploy.js

@@ -27,14 +27,21 @@ import ora from 'ora';
 import { log } from '../utils/logger.js';
 import { apiRequest, CliNetworkError } from '../lib/api-client.js';
 import { handleApiError } from '../lib/api-error.js';
+import { exitWithCliError } from '../lib/cli-error.js';
+import { invalidChoiceError } from '../cli-kit/choices.js';
+import { DEPLOY_ENVIRONMENT_IDS, deployEnvParaRuntime, } from '../lib/envs.js';
 import { resolveStepUp } from '../lib/cli-write.js';
 import { runBuild } from './build.js';
 import { formatDeployConsole, isDeployUnverified, deployStatusLabel } from './deployments.js';
 import { readDbJson, schemaFingerprint } from '../lib/db-local/index.js';
 // bug_863ae5: pre-flight IAM check.
 import { assertIamReady } from '../lib/iam-preflight.js';
+import { ALLOW_PUBLIC_SECRET_FLAG, MIN_OVERRIDE_REASON_LENGTH, buildOverrideRecord, collectPublicEnvSecrets, formatFindingsMessage, scanDirectoryForPublicSecrets, scanTarballForPublicSecrets, } from '../lib/public-secret-scan.js';
 import { getActiveTokenSync } from '../lib/token-resolver.js';
+import { BYTES_FAREJADOS, checkDeployTargetContract, farejarConteudoDePacote, mensagemSourceAcimaDoTeto, mensagemSourceNaoEhHandler, pareceArquivoDePacote, WORKSPACE_SOURCE_MAX_BYTES, } from '../lib/deploy-target-contract.js';
 import { safeExit } from '../utils/safe-exit.js';
+import { AVISO_AGENTE_PENDENTE, CHAVES_DO_CARREGADOR, CHAVE_SEGREDO_RE, chaveInjetadaPeloCore, comandoParaRegistrarSegredo, problemaNaChaveReservada, } from '../lib/segredo-produto.js';
+import { avisoEnvDoBundlerForaDeUtf8, CodificacaoInvalida, decodificarUtf8, semBomInicial, } from '../lib/texto-utf8.js';
 /**
  * bug_a5786e03 (2026-05-31): o Core/agente só conhecem os stacks canônicos
  * `node|docker|php-apache|static` (PRODUCT_STACKS). `nextjs` é um alias de
@@ -86,6 +93,113 @@ export function resolveDeployVersion(manifestVersion, explicitVersion, json) {
     }
     return version;
 }
+/**
+ * Valida o motivo do `--allow-public-secret` ANTES de qualquer build/upload.
+ * `undefined` = flag não passada.
+ */
+export function validateAllowPublicSecretReason(raw, json) {
+    if (raw === undefined)
+        return undefined;
+    const reason = String(raw).trim();
+    if (reason.length < MIN_OVERRIDE_REASON_LENGTH) {
+        deployFail(json, 'invalid_override_reason', `${ALLOW_PUBLIC_SECRET_FLAG} exige um motivo de verdade (mínimo ${MIN_OVERRIDE_REASON_LENGTH} caracteres) — ` +
+            'ele fica registrado no deploy. Ex.: --allow-public-secret "rotação da chave em andamento, ticket #123".');
+    }
+    return reason;
+}
+/**
+ * 2.30.0 — gate de segredo no pacote PÚBLICO (decisão do dono 2026-10-03: a
+ * credencial nrt_ é SÓ DE SERVIDOR). Roda ANTES do upload. Achou → falha
+ * FECHADO (exit 1, `public_secret_in_bundle`), a não ser que haja override com
+ * motivo — aí segue com aviso alto e devolve o registro pro corpo do deploy.
+ */
+export async function runPublicSecretGate(source, ctx) {
+    const lg = scopedLog(ctx.json);
+    // Rodada final 2 do cli#81: `.env*` fora de UTF-8 limpo não para a varredura
+    // (ela confere o valor como o bundler o lê), mas não passa calado. Em --json
+    // o aviso vai ao stderr: o stdout segue com a linha JSON única.
+    const envSecrets = await collectPublicEnvSecrets(ctx.cwd, ctx.envFile, process.env, (arquivo, problema) => {
+        const aviso = avisoEnvDoBundlerForaDeUtf8(arquivo, problema);
+        if (ctx.json)
+            console.error(aviso);
+        else
+            lg.warn(aviso);
+    });
+    let result;
+    try {
+        result =
+            source.kind === 'tar'
+                ? await scanTarballForPublicSecrets(source.path, { stack: ctx.stack, envSecrets })
+                : await scanDirectoryForPublicSecrets(source.root, { stack: ctx.stack, envSecrets });
+    }
+    catch (err) {
+        // Não conseguir LER o pacote é falha fechada também (não dá pra afirmar que está limpo).
+        deployFail(ctx.json, 'public_secret_scan_failed', `Não consegui varrer o pacote em busca de segredos: ${err.message}`);
+    }
+    if (result.skippedLarge.length > 0) {
+        lg.warn(`Varredura de segredo: ${result.skippedLarge.length} arquivo(s) público(s) grande(s) demais não foram varridos ` +
+            `(ex.: ${result.skippedLarge[0]}).`);
+    }
+    if (result.findings.length === 0) {
+        lg.dim(`  Varredura de segredo no pacote público: ok (${result.scannedFiles} arquivo(s)).`);
+        return { scanned: true, scannedFiles: result.scannedFiles };
+    }
+    if (!ctx.allowReason) {
+        deployFail(ctx.json, 'public_secret_in_bundle', formatFindingsMessage(result.findings));
+    }
+    const override = buildOverrideRecord(ctx.allowReason, result.findings);
+    lg.warn(formatFindingsMessage(result.findings).split('\n')[0].replace('Deploy BLOQUEADO.', 'Deploy LIBERADO por override.'));
+    lg.warn(`OVERRIDE ${ALLOW_PUBLIC_SECRET_FLAG} — motivo registrado no deploy: "${ctx.allowReason}". ` +
+        'Trate a chave exposta como VAZADA: rotacione-a assim que possível.');
+    return { scanned: true, scannedFiles: result.scannedFiles, override };
+}
+/**
+ * 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 function entrypointParaDeploy(manifest) {
+    if (!manifest)
+        return undefined;
+    if (manifest.stack !== 'node')
+        return undefined;
+    if (!manifest.appPrefix)
+        return undefined;
+    return manifest.entrypoint ?? undefined;
+}
 /** `true` pra `prod`/`production` (o Core normaliza `production`→`prod`). */
 export function isProdEnv(envName) {
     const e = (envName ?? '').trim().toLowerCase();
@@ -94,7 +208,7 @@ export function isProdEnv(envName) {
 /**
  * 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.
  */
@@ -108,26 +222,74 @@ export async function resolveDeployStepUpHeaders(opts, envName, nonInteractive)
     });
     return headers;
 }
+/**
+ * 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 function mostrarAvisosDoCore(warnings, json) {
+    if (!Array.isArray(warnings))
+        return;
+    const linhas = warnings.filter((w) => typeof w === 'string' && w.trim() !== '');
+    if (linhas.length === 0)
+        return;
+    if (json) {
+        for (const w of linhas)
+            process.stderr.write(`[aviso do Core] ${w}\n`);
+        return;
+    }
+    for (const w of linhas)
+        log.warn(`  aviso do Core: ${w}`);
+}
 const TERMINAL_STATUSES = new Set(['success', 'failed', 'cancelled']);
-/** Estágios de ambiente válidos para o deploy workspace. */
-const WORKSPACE_ENVS = new Set(['dev', 'staging', 'prod']);
+/**
+ * Estágios de ambiente válidos para o deploy workspace/cloud-run. P105: era
+ * `new Set(['dev','staging','prod'])` escrito à mão; agora sai da tabela
+ * `VOCABULARIOS_DE_AMBIENTE` (`lib/envs.ts`), derivada de
+ * `TENANT_ENVIRONMENT_IDS`.
+ */
+const WORKSPACE_ENVS = new Set(DEPLOY_ENVIRONMENT_IDS);
+/**
+ * `--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 function validarAmbienteDoDeploy(envName, json) {
+    if (WORKSPACE_ENVS.has(envName))
+        return;
+    exitWithCliError(invalidChoiceError({
+        flag: '--env',
+        value: envName,
+        valid: DEPLOY_ENVIRONMENT_IDS,
+        subject: 'Ambiente',
+        code: 'invalid_env',
+    }), json);
+}
 /**
  * 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 function deployEnvToBuildTargetEnv(envName) {
-    if (envName === 'dev')
-        return 'dev';
-    if (envName === 'staging')
-        return 'workspace';
-    return 'prod';
+    return deployEnvParaRuntime(envName) ?? 'prod';
 }
 /** Candidatos default de arquivo de source para um deploy workspace. */
 const WORKSPACE_SOURCE_CANDIDATES = [
@@ -168,6 +330,16 @@ async function loadLocalConfig(cwd) {
     }
     return null;
 }
+/**
+ * `runtime` do neetru.config.json do diretório atual, só quando o config é
+ * DESTE produto. `--product outro` com o config do diretório atual: o `runtime`
+ * lido é de OUTRO produto e não diz nada sobre este deploy (revisão do PR #74).
+ * Sem `--product`, ou config sem `slug`, conta como deste produto.
+ */
+function runtimeDoConfigDesteProduto(cfg, product) {
+    const configEhDesteProduto = !product || !cfg?.slug || cfg.slug === product;
+    return configEhDesteProduto ? cfg?.runtime : undefined;
+}
 /**
  * Nomes de variáveis que NUNCA devem ser injetados no deploy —
  * podem alterar o comportamento do runtime de formas perigosas.
@@ -241,10 +413,82 @@ const SDK_CRED_ENV_KEYS = new Set([
     'NEETRU_API_KEY',
     'NEETRU_CLIENT_ID',
 ]);
-async function loadEnvFile(envFile, target = 'cloud-run', json) {
+/**
+ * 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 function avisoSegredoDescartadoNaVm(chave, env) {
+    const inicio = `Variável com aparência de segredo ignorada (${chave}): `;
+    if (CHAVES_DO_CARREGADOR.includes(chave)) {
+        return inicio + 'ela muda como o processo carrega código e não pode vir de um segredo do produto.';
+    }
+    if (chaveInjetadaPeloCore(chave)) {
+        return (inicio +
+            'o Core já a entrega ao app na VM por outro canal (credencial SDK, OIDC ou CLI, módulo ' +
+            'ativo, ambiente ou unit do app). Não precisa passá-la no --env-file nem registrá-la como ' +
+            'segredo do produto.');
+    }
+    if (!CHAVE_SEGREDO_RE.test(chave)) {
+        return (inicio +
+            'segredo não vai no deploy por variável de ambiente (ficaria gravado no Firestore, que ' +
+            'toda a equipe lê), e o registro de segredos do produto só aceita nome em CAIXA_ALTA ' +
+            '(letras, dígitos e underscore, começando por letra, de 2 a 64 caracteres). Renomeie a ' +
+            `variável no app e registre-a com \`${comandoParaRegistrarSegredo('<NOME>', env)}\`.`);
+    }
+    return (inicio +
+        'segredo não vai no deploy por variável de ambiente (ficaria gravado no Firestore, que toda ' +
+        `a equipe lê). Registre-o com \`${comandoParaRegistrarSegredo(chave, env)}\` — o valor vai ` +
+        'direto para o Secret Manager; use --generate quando o Core puder sortear o valor.');
+}
+/**
+ * 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 function segredoDescartadoApontaSecretsSet(chave) {
+    return problemaNaChaveReservada(chave) === null;
+}
+/**
+ * Lê o `--env-file` do deploy e devolve o texto. Revisão do cli#81 (N-r3-1):
+ * `readFile(…, 'utf8')` trocava cada byte que não é UTF-8 por U+FFFD sem aviso
+ * — um .env ANSI com `NOME_LOJA=Café` ia ao deploy como `Caf\uFFFD`. Agora o
+ * arquivo é lido em bytes e recusado com `invalid_encoding`, pela mesma regra
+ * do `neetru secrets set --from-file`. `runDeploy` chama esta função antes do
+ * catálogo, de qualquer pergunta e de qualquer chamada de rede (rodada final 3).
+ */
+async function lerEnvFileDoDeploy(envFile, json) {
+    const bruto = await fsp.readFile(envFile);
+    try {
+        return semBomInicial(decodificarUtf8(bruto, 'env-file'));
+    }
+    catch (err) {
+        if (err instanceof CodificacaoInvalida)
+            deployFail(json, 'invalid_encoding', err.message);
+        throw err;
+    }
+}
+/**
+ * Monta as variáveis do `--env-file` que `lerEnvFileDoDeploy` já leu. Fica
+ * para depois do `pickTarget` porque os avisos dependem do alvo.
+ */
+function envVarsDoEnvFile(content, target = 'cloud-run', json, 
+/** `--env` do deploy (só para o aviso de segredo descartado na VM). */
+env) {
     const lg = scopedLog(json);
-    const content = await fsp.readFile(envFile, 'utf8');
     const out = {};
+    let descartouSegredoNaVm = false;
     if (target === 'vm') {
         // (3) Lembrete único: a credencial SDK não precisa ir no --env-file.
         lg.info('A credencial SDK é injetada automaticamente na VM pelo Core/agente — ' +
@@ -290,13 +534,23 @@ async function loadEnvFile(envFile, target = 'cloud-run', json) {
         }
         // (1) Segredos são dropados aqui (o Core rejeitaria com HTTP 400).
         if (isSecretEnvVarKey(k)) {
-            lg.warn(`Variável com aparência de segredo ignorada (${k}): segredos não podem ` +
-                'ir no deploy via env (vazariam no Firestore, legível por todo o staff). ' +
-                'Use o Secret Manager e referencie por nome na VM.');
+            if (target === 'vm') {
+                if (segredoDescartadoApontaSecretsSet(k))
+                    descartouSegredoNaVm = true;
+                lg.warn(avisoSegredoDescartadoNaVm(k, env));
+            }
+            else {
+                lg.warn(`Variável com aparência de segredo ignorada (${k}): segredos não podem ` +
+                    'ir no deploy via env (vazariam no Firestore, legível por todo o staff). ' +
+                    'Use o Secret Manager e referencie por nome na VM.');
+            }
             continue;
         }
         out[k] = v;
     }
+    // Uma vez só, depois da lista: o registro ainda não chega ao app na VM.
+    if (descartouSegredoNaVm)
+        lg.warn(AVISO_AGENTE_PENDENTE);
     return out;
 }
 // handleApiError unificado em ../lib/api-error.js (auditoria qualidade 2026-06-20).
@@ -335,7 +589,7 @@ async function pickProduct(opts, nonInteractive, cwd) {
     ]);
     return slug;
 }
-async function pickTarget(opts, nonInteractive) {
+export async function pickTarget(opts, nonInteractive, runtime) {
     if (opts.target)
         return opts.target;
     // Não-interativo (CI/scripts) mantém `vm` como default — mudar pra workspace
@@ -343,17 +597,27 @@ async function pickTarget(opts, nonInteractive) {
     // interativo o menu já oferece workspace como recomendado/primeiro.
     if (nonInteractive)
         return 'vm';
+    // Produto `runtime: nextjs` (o padrão do `neetru init`): o workspace roda UM
+    // handler .ts, não um app Next.js. Recomendar "Workspace" aqui levava quem
+    // aceita o padrão direto ao aviso do contrato (confirmação final do PR #74).
+    const ehNext = runtime === 'nextjs';
     const { target } = await inquirer.prompt([
         {
             type: 'list',
             name: 'target',
             message: 'Onde deployar?',
-            default: 'workspace',
-            choices: [
-                { name: 'Workspace — runtime compartilhado, mais barato (recomendado)', value: 'workspace' },
-                { name: 'Cloud Run — serviço dedicado, escala a zero', value: 'cloud-run' },
-                { name: 'VM existente — custo fixo, sem cold start', value: 'vm' },
-            ],
+            default: ehNext ? 'vm' : 'workspace',
+            choices: ehNext
+                ? [
+                    { name: 'VM existente — serve o app Next.js (recomendado)', value: 'vm' },
+                    { name: 'Cloud Run — serviço dedicado, escala a zero (imagem)', value: 'cloud-run' },
+                    { name: 'Workspace — só UM handler .ts, não o app Next.js', value: 'workspace' },
+                ]
+                : [
+                    { name: 'Workspace — runtime compartilhado, mais barato (recomendado)', value: 'workspace' },
+                    { name: 'Cloud Run — serviço dedicado, escala a zero', value: 'cloud-run' },
+                    { name: 'VM existente — custo fixo, sem cold start', value: 'vm' },
+                ],
         },
     ]);
     return target;
@@ -566,7 +830,15 @@ async function uploadArtifactToGcs(tarballAbs, productSlug, envName, sizeBytes,
 async function resolveArtifact(opts, productSlug, envName, cwd) {
     // Caso 1: caller já fez upload e passou URL+sha pronta.
     if (opts.artifactUrl && opts.artifactSha256) {
-        return { artifactUrl: opts.artifactUrl, artifactSha256: opts.artifactSha256 };
+        // 2.30.0: artefato remoto não passa pelo CLI — não dá pra varrer. Avisa (o
+        // gate vale pro fluxo padrão build→upload e pro --artifact local).
+        scopedLog(opts.json).warn('Varredura de segredo NÃO feita: --artifact-url aponta um pacote remoto. ' +
+            'Prefira `neetru deploy` com build local ou --artifact <arquivo> (que são varridos).');
+        return {
+            artifactUrl: opts.artifactUrl,
+            artifactSha256: opts.artifactSha256,
+            publicSecretScan: { scanned: false, reason: 'remote_artifact' },
+        };
     }
     // Decide se vamos fazer upload pra GCS ou manter file://.
     const keepLocal = shouldKeepLocalArtifact(opts);
@@ -584,12 +856,15 @@ async function resolveArtifact(opts, productSlug, envName, cwd) {
             hash.update(chunk);
         const stat = await fsp.stat(abs);
         const sha256 = hash.digest('hex');
+        // 2.30.0: varredura de segredo ANTES de qualquer envio.
+        const publicSecretScan = await runPublicSecretGate({ kind: 'tar', path: abs }, { cwd, envFile: opts.envFile, stack: opts.stack, allowReason: opts.allowPublicSecret, json: opts.json });
         if (keepLocal) {
             lg.warn('Modo --local-artifact: mandando file:// pro Core. Só funciona se o agent compartilha FS com este CLI.');
             return {
                 artifactUrl: `file://${abs.replace(/\\/g, '/')}`,
                 artifactSha256: sha256,
                 artifactSizeBytes: stat.size,
+                publicSecretScan,
             };
         }
         const uploaded = await uploadArtifactToGcs(abs, productSlug, envName, stat.size, opts.json);
@@ -598,6 +873,7 @@ async function resolveArtifact(opts, productSlug, envName, cwd) {
             artifactSha256: sha256,
             artifactSizeBytes: stat.size,
             deployId: uploaded.deployId,
+            publicSecretScan,
         };
     }
     // Caso 3: procura manifest existente, senão chama runBuild.
@@ -638,6 +914,14 @@ async function resolveArtifact(opts, productSlug, envName, cwd) {
         });
     }
     const tarAbs = path.resolve(cwd, manifest.tarball);
+    // 2.30.0: varredura de segredo no pacote que VAI ser enviado, antes do upload.
+    const publicSecretScan = await runPublicSecretGate({ kind: 'tar', path: tarAbs }, {
+        cwd,
+        envFile: opts.envFile,
+        stack: manifest.stack ?? opts.stack,
+        allowReason: opts.allowPublicSecret,
+        json: opts.json,
+    });
     if (keepLocal) {
         lg.warn('Modo --local-artifact: mandando file:// pro Core. Só funciona se o agent compartilha FS com este CLI.');
         return {
@@ -645,6 +929,7 @@ async function resolveArtifact(opts, productSlug, envName, cwd) {
             artifactSha256: manifest.sha256,
             artifactSizeBytes: manifest.sizeBytes,
             manifest,
+            publicSecretScan,
         };
     }
     const uploaded = await uploadArtifactToGcs(tarAbs, productSlug, envName, manifest.sizeBytes, opts.json);
@@ -654,6 +939,7 @@ async function resolveArtifact(opts, productSlug, envName, cwd) {
         artifactSizeBytes: manifest.sizeBytes,
         manifest,
         deployId: uploaded.deployId,
+        publicSecretScan,
     };
 }
 async function pollDeploymentStatus(deploymentId, json) {
@@ -888,16 +1174,32 @@ async function probeDeployedHealth(domain) {
  * Resolve o arquivo de source `.ts` de um deploy workspace. Ordem de busca:
  * `--artifact <arquivo>` → campo `source` do neetru.config.json → candidatos
  * default (`handler.ts`, `src/handler.ts`, `index.ts`, `src/index.ts`).
+ *
+ * Devolve também os primeiros BYTES CRUS (`inicio`) e de onde o arquivo veio
+ * (`origem`): o farejador de pacote precisa dos bytes antes da decodificação
+ * UTF-8 (depois dela o gzip já virou U+FFFD) e a mensagem de recusa precisa
+ * dizer qual porta apontou o arquivo.
  */
 async function resolveWorkspaceSource(opts, cwd) {
-    const cfg = (await loadLocalConfig(cwd));
-    const candidates = [opts.artifact, cfg?.source, ...WORKSPACE_SOURCE_CANDIDATES].filter((c) => typeof c === 'string' && c.length > 0);
-    for (const c of candidates) {
-        const abs = path.resolve(cwd, c);
+    const cfg = await loadLocalConfig(cwd);
+    const candidates = [
+        { caminho: opts.artifact, origem: 'artifact' },
+        { caminho: cfg?.source, origem: 'config' },
+        ...WORKSPACE_SOURCE_CANDIDATES.map((c) => ({ caminho: c, origem: 'padrao' })),
+    ];
+    for (const { caminho, origem } of candidates) {
+        if (typeof caminho !== 'string' || caminho.length === 0)
+            continue;
+        const abs = path.resolve(cwd, caminho);
         if (fileExists(abs)) {
+            // Uma leitura só: `toString('utf8')` é exatamente o que
+            // `readFile(abs, 'utf8')` fazia.
+            const bruto = await fsp.readFile(abs);
             return {
-                relPath: path.relative(cwd, abs) || c,
-                content: await fsp.readFile(abs, 'utf8'),
+                relPath: path.relative(cwd, abs) || caminho,
+                content: bruto.toString('utf8'),
+                inicio: bruto.subarray(0, BYTES_FAREJADOS),
+                origem,
             };
         }
     }
@@ -921,11 +1223,38 @@ const WORKSPACE_SOURCE_GCS_THRESHOLD_BYTES = 1.5 * 1024 * 1024;
  * inline. O Core aceita os dois (campo `sourceUrl` no schema).
  */
 async function runWorkspaceDeploy(opts, productSlug, envName, cwd, nonInteractive) {
-    if (!WORKSPACE_ENVS.has(envName)) {
-        deployFail(opts.json, 'invalid_env', `Ambiente inválido: "${envName}". Use dev, staging ou prod.`);
-    }
+    validarAmbienteDoDeploy(envName, opts.json);
     const source = await resolveWorkspaceSource(opts, cwd);
     const sourceSizeBytes = Buffer.byteLength(source.content, 'utf8');
+    // bug_a8375858 — PACOTE no workspace, pela porta que o gate não vê.
+    //
+    // O gate de contrato (`deploy-target-contract.ts`) só enxerga a extensão de
+    // `--artifact`. Um pacote apontado pelo `source` do neetru.config.json, ou
+    // com extensão que a lista não prevê (`.bin`, nome sem extensão…), chegava
+    // até aqui e só batia no teto abaixo. Lido como UTF-8 o binário incha ~1,75x,
+    // então um pacote abaixo de ~1,15 MiB passava no teto, subia e voltava do
+    // Core como erro de compilação do esbuild, que não diz a causa (revisão do
+    // PR #74). Recusa aqui, ANTES de qualquer signed URL ou POST, pelo nome e
+    // pelos bytes crus — e vem ANTES do teto, pra que um pacote grande ouça
+    // "é pacote" e não "é grande".
+    const motivoDePacote = pareceArquivoDePacote(source.relPath)
+        ? 'a extensão é de pacote de aplicação'
+        : farejarConteudoDePacote(source.inicio);
+    if (motivoDePacote) {
+        deployFail(opts.json, 'artifact_nao_eh_handler_workspace', mensagemSourceNaoEhHandler(source.relPath, motivoDePacote, source.origem));
+    }
+    // bug_a8375858 — teto de source, depois da leitura: na prática, o handler
+    // que simplesmente cresceu demais.
+    //
+    // O que faltava: a CLI conhecia só o limiar de 1.5 MiB do bug_eae4bef6, que
+    // decide *inline vs GCS*, e NUNCA o teto absoluto do Core
+    // (`WORKSPACE_SOURCE_MAX_BYTES`, 2 MiB, aplicado nos dois caminhos). Então
+    // tudo acima de 2 MiB subia pro GCS pra só depois voltar 413 "Falha ao
+    // resolver a source do deploy" — mensagem que aponta a dimensão errada.
+    if (sourceSizeBytes > WORKSPACE_SOURCE_MAX_BYTES) {
+        const cfgTeto = await loadLocalConfig(cwd);
+        deployFail(opts.json, 'source_acima_do_teto_workspace', mensagemSourceAcimaDoTeto(source.relPath, sourceSizeBytes, cfgTeto?.runtime));
+    }
     if (!nonInteractive) {
         log.heading('Resumo');
         log.dim(`  produto:   ${productSlug}`);
@@ -1026,6 +1355,7 @@ async function runWorkspaceDeploy(opts, productSlug, envName, cwd, nonInteractiv
             headers: mfaHeaders,
             body: deployBody,
         });
+        mostrarAvisosDoCore(resp.warnings, opts.json);
     }
     catch (err) {
         spinner.fail('Falha ao publicar.');
@@ -1033,9 +1363,11 @@ async function runWorkspaceDeploy(opts, productSlug, envName, cwd, nonInteractiv
     }
     if (resp.status === 'live') {
         spinner.succeed(`Deploy ${chalk.bold('live')} · ${resp.deploymentId}`);
+        const docsSync = await postDeployDocs(opts, cwd, envName);
         if (opts.json) {
             console.log(JSON.stringify({
                 ok: true,
+                ...(docsSync ? { docs: { sync: docsSync } } : {}),
                 status: 'live',
                 target: 'workspace',
                 deploymentId: resp.deploymentId,
@@ -1053,9 +1385,11 @@ async function runWorkspaceDeploy(opts, productSlug, envName, cwd, nonInteractiv
         // aplicou o deploy mas ainda não confirmou saúde. Sucesso COM AVISO — não
         // tratamos como falha nem fingimos "Live" confirmado.
         spinner.warn(`Deploy aplicado — ${deployStatusLabel(resp.status)} · ${resp.deploymentId}`);
+        const docsSync = await postDeployDocs(opts, cwd, envName);
         if (opts.json) {
             console.log(JSON.stringify({
                 ok: true,
+                ...(docsSync ? { docs: { sync: docsSync } } : {}),
                 status: resp.status,
                 verified: false,
                 target: 'workspace',
@@ -1358,28 +1692,20 @@ async function resolveCloudRunImage(opts, productSlug, envName, cwd) {
  * Deploy `target=cloud-run` — cria/atualiza o serviço Cloud Run dedicado do
  * ambiente. Síncrono: o POST retorna com o desfecho (`live`/`failed`/...).
  */
-async function runCloudRunDeploy(opts, productSlug, envName, cwd, nonInteractive) {
-    if (!WORKSPACE_ENVS.has(envName)) {
-        deployFail(opts.json, 'invalid_env', `Ambiente inválido: "${envName}". Use dev, staging ou prod.`);
-    }
-    // Fix bug_ec17af083d7045a1a00f24255efb716c:
-    // Cloud Run exige uma imagem de container — não um tarball source.
-    // Se o dev passou --artifact (útil pra target=vm/workspace), informamos
-    // claramente o que fazer em vez de silenciosamente ignorar a flag.
-    if (opts.artifact || opts.artifactUrl) {
-        deployFail(opts.json, 'artifact_not_supported_cloud_run', 'target=cloud-run não aceita --artifact / --artifact-url (tarball source).\n' +
-            '  Cloud Run precisa de uma imagem de container OCI já buildada e pushada.\n' +
-            '\n' +
-            '  Opções:\n' +
-            '    1. --image <uri>    — URI de imagem já no Artifact Registry.\n' +
-            '       Exemplo: --image=us-central1-docker.pkg.dev/neetru/gestovendas-staging/app:1.0.0\n' +
-            '\n' +
-            '    2. --registry <host|host/project/repo> — CLI usa Cloud Build remoto automaticamente.\n' +
-            '       Não exige Docker instalado. Requer gcloud autenticado.\n' +
-            '       Exemplo: --registry=us-central1-docker.pkg.dev/neetru/gestovendas-staging\n' +
-            '\n' +
-            '    3. Mude o target pra vm ou workspace se quiser usar o tarball:\n' +
-            '       --target=vm --artifact=' + (opts.artifact ?? opts.artifactUrl ?? '<file>'));
+async function runCloudRunDeploy(opts, productSlug, envName, cwd, nonInteractive, 
+/** O `--env-file` já lido e conferido por `runDeploy` (`lerEnvFileDoDeploy`). */
+envFileTexto) {
+    validarAmbienteDoDeploy(envName, opts.json);
+    // bug_ec17af08 (cloud-run não aceita tarball) agora mora na tabela do
+    // `deploy-target-contract.ts`, avaliada em `runDeploy` logo após o
+    // `pickTarget` — ANTES de qualquer build/upload, pra TODOS os alvos. O
+    // código de erro e o texto são os mesmos; só deixou de ser um `if` solto.
+    // Rodadas finais 2 e 3 do cli#81: o `--env-file` era lido depois de
+    // `resolveCloudRunImage`, que manda a imagem ao Cloud Build. Agora
+    // `runDeploy` o lê e confere antes de tudo; aqui só se montam as variáveis.
+    let envVars;
+    if (envFileTexto !== undefined) {
+        envVars = envVarsDoEnvFile(envFileTexto, 'cloud-run', opts.json);
     }
     // bug_863ae5: pre-flight IAM check — abort cedo se SA Core não tiver permissão.
     // MASTER-HIGH-048 (2.11.0): prefere auth.json sobre Conf legado.
@@ -1387,11 +1713,17 @@ async function runCloudRunDeploy(opts, productSlug, envName, cwd, nonInteractive
     if (deployToken) {
         await assertIamReady(deployToken, 'deploy.cloud-run', opts.json);
     }
-    const imageUrl = await resolveCloudRunImage(opts, productSlug, envName, cwd);
-    let envVars;
-    if (opts.envFile) {
-        envVars = await loadEnvFile(path.resolve(cwd, opts.envFile), 'cloud-run', opts.json);
+    // 2.30.0: varredura de segredo nas pastas públicas ANTES de buildar a imagem.
+    // Com --image (imagem pronta) não há o que varrer aqui — avisa.
+    let publicSecretScan;
+    if (opts.image) {
+        scopedLog(opts.json).warn('Varredura de segredo NÃO feita: --image aponta uma imagem já buildada (o CLI não vê o conteúdo).');
+        publicSecretScan = { scanned: false, reason: 'prebuilt_image' };
+    }
+    else {
+        publicSecretScan = await runPublicSecretGate({ kind: 'dir', root: cwd }, { cwd, envFile: opts.envFile, stack: opts.stack, allowReason: opts.allowPublicSecret, json: opts.json });
     }
+    const imageUrl = await resolveCloudRunImage(opts, productSlug, envName, cwd);
     if (!nonInteractive) {
         log.heading('Resumo');
         log.dim(`  produto:   ${productSlug}`);
@@ -1421,8 +1753,10 @@ async function runCloudRunDeploy(opts, productSlug, envName, cwd, nonInteractive
                 imageUrl,
                 ...(opts.port ? { port: opts.port } : {}),
                 ...(envVars && Object.keys(envVars).length > 0 ? { envVars } : {}),
+                ...(publicSecretScan.override ? { publicSecretOverride: publicSecretScan.override } : {}),
             },
         });
+        mostrarAvisosDoCore(resp.warnings, opts.json);
     }
     catch (err) {
         spinner.fail('Falha ao publicar.');
@@ -1430,9 +1764,11 @@ async function runCloudRunDeploy(opts, productSlug, envName, cwd, nonInteractive
     }
     if (resp.status === 'live') {
         spinner.succeed(`Deploy ${chalk.bold('live')} · ${resp.deploymentId}`);
+        const docsSync = await postDeployDocs(opts, cwd, envName);
         if (opts.json) {
             console.log(JSON.stringify({
                 ok: true,
+                ...(docsSync ? { docs: { sync: docsSync } } : {}),
                 status: 'live',
                 target: 'cloud-run',
                 deploymentId: resp.deploymentId,
@@ -1454,9 +1790,11 @@ async function runCloudRunDeploy(opts, productSlug, envName, cwd, nonInteractive
         // aplicou o deploy mas ainda não confirmou saúde. Sucesso COM AVISO — não
         // tratamos como falha nem fingimos "Live" confirmado.
         spinner.warn(`Deploy aplicado — ${deployStatusLabel(resp.status)} · ${resp.deploymentId}`);
+        const docsSync = await postDeployDocs(opts, cwd, envName);
         if (opts.json) {
             console.log(JSON.stringify({
                 ok: true,
+                ...(docsSync ? { docs: { sync: docsSync } } : {}),
                 status: resp.status,
                 verified: false,
                 target: 'cloud-run',
@@ -1562,18 +1900,115 @@ async function checkSchemaGate(cwd, opts) {
     }
     return true;
 }
+/**
+ * Protocolo de docs v1 (decisão do dono 2026-10-03): depois de um deploy bem
+ * sucedido, publica os docs no Core SÓ se for produção e `docs.publishOnDeploy`
+ * estiver ligado. Nunca lança — falha do sync não derruba o deploy.
+ */
+async function postDeployDocs(opts, cwd, envName) {
+    if (opts.semDocs)
+        return undefined;
+    try {
+        const { deployDocsPostSync } = await import('./docs-produto.js');
+        const r = await deployDocsPostSync(cwd, envName, opts.json);
+        return r.attempted ? r : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export async function runDeploy(opts) {
     if (!opts.json)
         log.banner();
     const cwd = process.cwd();
     const nonInteractive = ensureNonInteractive(opts);
+    // 2.30.0: motivo do override validado ANTES de build/upload.
+    opts = { ...opts, allowPublicSecret: validateAllowPublicSecretReason(opts.allowPublicSecret, opts.json) };
+    // Rodadas finais 2 e 3 do cli#81: o `--env-file` é lido e conferido AQUI,
+    // antes do catálogo e da pergunta do `pickProduct`, da pergunta do
+    // `checkSchemaGate` e do `pickTarget`, da lista de servidores, do build e
+    // do upload. Um arquivo fora de UTF-8 sai como `invalid_encoding` antes de
+    // tudo isso. As variáveis só são montadas depois do `pickTarget`, porque os
+    // avisos dependem do alvo. Com `--target workspace` o arquivo não é lido: o
+    // workspace o descarta, com o aviso do contrato de alvo. Sem `--target`, o
+    // menu ainda pode escolher o workspace, e então o arquivo foi conferido à toa.
+    const envFileTexto = opts.envFile && opts.target !== 'workspace'
+        ? await lerEnvFileDoDeploy(path.resolve(cwd, opts.envFile), opts.json)
+        : undefined;
     const productSlug = await pickProduct(opts, nonInteractive, cwd);
     // GAP-M1-5 — gate de schema: detecta drift antes de prosseguir.
     const canDeploy = await checkSchemaGate(cwd, opts);
     if (!canDeploy) {
         safeExit(1);
     }
-    const target = await pickTarget(opts, nonInteractive);
+    // Protocolo de docs v1 (decisão do dono 2026-10-03): `docs check` antes do
+    // deploy SÓ AVISA — nunca bloqueia, em nenhum ambiente.
+    let docsCheck;
+    if (!opts.semDocs) {
+        try {
+            const { deployDocsPrecheck } = await import('./docs-produto.js');
+            docsCheck = await deployDocsPrecheck(cwd, (opts.env ?? 'dev').toLowerCase(), opts.json);
+        }
+        catch {
+            docsCheck = undefined;
+        }
+    }
+    // O `runtime` do config serve a duas coisas aqui: recomendar o alvo certo no
+    // menu (que só abre em modo interativo e sem `--target`) e o gate de contrato
+    // logo abaixo. Uma leitura só, e só vale se o config é DESTE produto.
+    const runtimeDoConfig = runtimeDoConfigDesteProduto(await loadLocalConfig(cwd), opts.product);
+    const target = await pickTarget(opts, nonInteractive, runtimeDoConfig);
+    // bug_a8375858 — GATE DE CONTRATO `target × runtime × flags`.
+    //
+    // Roda aqui, entre a escolha do alvo e QUALQUER trabalho caro (build,
+    // empacotamento, signed URL, upload pro GCS, POST no Core). Era exatamente
+    // esse o custo do bug: `--target workspace` com tarball de 20 MB subia
+    // ~35 MB pro GCS e só então voltava um 413 que falava de tamanho quando o
+    // problema era o TIPO do alvo.
+    //
+    // O `runtime` já vinha no neetru.config.json e já era lido aqui (o
+    // `loadLocalConfig` devolve o JSON cru) — só não era olhado. Ausente =
+    // nenhuma opinião; o gate não inventa bloqueio pra repo antigo.
+    {
+        const veredito = checkDeployTargetContract({
+            target,
+            runtime: runtimeDoConfig,
+            flags: {
+                artifact: opts.artifact,
+                artifactUrl: opts.artifactUrl,
+                artifactSha256: opts.artifactSha256,
+                image: opts.image,
+                registry: opts.registry,
+                registryRepo: opts.registryRepo,
+                buildLocal: opts.buildLocal,
+                server: opts.server,
+                port: opts.port,
+                stack: opts.stack,
+                envFile: opts.envFile,
+                domain: opts.domain,
+                localArtifact: opts.localArtifact,
+            },
+        });
+        for (const aviso of veredito.warnings) {
+            // Em `--json` o stdout é contrato de 1 linha — aviso vai pro stderr
+            // (bug_6d92ef71: calar por completo em modo máquina é pior).
+            if (opts.json)
+                console.error(aviso);
+            else
+                log.warn(aviso);
+        }
+        if (veredito.errors.length > 0) {
+            const primeiro = veredito.errors[0];
+            // `deployFail` emite 1 erro e sai; os demais entram no corpo pra que uma
+            // rodada só mostre tudo que está errado (meio-conserto é não contar os
+            // outros e o dev voltar aqui amanhã).
+            const extras = veredito.errors
+                .slice(1)
+                .map((e) => `\n\nTambém: ${e.message}`)
+                .join('');
+            deployFail(opts.json, primeiro.code, primeiro.message + extras);
+        }
+    }
     // Caminho workspace (Fase 1 do Fluxo de Ambientes) — sem server/tar/upload.
     if (target === 'workspace') {
         await runWorkspaceDeploy(opts, productSlug, (opts.env ?? 'dev').toLowerCase(), cwd, nonInteractive);
@@ -1581,9 +2016,21 @@ export async function runDeploy(opts) {
     }
     // Caminho cloud-run (Fase 3) — imagem de container, serviço dedicado.
     if (target === 'cloud-run') {
-        await runCloudRunDeploy(opts, productSlug, (opts.env ?? 'dev').toLowerCase(), cwd, nonInteractive);
+        await runCloudRunDeploy(opts, productSlug, (opts.env ?? 'dev').toLowerCase(), cwd, nonInteractive, envFileTexto);
         return;
     }
+    // F-11: env name pra GCS path (`gs://neetru-deploy-artifacts/<product>/<env>/…`).
+    // Default 'dev' quando não definido — alinhado com o middleware OAuth.
+    const envName = (opts.env ?? 'dev').toLowerCase();
+    // EnvVars. Rodadas finais 2 e 3 do cli#81: o `--env-file` era lido DEPOIS
+    // de `resolveArtifact`. Um arquivo fora de UTF-8 só era recusado depois do
+    // build interno (que recusava no stderr, e o `deploy --json` ficava sem a
+    // linha JSON) ou depois de o pacote em cache subir ao GCS. Agora o começo de
+    // `runDeploy` o lê e confere; aqui só se montam as variáveis.
+    let envVars;
+    if (envFileTexto !== undefined) {
+        envVars = envVarsDoEnvFile(envFileTexto, target, opts.json, envName);
+    }
     let serverChoice = null;
     if (target === 'vm') {
         serverChoice = await pickServer(opts, nonInteractive);
@@ -1594,20 +2041,27 @@ export async function runDeploy(opts) {
     // motivou o guard antigo (Core rejeitava sem --port); o Core agora ignora
     // porta em deploy VM, então exigi-la aqui só atrapalharia scripts/CI.
     // --port continua aceito (compat) mas é ignorado com WARN — ver abaixo.
-    if (target === 'vm' && opts.port && !opts.json) {
-        log.warn('A porta é gerenciada pelo Core; --port é ignorado em deploy staging/prod.');
+    //
+    // bug_6d92ef71 (low): o `!opts.json` calava o aviso POR COMPLETO em modo
+    // machine-readable — nem no stdout (certo, quebraria o contrato de 1 linha
+    // JSON do --json), nem em canal nenhum. Quem roda via script nunca
+    // descobria que --port foi descartado. Mantém o aviso humano em stdout no
+    // modo interativo e manda a MESMA informação pro stderr em --json — stderr
+    // não faz parte do contrato de saída parseável, então não quebra nada.
+    // Mensagem também deixou de dizer "staging/prod": o guard dispara pra
+    // QUALQUER ambiente em target=vm (inclusive dev).
+    if (target === 'vm' && opts.port) {
+        const portIgnoredMsg = 'A porta é gerenciada pelo Core em deploy VM (aloca por produto/ambiente/servidor); --port é ignorado.';
+        if (opts.json) {
+            console.error(portIgnoredMsg);
+        }
+        else {
+            log.warn(portIgnoredMsg);
+        }
     }
     const { domain } = await pickDomain(opts, nonInteractive, productSlug);
-    // F-11: env name pra GCS path (`gs://neetru-deploy-artifacts/<product>/<env>/…`).
-    // Default 'dev' quando não definido — alinhado com o middleware OAuth.
-    const envName = (opts.env ?? 'dev').toLowerCase();
     // Build / artifact (default: faz upload pra GCS via signed URL).
     const artifact = await resolveArtifact(opts, productSlug, envName, cwd);
-    // EnvVars.
-    let envVars;
-    if (opts.envFile) {
-        envVars = await loadEnvFile(path.resolve(cwd, opts.envFile), target, opts.json);
-    }
     // Confirmação interativa.
     if (!nonInteractive) {
         log.heading('Resumo');
@@ -1616,7 +2070,13 @@ export async function runDeploy(opts) {
         // no resumo — só cloud-run/workspace mostravam. `ambiente` é o parâmetro que
         // decide se secrets/rota de prod são tocados; tem que aparecer. Em prod,
         // destacado (log.warn) pra não passar batido num Enter.
-        if (envName === 'prod') {
+        // 2026-10-12: era `envName === 'prod'`, mas `isProdEnv` (logo acima, e a
+        // guarda que decide o step-up MFA) aceita TAMBEM `production`. Entao um
+        // `--env production` passava pelo gate de MFA como producao e aparecia no
+        // resumo como ambiente qualquer — sem o destaque, com o Enter do operador
+        // no meio. Conserto pela metade: a mesma pergunta respondida de dois jeitos
+        // no mesmo arquivo.
+        if (isProdEnv(envName)) {
             log.warn(`  ambiente: ${envName}  ← PRODUÇÃO`);
         }
         else {
@@ -1660,6 +2120,14 @@ export async function runDeploy(opts) {
         artifactSha256: artifact.artifactSha256,
         artifactSizeBytes: artifact.artifactSizeBytes,
     };
+    // bug_678ddc98: standalone aninhado de monorepo — o agente não tem como
+    // inferir `apps/web/server.js` olhando a raiz do tarball. Ver
+    // `entrypointParaDeploy` (e, no PR, o que ainda falta do lado do Core).
+    const entrypointAninhado = entrypointParaDeploy(artifact.manifest);
+    if (entrypointAninhado) {
+        body.entrypoint = entrypointAninhado;
+        log.dim(`  entrypoint: ${entrypointAninhado} (standalone aninhado — monorepo)`);
+    }
     if (target === 'vm') {
         body.serverId = serverChoice.id;
         // P6 (2026-07-19): NÃO enviar porta em deploy VM — é detalhe interno do
@@ -1671,6 +2139,10 @@ export async function runDeploy(opts) {
         body.domain = domain;
     if (envVars && Object.keys(envVars).length > 0)
         body.envVars = envVars;
+    // 2.30.0: override da varredura de segredo vai NO deploy (só caminho + tipo
+    // de padrão, nunca o valor). O Core lê do corpo cru (como prodDirectOverride).
+    if (artifact.publicSecretScan.override)
+        body.publicSecretOverride = artifact.publicSecretScan.override;
     const mfaHeaders = await resolveDeployStepUpHeaders(opts, envName, nonInteractive);
     let deploy;
     const dispatchSpinner = ora({ text: 'Enviando comando ao Core…', color: 'blue' }).start();
@@ -1680,6 +2152,7 @@ export async function runDeploy(opts) {
             headers: mfaHeaders,
             body,
         });
+        mostrarAvisosDoCore(deploy.warnings, opts.json);
         dispatchSpinner.succeed(`Deploy criado: ${chalk.bold(deploy.deploymentId)}`);
     }
     catch (err) {
@@ -1707,6 +2180,9 @@ export async function runDeploy(opts) {
         }
         safeExit(1);
     }
+    // Docs no Core (opt-in `docs.publishOnDeploy`, só produção). O pipeline já
+    // aplicou a versão; falha aqui só vira aviso.
+    const docsSync = await postDeployDocs(opts, cwd, envName);
     // ── Fase 0 #1: probe de saúde INDEPENDENTE antes de declarar "Live" ────────
     // O pipeline pode reportar `success` com o site quebrado (outage PDV
     // 2026-09-07). Só declaramos "Live" se um GET real ao domínio confirmar 200 +
@@ -1724,6 +2200,8 @@ export async function runDeploy(opts) {
         url: final.domain ? `https://${final.domain}` : null,
         artifactUrl: artifact.artifactUrl,
         steps: final.steps,
+        publicSecretScan: artifact.publicSecretScan,
+        ...(docsCheck || docsSync ? { docs: { check: docsCheck ?? null, sync: docsSync ?? null } } : {}),
     };
     if (opts.skipHealthProbe) {
         if (opts.json) {