@neetru/cli 2.31.0 → 2.32.1

package/dist/commands/build.js

@@ -28,7 +28,14 @@ import ora from 'ora';
 import { log } from '../utils/logger.js';
 import { safeExit } from '../utils/safe-exit.js';
 import { normalizeTarget } from './env.js';
+import { RUNTIME_ENVIRONMENT_IDS } from '../lib/envs.js';
+import { formatChoices } from '../cli-kit/choices.js';
 import { registerSpinner, unregisterSpinner } from '../utils/spinner-registry.js';
+import { CodificacaoInvalida, decodificarUtf8, semBomInicial } from '../lib/texto-utf8.js';
+import { variaveisDoEnvFile } from '../lib/env-file-do-build.js';
+// bug_678ddc98: detecção de alvo — diretório do app, gerenciador de pacote e
+// layout do standalone (possivelmente aninhado). Ver `src/lib/build-targets.ts`.
+import { detectPackageManager, comandoInstall, comandoRunScript, comandoExecBin, resolveStandaloneLayout, baseDeInjecaoNoTar, } from '../lib/build-targets.js';
 const CONFIG_FILENAMES = ['neetru.config.json', '.neetru.json'];
 function fileExists(p) {
     try {
@@ -318,17 +325,43 @@ function isStandaloneBuildDir(cwd) {
  *     package.json
  *     node_modules/…             (mínimo, tracejado pelo Next.js)
  *     .next/…                    (server chunks, BUILD_ID, etc.)
- *     .next/static/…             (injetado de <cwd>/.next/static)
- *     public/…                   (injetado de <cwd>/public)
+ *     .next/static/…             (injetado de <appDir>/.next/static)
+ *     public/…                   (injetado de <appDir>/public)
+ *
+ * bug_678ddc98 (MONOREPO): o layout acima só vale pra repo de app ÚNICO. Num
+ * monorepo o Next.js traceja a partir do `outputFileTracingRoot` e ANINHA o app
+ * dentro do standalone, porque o `node_modules` tracejado mora na raiz e o
+ * `server.js` precisa enxergá-lo subindo a árvore:
+ *
+ *   raiz-do-tar/
+ *     node_modules/…             (tracejado, compartilhado pelo workspace)
+ *     packages/ui/…              (pacotes internos que o app importa)
+ *     apps/web/server.js         (entrypoint REAL → `node apps/web/server.js`)
+ *     apps/web/.next/…
+ *     apps/web/.next/static/…    (injetado — tem que ir pro prefixo, não pra raiz)
+ *     apps/web/public/…          (idem)
+ *
+ * Antes deste fix o `static`/`public` iam pra RAIZ do tar enquanto o server
+ * rodava de `apps/web/` — o app subia sem CSS/JS e sem os estáticos. `appPrefix`
+ * vem de `resolveStandaloneLayout` (`''` em repo de app único: layout idêntico
+ * ao de antes, byte a byte).
  *
  * Um único `tar` com múltiplos `-C` — não faz staging-copy (não duplica em
  * disco). Os `--exclude` (inclui ENV_TAR_EXCLUDES) são globais, valem pros três
  * `-C`.
  */
-async function tarStandalone(cwd, dest, exclude = [], quiet = false) {
-    const standaloneDir = path.join(cwd, '.next', 'standalone');
-    const staticDir = path.join(cwd, '.next', 'static');
-    const publicDir = path.join(cwd, 'public');
+async function tarStandalone(appDir, dest, exclude = [], quiet = false, appPrefix = '') {
+    const standaloneDir = path.join(appDir, '.next', 'standalone');
+    const staticDir = path.join(appDir, '.next', 'static');
+    const publicDir = path.join(appDir, 'public');
+    // bug_678ddc98: pra gravar o membro já aninhado (`apps/web/.next/static`) sem
+    // `--transform`/`-s` (não portáveis entre GNU tar e bsdtar), o `-C` recua até
+    // a raiz de tracing e o membro leva o prefixo junto. Ver `baseDeInjecaoNoTar`.
+    const injecao = baseDeInjecaoNoTar(appDir, appPrefix);
+    if (!injecao) {
+        throw new Error(`Não foi possível mapear o prefixo "${appPrefix}" do standalone pro disco a partir de ${appDir}. ` +
+            'Isso indica um layout de standalone inesperado — abortando pra não empacotar estáticos no caminho errado.');
+    }
     const isWinGnu = process.platform === 'win32' && (await tarIsGnu());
     const norm = (p) => (isWinGnu ? normalizePathForTar(p) : p);
     const args = [];
@@ -340,18 +373,18 @@ async function tarStandalone(cwd, dest, exclude = [], quiet = false) {
     for (const ex of [...exclude, ...ENV_TAR_EXCLUDES]) {
         args.push(`--exclude=${ex}`);
     }
-    // 1) Todo o conteúdo do standalone → RAIZ do tar.
+    // 1) Todo o conteúdo do standalone → RAIZ do tar (com o aninhamento que o
+    //    Next.js produziu, quando houver).
     args.push('-C', norm(standaloneDir), '.');
-    // 2) `.next/static` → `./.next/static` (Next.js não copia sozinho). Usar
-    //    `-C <cwd> .next/static` grava members `.next/static/...` (forward-slash
-    //    aceito por bsdtar e GNU tar), que casam com o `.next` já vindo do
-    //    standalone e mergeiam na extração.
+    // 2) `.next/static` → `./<prefixo>.next/static` (Next.js não copia sozinho).
+    //    Forward-slash no membro é aceito por bsdtar e GNU tar, e casa com o
+    //    `.next` já vindo do standalone — mergeiam na extração.
     if (fileExists(staticDir)) {
-        args.push('-C', norm(cwd), '.next/static');
+        args.push('-C', norm(injecao.chdir), `${injecao.prefixo}.next/static`);
     }
-    // 3) `public` → `./public` (idem — não vem no standalone).
+    // 3) `public` → `./<prefixo>public` (idem — não vem no standalone).
     if (fileExists(publicDir)) {
-        args.push('-C', norm(cwd), 'public');
+        args.push('-C', norm(injecao.chdir), `${injecao.prefixo}public`);
     }
     try {
         await runCmd('tar', args, process.cwd(), undefined, quiet);
@@ -456,70 +489,73 @@ function parseUnixEnvPrefix(script) {
  *   linha vazia            (ignorada)
  *
  * Não suporta multi-line values — use aspas com \n.
+ *
+ * Revisão do cli#81 (N-r3-1): o arquivo é lido em bytes e só segue se for
+ * UTF-8 (`decodificarUtf8`). Antes, `readFile(…, 'utf8')` trocava cada byte
+ * que não é UTF-8 por U+FFFD sem aviso, e um .env ANSI com `NOME_LOJA=Café`
+ * entrava no build como `Caf\uFFFD`. A recusa é `CodificacaoInvalida`, que
+ * `runBuild` mostra como `invalid_encoding`.
  */
 async function loadEnvFile(envFile) {
-    let content;
+    let bruto;
     try {
-        content = await fsp.readFile(envFile, 'utf8');
+        bruto = await fsp.readFile(envFile);
     }
     catch {
         throw new Error(`--env-file: arquivo não encontrado: ${envFile}`);
     }
-    const vars = {};
-    for (const line of content.split(/\r?\n/)) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#'))
-            continue;
-        const eq = trimmed.indexOf('=');
-        if (eq === -1)
-            continue;
-        const key = trimmed.slice(0, eq).trim();
-        let val = trimmed.slice(eq + 1).trim();
-        // Remove aspas simétricas.
-        if (val.length >= 2) {
-            const open = val[0];
-            const close = val[val.length - 1];
-            if ((open === '"' && close === '"') || (open === "'" && close === "'")) {
-                val = val.slice(1, -1);
-            }
-        }
-        if (!key)
-            continue;
-        vars[key] = val;
-    }
-    return vars;
+    return variaveisDoEnvFile(semBomInicial(decodificarUtf8(bruto, 'env-file')));
 }
-async function buildNode(cwd, noCache, noInstall = false, extraEnv, targetEnv = 'prod', quiet = false) {
+async function buildNode(cwd, noCache, noInstall = false, extraEnv, targetEnv = 'prod', quiet = false, 
+// bug_678ddc98: o gerenciador de pacote deixa de ser `npm` cravado. Quem
+// chama já detectou (lockfile/campo packageManager) e passa aqui — default
+// mantém o comportamento histórico pra qualquer caller que não passe nada.
+pm = { name: 'npm', rootDir: cwd, source: 'default' }) {
     const lg = scopedLog(quiet);
     const pkgPath = path.join(cwd, 'package.json');
     if (!fileExists(pkgPath))
         throw new Error('Stack node sem package.json.');
     const pkg = JSON.parse(await fsp.readFile(pkgPath, 'utf8'));
+    const install = comandoInstall(pm.name);
+    const runBuildScript = comandoRunScript(pm.name, 'build');
     // bug_93f984a (MEDIUM): npm ci conflita com `next dev` em Windows (file locks
     // em node_modules/@next/swc-*). Trocar pra `npm install --no-save --no-audit
     // --no-fund` que respeita locks parciais. Flag --no-install permite skip
     // total quando dev sabe que node_modules está OK.
     if (noInstall) {
-        lg.dim('npm install pulado (--no-install).');
+        lg.dim(`${install.cmd} install pulado (--no-install).`);
     }
     else {
         if (noCache) {
             // BUG-016 fix (2026-05-13): não apagar package-lock.json do usuário.
             // Em vez disso, limpamos o cache do npm global se `--no-cache` for exigido.
-            lg.info('Limpando cache do npm (--no-cache)…');
-            try {
-                await runCmd('npm', ['cache', 'clean', '--force'], cwd, undefined, quiet);
+            // bug_678ddc98: `cache clean --force` é sintaxe de npm/pnpm; yarn e bun
+            // usam outra, então pros dois a limpeza é pulada (nunca é fatal — o
+            // --no-cache continua valendo pro caminho docker).
+            if (pm.name === 'npm' || pm.name === 'pnpm') {
+                lg.info(`Limpando cache do ${pm.name} (--no-cache)…`);
+                try {
+                    await runCmd(pm.name, ['cache', 'clean', '--force'], cwd, undefined, quiet);
+                }
+                catch {
+                    // Ignora falha de cache clean e prossegue
+                }
             }
-            catch {
-                // Ignora falha de cache clean e prossegue
+            else {
+                lg.dim(`  --no-cache ignorado: ${pm.name} não tem \`cache clean --force\`.`);
             }
         }
         if (process.platform === 'win32') {
-            lg.warn(`Se houver \`next dev\` ativo na pasta, ele pode conflitar com o npm install (file locks).\n` +
+            lg.warn(`Se houver \`next dev\` ativo na pasta, ele pode conflitar com o ${install.cmd} install (file locks).\n` +
                 `  Pause o dev server antes do build, ou use --no-install pra pular esta etapa.`);
         }
-        lg.info('npm install (não destructivo, respeita locks)…');
-        await runCmd('npm', ['install', '--no-save', '--no-audit', '--no-fund'], cwd, undefined, quiet);
+        // bug_678ddc98: o install roda na RAIZ do workspace (onde mora o lockfile),
+        // não no diretório do app — `pnpm install` dentro de `apps/web` sem o
+        // lockfile por perto instala um projeto solto e quebra os links dos pacotes
+        // internos. Em repo de app único `pm.rootDir === cwd` e nada muda.
+        lg.info(`${install.cmd} ${install.args.join(' ')} (não destrutivo, respeita locks)` +
+            `${pm.rootDir === cwd ? '' : ` em ${pm.rootDir}`}…`);
+        await runCmd(install.cmd, install.args, pm.rootDir, undefined, quiet);
     }
     if (pkg.scripts?.build) {
         // Fix crítico (2026-07-22, incidente pdv-agiliza): `NEXT_PUBLIC_NEETRU_ENV`
@@ -546,13 +582,17 @@ async function buildNode(cwd, noCache, noInstall = false, extraEnv, targetEnv =
             lg.info(`Script "build" usa env-prefix Unix. Auto-injetando ${Object.keys(mergedEnv).join('+')} via spawn-env (compat Windows).`);
             lg.dim(`  Original: ${pkg.scripts.build}`);
             lg.dim(`  Executando: ${cmd} (com env: ${JSON.stringify(mergedEnv)})`);
-            // Roda o comando real com env injetado. Usa npx pra resolver bins de
+            // Roda o comando real com env injetado, resolvendo bins de
             // node_modules/.bin (next, vite, tsc, etc).
             const parts = cmd.split(/\s+/);
             const bin = parts[0];
             const args = parts.slice(1);
-            // npx <bin> respeita node_modules/.bin; se nao tem bin local, fallback ao PATH.
-            await runCmd('npx', [bin, ...args], cwd, mergedEnv, quiet);
+            // bug_678ddc98: `npx` era cravado aqui. Com pnpm isso é um tiro no pé —
+            // os bins ficam atrás do store de links e o npx acabaria BAIXANDO o
+            // pacote do registry em vez de usar o do workspace. `comandoExecBin`
+            // devolve `pnpm exec`/`yarn exec`/`bunx`/`npx` conforme o gerenciador.
+            const exec = comandoExecBin(pm.name, bin, args);
+            await runCmd(exec.cmd, exec.args, cwd, mergedEnv, quiet);
         }
         else {
             const mergedEnv = { ...(extraEnv ?? {}), ...forcedEnv };
@@ -562,9 +602,11 @@ async function buildNode(cwd, noCache, noInstall = false, extraEnv, targetEnv =
                 lg.info(`Injetando ${Object.keys(extraEnv).length} var(s) de env-file: ${Object.keys(extraEnv).join(', ')}`);
             }
             else {
-                lg.info('npm run build…');
+                lg.info(`${runBuildScript.cmd} ${runBuildScript.args.join(' ')}…`);
             }
-            await runCmd('npm', ['run', 'build'], cwd, mergedEnv, quiet);
+            // O BUILD roda no diretório do APP (não na raiz do workspace): é lá que
+            // mora o script `build` e é lá que o Next.js grava o `.next`.
+            await runCmd(runBuildScript.cmd, runBuildScript.args, cwd, mergedEnv, quiet);
         }
     }
     // bug_b8e6e1a2: Next.js `output: 'standalone'` — a verdade pós-build é a pasta
@@ -572,8 +614,25 @@ async function buildNode(cwd, noCache, noInstall = false, extraEnv, targetEnv =
     // Standalone roda via `node server.js` (com seu node_modules mínimo próprio),
     // NUNCA `next start` — por isso o entrypoint muda pra `server.js` e o
     // empacotamento pula o node_modules gigante da raiz.
+    const layout = resolveStandaloneLayout(cwd);
     const standalone = isStandaloneBuildDir(cwd) || detectStandaloneOutput(cwd);
-    return { entrypoint: standalone ? 'server.js' : (pkg.main ?? 'index.js'), standalone };
+    // bug_678ddc98: o entrypoint era a string FIXA `'server.js'`. Num monorepo o
+    // Next.js aninha o app dentro do standalone (`apps/web/server.js`) e esse
+    // caminho fixo apontava pro vazio. Agora vem do layout real pós-build.
+    if (standalone && isStandaloneBuildDir(cwd) && !layout) {
+        throw new Error('Existe `.next/standalone` mas nenhum `server.js` foi encontrado dentro dele. ' +
+            'Num monorepo o Next.js aninha o app sob o `outputFileTracingRoot` (ex: `apps/web/server.js`) — ' +
+            'confira se o build rodou no diretório certo (use `--app <dir>`) e se `output: "standalone"` está ativo. ' +
+            'Abortando: um tarball sem entrypoint sobe e nunca inicia.');
+    }
+    if (layout?.appPrefix) {
+        lg.dim(`  standalone aninhado: entrypoint = ${layout.entrypoint} (monorepo — bug_678ddc98)`);
+    }
+    return {
+        entrypoint: standalone ? (layout?.entrypoint ?? 'server.js') : (pkg.main ?? 'index.js'),
+        standalone,
+        appPrefix: layout?.appPrefix ?? '',
+    };
 }
 /**
  * `''`/whitespace/`null`/`undefined` num campo do manifesto contam como
@@ -714,9 +773,14 @@ async function buildPhp(cwd, quiet = false) {
     }
     return { entrypoint: 'index.php' };
 }
-async function buildStatic(cwd, noInstall = false, targetEnv = 'prod', quiet = false) {
+async function buildStatic(cwd, noInstall = false, targetEnv = 'prod', quiet = false, 
+// bug_678ddc98: mesmo tratamento do stack node — um export estático também
+// pode viver num monorepo pnpm/yarn.
+pm = { name: 'npm', rootDir: cwd, source: 'default' }) {
     const lg = scopedLog(quiet);
     const pkgPath = path.join(cwd, 'package.json');
+    const install = comandoInstall(pm.name);
+    const runBuildScript = comandoRunScript(pm.name, 'build');
     if (fileExists(pkgPath)) {
         try {
             const pkg = JSON.parse(await fsp.readFile(pkgPath, 'utf8'));
@@ -726,8 +790,9 @@ async function buildStatic(cwd, noInstall = false, targetEnv = 'prod', quiet = f
                     if (process.platform === 'win32') {
                         lg.warn('Se houver `next dev` ativo, pause antes (file locks).');
                     }
-                    lg.info('npm install (não destructivo)…');
-                    await runCmd('npm', ['install', '--no-save', '--no-audit', '--no-fund'], cwd, undefined, quiet);
+                    lg.info(`${install.cmd} ${install.args.join(' ')} (não destrutivo)…`);
+                    // Install na raiz do workspace — ver o porquê em `buildNode`.
+                    await runCmd(install.cmd, install.args, pm.rootDir, undefined, quiet);
                 }
                 // Fix (2026-07-22, achado da revisão adversarial): `--stack static`
                 // também roda `next build` (output:'export') pra produtos Next.js
@@ -735,8 +800,8 @@ async function buildStatic(cwd, noInstall = false, targetEnv = 'prod', quiet = f
                 // .env.production do stack node, mas sem proteção nenhuma até aqui.
                 // Mesmo forçado via spawn-env que buildNode (ver ali pro porquê).
                 lg.dim(`  NEXT_PUBLIC_NEETRU_ENV forçado via spawn-env: ${targetEnv} (incidente pdv-agiliza 2026-07-22)`);
-                lg.info('npm run build…');
-                await runCmd('npm', ['run', 'build'], cwd, { NEXT_PUBLIC_NEETRU_ENV: targetEnv }, quiet);
+                lg.info(`${runBuildScript.cmd} ${runBuildScript.args.join(' ')}…`);
+                await runCmd(runBuildScript.cmd, runBuildScript.args, cwd, { NEXT_PUBLIC_NEETRU_ENV: targetEnv }, quiet);
             }
         }
         catch {
@@ -760,8 +825,34 @@ export async function runBuild(opts = {}) {
     const startedAt = Date.now();
     if (!quiet)
         log.banner();
-    const cwd = process.cwd();
-    const localCfg = await loadLocalConfig(cwd);
+    // bug_678ddc98: duas noções de diretório, antes confundidas num `cwd` só.
+    //
+    //   `invocacaoDir` = onde o dev rodou o comando. Manda no ARTEFATO: é onde
+    //     sai o `.neetru-build/`, e é contra ele que os caminhos do manifest são
+    //     relativizados. Precisa continuar assim porque o `neetru deploy` procura
+    //     `<cwd>/.neetru-build/manifest.json` — se o artefato fosse pro diretório
+    //     do app, um `neetru build --app apps/web && neetru deploy` da raiz não
+    //     acharia nada.
+    //   `cwd` (= diretório do APP) = onde mora o package.json a construir. Manda
+    //     no BUILD: stack, versão, script `build`, `.next`, standalone, guard.
+    //
+    // Sem `--app` os dois são o mesmo diretório — comportamento idêntico ao de antes.
+    const invocacaoDir = process.cwd();
+    const cwd = path.resolve(invocacaoDir, opts.app ?? '.');
+    if (opts.app) {
+        if (!fileExists(cwd)) {
+            const msg = `--app "${opts.app}" não existe (resolvido para ${cwd}).`;
+            if (machineOutput)
+                emitBuildJsonError(msg, 'app_dir_not_found');
+            else
+                log.error(msg);
+            safeExit(1);
+        }
+        lg.dim(`  app=${path.relative(invocacaoDir, cwd) || '.'} (monorepo — bug_678ddc98)`);
+    }
+    // O `neetru.config.json` pode morar no app (monorepo) ou na raiz do repo —
+    // procura nos dois, app primeiro (mais específico vence).
+    const localCfg = (await loadLocalConfig(cwd)) ?? (cwd === invocacaoDir ? null : await loadLocalConfig(invocacaoDir));
     const slug = opts.product ?? localCfg?.slug;
     if (!slug) {
         const msg = '--product <slug> é obrigatório (ou rode em diretório com neetru.config.json).';
@@ -795,7 +886,7 @@ export async function runBuild(opts = {}) {
     if (opts.targetEnv) {
         const normalized = normalizeTarget(opts.targetEnv);
         if (!normalized) {
-            const msg = `--target-env "${opts.targetEnv}" inválido. Use: dev | workspace | prod.`;
+            const msg = `--target-env "${opts.targetEnv}" inválido. Use: ${formatChoices(RUNTIME_ENVIRONMENT_IDS)}.`;
             if (machineOutput)
                 emitBuildJsonError(msg, 'invalid_target_env');
             else
@@ -808,27 +899,52 @@ export async function runBuild(opts = {}) {
     // via spawn-env apenas durante o build — não vão pro Core nem ao manifest.
     let buildEnvVars;
     if (opts.envFile) {
-        const envFilePath = path.resolve(cwd, opts.envFile);
-        buildEnvVars = await loadEnvFile(envFilePath);
+        // Resolvido contra o diretório de INVOCAÇÃO: o dev digitou o caminho a
+        // partir de onde ele está, não a partir do diretório do app.
+        const envFilePath = path.resolve(invocacaoDir, opts.envFile);
+        try {
+            buildEnvVars = await loadEnvFile(envFilePath);
+        }
+        catch (err) {
+            if (!(err instanceof CodificacaoInvalida))
+                throw err;
+            if (machineOutput)
+                emitBuildJsonError(err.message, 'invalid_encoding');
+            else
+                log.error(err.message);
+            safeExit(1);
+        }
         lg.info(`Env-file carregado: ${opts.envFile} (${Object.keys(buildEnvVars).length} vars)`);
         // Loga os nomes (nunca os valores) pra rastreabilidade sem vazar secrets.
         lg.dim(`  vars: ${Object.keys(buildEnvVars).join(', ')}`);
     }
     lg.heading(`neetru build`);
     lg.dim(`  slug=${slug}  version=${version}  stack=${stack}${rawStack === 'nextjs' ? ' (nextjs→node)' : ''}`);
-    const outputDir = path.resolve(cwd, opts.output ?? '.neetru-build');
+    // Artefato sai no diretório de INVOCAÇÃO (ver o bloco de `invocacaoDir`) —
+    // é o que mantém `neetru build --app apps/web && neetru deploy` funcionando
+    // a partir da raiz do monorepo.
+    const outputDir = path.resolve(invocacaoDir, opts.output ?? '.neetru-build');
     await ensureDir(outputDir);
     const tarballName = `${slug}-${version}.tar.gz`;
     let tarballPath = path.join(outputDir, tarballName);
     let entrypoint;
+    // bug_678ddc98 (elo que faltava): o layout aninhado era calculado, usado pro
+    // tar e DESCARTADO. O deploy precisa dele pra decidir se manda o entrypoint.
+    let appPrefix = '';
     const spinner = registerSpinner(ora({ text: `Construindo ${stack}…`, color: 'blue' }).start());
     try {
         if (stack === 'node') {
             // bug_25ff8581: passa extraEnv do --env-file para o buildNode.
             // Incidente 2026-07-22: passa targetEnv — força NEXT_PUBLIC_NEETRU_ENV
             // via spawn-env, neutralizando .env.local vencendo .env.production.
-            const r = await buildNode(cwd, !!opts.noCache, !!opts.noInstall, buildEnvVars, targetEnv, quiet);
+            // bug_678ddc98: o gerenciador vem do lockfile/campo `packageManager`
+            // (npm/pnpm/yarn/bun), não mais cravado em `npm`.
+            const pm = detectPackageManager(cwd);
+            lg.dim(`  gerenciador=${pm.name} (${pm.source}${pm.lockfile ? `: ${pm.lockfile}` : ''})` +
+                `${pm.rootDir === cwd ? '' : `  raiz-do-workspace=${path.relative(invocacaoDir, pm.rootDir) || '.'}`}`);
+            const r = await buildNode(cwd, !!opts.noCache, !!opts.noInstall, buildEnvVars, targetEnv, quiet, pm);
             entrypoint = r.entrypoint;
+            appPrefix = r.appPrefix;
             // Incidente 2026-07-22: confirma que o bundle compilado realmente
             // refletiu o targetEnv (defesa contra scripts de build customizados
             // que ignorem o spawn-env acima) ANTES de empacotar o tarball.
@@ -840,7 +956,10 @@ export async function runBuild(opts = {}) {
                 // agente da VM estourava o timeout de 120s de extração, bug_e3202fcc, e
                 // bloqueava o deploy). O standalone já traz seu node_modules mínimo.
                 lg.info('Next.js standalone detectado — empacotando output tracejado (sem node_modules da raiz).');
-                await tarStandalone(cwd, tarballPath, ['*.log'], quiet);
+                // bug_678ddc98: `appPrefix` leva `.next/static` e `public` pro lugar
+                // onde o `server.js` aninhado vai procurá-los. `''` = layout de app
+                // único, idêntico ao anterior.
+                await tarStandalone(cwd, tarballPath, ['*.log'], quiet, r.appPrefix);
             }
             else {
                 // Não-standalone: o servidor (`next start`/`node`) precisa do
@@ -869,7 +988,7 @@ export async function runBuild(opts = {}) {
         else if (stack === 'static') {
             // Incidente 2026-07-22: --stack static também roda `next build`
             // (output:'export') pra produtos Next.js — mesma proteção do stack node.
-            const r = await buildStatic(cwd, !!opts.noInstall, targetEnv, quiet);
+            const r = await buildStatic(cwd, !!opts.noInstall, targetEnv, quiet, detectPackageManager(cwd));
             entrypoint = r.entrypoint;
             await validateBuildEnvManifest(cwd, targetEnv, quiet);
             await tarDirectory(r.root, tarballPath, ['.git', '.neetru-build'], quiet);
@@ -877,7 +996,7 @@ export async function runBuild(opts = {}) {
         else {
             throw new Error(`Stack desconhecida: ${stack}`);
         }
-        spinner.succeed(`Empacotado: ${chalk.bold(path.relative(cwd, tarballPath))}`);
+        spinner.succeed(`Empacotado: ${chalk.bold(path.relative(invocacaoDir, tarballPath))}`);
         unregisterSpinner(spinner);
     }
     catch (err) {
@@ -913,17 +1032,20 @@ export async function runBuild(opts = {}) {
         version,
         // Gravamos o stack canônico (nextjs já foi normalizado acima).
         stack,
-        tarball: path.relative(cwd, tarballPath),
+        tarball: path.relative(invocacaoDir, tarballPath),
         sha256,
         sizeBytes,
         entrypoint,
+        // Só grava quando há aninhamento — manifest de app único fica idêntico ao
+        // de antes (nenhuma chave nova), então nada a montante muda de forma.
+        ...(appPrefix ? { appPrefix } : {}),
         builtAt: new Date().toISOString(),
     };
     const manifestPath = path.join(outputDir, 'manifest.json');
     await fsp.writeFile(manifestPath, JSON.stringify(manifest, null, 2), 'utf8');
     lg.dim(`  sha256=${sha256.slice(0, 16)}…`);
     lg.dim(`  size=${(sizeBytes / 1024 / 1024).toFixed(2)} MB`);
-    lg.dim(`  manifest=${path.relative(cwd, manifestPath)}`);
+    lg.dim(`  manifest=${path.relative(invocacaoDir, manifestPath)}`);
     lg.success(`Build pronto. Use: ${chalk.bold('neetru deploy --product=' + slug)}`);
     // SETOR 5.1: em --json, imprime UMA linha JSON estruturada no stdout no fim.
     // Não emite quando chamado internamente pelo deploy (`quiet` sem `json`) — o
@@ -942,7 +1064,7 @@ export async function runBuild(opts = {}) {
             sizeBytes,
             entrypoint: entrypoint ?? null,
             builtAt: manifest.builtAt,
-            manifestPath: path.relative(cwd, manifestPath),
+            manifestPath: path.relative(invocacaoDir, manifestPath),
             durationMs: Date.now() - startedAt,
         }));
     }

package/dist/commands/chat.d.ts

@@ -1,4 +1,5 @@
 import type { Command } from 'commander';
+import type { NeetruCliError } from '../cli-kit/errors.js';
 type ActorType = 'agent_claude' | 'human' | 'cli';
 type ChatChannelType = 'global' | 'product' | 'custom';
 export interface ChatChannelsOptions {
@@ -44,6 +45,82 @@ export interface ChatIdentityOptions {
     /** Suprime o log de sucesso (usado pelo --as do send). */
     quiet?: boolean;
 }
+/**
+ * O que `neetru chat identity <args...>` pede.
+ *
+ * bug_09574d4b (2026-10-12): o comando só aceitava o apelido POSICIONAL, e não
+ * havia subcomando — mas a skill da casa (`neetru-chat`) documenta
+ * `identity set "Nome"` e `identity show`. Resultado: `identity show` GRAVAVA o
+ * apelido "show", e `identity set "PDV · IA"` gravava "set" e descartava o
+ * nome. Sem aviso: a saída era o mesmo "✓ Apelido definido" do caminho feliz.
+ *
+ * Agora `show`/`ver` lê, `set`/`definir` grava o resto, `clear`/`limpar` limpa,
+ * e o posicional antigo (`identity "PDV · IA"`) segue funcionando. O preço: não
+ * dá pra ter um apelido que seja SÓ uma dessas palavras.
+ *
+ * P105 (2026-10-18): o conserto acima cobria só as palavras que ele conhecia.
+ * `identity describe` gravava "describe", `identity list` gravava "list",
+ * `identity show Fulano` gravava "show Fulano" e `identity set clear` gravava
+ * "clear". Agora nenhum verbo de `identity` (os de `LER`/`DEFINIR`/`LIMPAR`)
+ * nem sinônimo de um deles (`SYNONYMS`, cli-kit) vira apelido: a CLI recusa e
+ * sugere o verbo certo, com o piso de qualidade do gcloud (`MIN_RATIO`) — sem
+ * sugestão que passe o piso, lista os três. Um apelido que só COMEÇA com um
+ * verbo continua possível pela forma explícita (`identity set "Show de Bola"`);
+ * um apelido que É um verbo (`Set`, `Ver`) só pelo `--as` do `send`, e a
+ * recusa ensina esse caminho.
+ *
+ * Os caminhos citados (`neetru chat identity …`, `neetru chat send --as`) saem
+ * da árvore do Commander (`contextoDeIdentidadeDaArvore`), não de literal
+ * (revisão do #87, BAIXO 5).
+ */
+export type PedidoDeIdentidade = {
+    acao: 'mostrar';
+} | {
+    acao: 'definir';
+    apelido: string;
+} | {
+    acao: 'erro';
+    mensagem: string;
+    erro?: NeetruCliError;
+};
+/** Caminho do comando na árvore, sem o `neetru` (ex.: `'chat channels create'`). */
+export declare function caminhoDoComando(cmd: Command | null | undefined): string;
+/** Onde `identity` mora na árvore e por onde se grava um apelido que é verbo. */
+export interface ContextoDeIdentidade {
+    /** Caminho do `identity`, sem o `neetru`. */
+    comando: string;
+    /** Caminho do `send` que declara `--as`, ou `null` se a árvore não tem esse caminho. */
+    definirViaSend: string | null;
+}
+/** O que a árvore de verdade dá hoje — travado por teste contra `registerChatCommand`. */
+export declare const CONTEXTO_DE_IDENTIDADE_PADRAO: ContextoDeIdentidade;
+/** Deriva o contexto do nó `identity` do Commander (o que o `.action()` recebe). */
+export declare function contextoDeIdentidadeDaArvore(identity: Command): ContextoDeIdentidade;
+export declare function interpretarArgsDeIdentidade(args: readonly string[], ctx?: ContextoDeIdentidade): PedidoDeIdentidade;
+/**
+ * Texto livre POSICIONAL de uma palavra só que é SUBCOMANDO irmão (nome,
+ * apelido ou sinônimo): recusa (P105). `neetru chat send history` postava
+ * "history" no canal global achando que listava; `neetru chat channels create
+ * close` criava o canal "close". Os subcomandos e o caminho citados saem do
+ * nó do Commander em execução (`command`), não de literal.
+ *
+ * `null` quando o texto pode seguir: resposta comum (`show`, `ok`, `top`,
+ * `beleza`, `valeu`, `sim`, `blz` — revisão do #87, BAIXO 6) e frase que só
+ * começa com uma palavra de comando ("history do dia").
+ */
+export declare function verboComoTextoPosicional(input: {
+    texto: string;
+    command: Command;
+    oQue: string;
+    escapeHint?: string;
+}): NeetruCliError | null;
+interface ChatIdentityResponse {
+    ok: true;
+    /** Apelido atual (string vazia = nenhum). */
+    displayName: string;
+    /** Email da credencial — só no GET. */
+    email?: string;
+}
 /**
  * `neetru chat identity [apelido]` — apelido inerente à credencial (CH3).
  *
@@ -55,7 +132,23 @@ export interface ChatIdentityOptions {
  * O apelido vive em `cli_api_keys/{keyId}.displayName` — é inerente ao token,
  * não por-mensagem.
  */
-export declare function runChatIdentity(displayName: string | undefined, opts?: ChatIdentityOptions): Promise<void>;
+export declare function runChatIdentity(displayName: string | undefined, opts?: ChatIdentityOptions): Promise<ChatIdentityResponse | undefined>;
+/**
+ * `chat send --as <apelido>`.
+ *
+ * O Core NÃO tem apelido por mensagem — o nome vem da credencial
+ * (`cli_api_keys/{keyId}.displayName`). Então `--as` só pode PERSISTIR. O defeito
+ * (bug_09574d4b) não era persistir: era persistir CALADO — e o help da versão
+ * publicada dizia só "antes de enviar", então quem lia concluía, com razão, que
+ * valia para aquela mensagem. Credencial compartilhada entre sessões fazia uma
+ * renomear a outra sem ninguém ver.
+ *
+ * Agora: se o apelido já é o pedido, nada muda (nem chamada de escrita); se muda,
+ * o aviso vai pro STDERR dizendo de quem para quem e que vale para as próximas
+ * mensagens da credencial. STDERR porque em `--json` o stdout é contrato de uma
+ * linha.
+ */
+export declare function aplicarApelidoDoSend(apelidoBruto: string, json: boolean): Promise<void>;
 export interface ChatHistoryOptions {
     /** Canal de destino (novo — tem precedência sobre product). */
     channel?: string;