@neetru/cli 2.29.0 → 2.32.0

package/dist/commands/deployments.js

@@ -13,6 +13,7 @@ import chalk from 'chalk';
 import { apiRequest, CliApiError, CliNetworkError } from '../lib/api-client.js';
 import { requireToken, handleApiError, confirmDestructive, printWriteResult, resolveStepUp, } from '../lib/cli-write.js';
 import { pickProductId, pickServer, pickTenant, promptChoice, promptText } from '../lib/pickers.js';
+import { DEFAULT_TENANT_ENVIRONMENT_ID, ESCOLHAS_AMBIENTE_TENANT, resolverAmbienteTenant, } from '../lib/envs.js';
 import { log } from '../utils/logger.js';
 import { safeExit } from '../utils/safe-exit.js';
 /** Monta o texto do console de deploy (estilo GCP): um bloco por step. */
@@ -39,12 +40,16 @@ export async function runDeploymentsCreate(opts) {
         message: 'Tenant alvo:',
     });
     const version = opts.version ?? (await promptText('Versao:', { json: opts.json }));
-    const env = opts.env ??
-        (await promptChoice('Ambiente:', [
-            { name: 'dev', value: 'dev' },
-            { name: 'staging', value: 'staging' },
-            { name: 'prod', value: 'prod' },
-        ], { default: 'dev', json: opts.json }));
+    // bug_7dcb68e2666a43f69ef362d2cbff94ed: POST /api/cli/v1/deployments valida
+    // environmentId contra ['dev-local','staging','prod'] por igualdade ESTRITA.
+    // Oferecer 'dev' no prompt (e usa-lo como padrao) garantia 400
+    // validation_failed. Alfabeto unico em ../lib/envs.js.
+    const env = opts.env
+        ? resolverAmbienteTenant(opts.env, opts.json)
+        : (await promptChoice('Ambiente:', [...ESCOLHAS_AMBIENTE_TENANT], {
+            default: DEFAULT_TENANT_ENVIRONMENT_ID,
+            json: opts.json,
+        }));
     const server = await pickServer(token, {
         fromFlag: opts.server,
         status: 'online',

package/dist/commands/dev-context.js

@@ -7,12 +7,22 @@ import { listProductDatabases, listProducts, listWorkspaces, resolveProductIdent
 import { requireToken, handleApiError } from '../lib/cli-read.js';
 import { log } from '../utils/logger.js';
 import { safeExit } from '../utils/safe-exit.js';
-function normalizeEnv(value) {
+import { invalidChoiceError } from '../cli-kit/choices.js';
+import { exitWithCliError } from '../lib/cli-error.js';
+/** Ambientes aceitos por `neetru dev sync --env` — validação e mensagem saem daqui. */
+const SYNC_ENVS = ['dev', 'dev-local', 'dev-core'];
+function normalizeEnv(value, json) {
     const raw = (value ?? 'dev').trim().toLowerCase();
-    if (raw === 'dev' || raw === 'dev-local' || raw === 'dev-core')
+    if (SYNC_ENVS.includes(raw))
         return raw;
-    log.error(`Ambiente "${value}" inválido para dev-local. Use: dev | dev-local | dev-core.`);
-    safeExit(1);
+    // bug_89d2497e: a lista da mensagem é a MESMA que validou (`SYNC_ENVS`).
+    return exitWithCliError(invalidChoiceError({
+        flag: '--env',
+        value,
+        valid: SYNC_ENVS,
+        subject: 'Ambiente do dev-local',
+        code: 'invalid_env',
+    }), json);
 }
 function envMatches(rowEnv, wanted) {
     const env = (rowEnv ?? '').toLowerCase();
@@ -79,7 +89,7 @@ async function resolveProductForSync(token, opts) {
 }
 async function syncFromCore(cwd, opts) {
     const token = await requireToken(opts.json);
-    const env = normalizeEnv(opts.env);
+    const env = normalizeEnv(opts.env, opts.json);
     const current = resolveDevContext(cwd);
     if (current?.mode === 'prototype' && !opts.product && !opts.productId) {
         log.error('Este projeto está marcado como protótipo local. Use `neetru dev use --product <slug>` para ligar ao Core.');

package/dist/commands/dev-up.d.ts

@@ -1,10 +1,12 @@
 /**
- * `neetru dev up` — ambiente dev-local (banco + agente) via Docker Compose.
+ * `neetru dev up` — banco do produto em container via Docker Compose.
  *
- * Pivô 2026-07 (do emulador Firebase pro emulador de VM): detecta o banco do
- * projeto em `neetru.config.json`, gera `neetru-compose.dev.yml` + `Dockerfile.agent`
- * a partir dos templates embutidos e sobe tudo com `docker compose up -d --wait`.
- * O app SaaS + banco + agente rodam em containers, espelhando a VM de produção.
+ * Detecta o banco do projeto em `neetru.config.json`, gera
+ * `neetru-compose.dev.yml` e sobe com `docker compose up -d --wait`. O app roda
+ * fora do container (`npm run dev`), apontando pra URL que o comando imprime.
+ *
+ * O agente local saiu em 2026-10-09 (nunca chegou a subir — ver o cabeçalho de
+ * `generateComposeDev`); volta quando o agente tiver modo dev de verdade.
  *
  * `runDevExec` (`neetru dev exec`) segue no caminho de emulador Firebase
  * (`firebase emulators:exec`) — é outro comando, pra rodar scripts de CI.

package/dist/commands/dev-up.js

@@ -1,10 +1,12 @@
 /**
- * `neetru dev up` — ambiente dev-local (banco + agente) via Docker Compose.
+ * `neetru dev up` — banco do produto em container via Docker Compose.
  *
- * Pivô 2026-07 (do emulador Firebase pro emulador de VM): detecta o banco do
- * projeto em `neetru.config.json`, gera `neetru-compose.dev.yml` + `Dockerfile.agent`
- * a partir dos templates embutidos e sobe tudo com `docker compose up -d --wait`.
- * O app SaaS + banco + agente rodam em containers, espelhando a VM de produção.
+ * Detecta o banco do projeto em `neetru.config.json`, gera
+ * `neetru-compose.dev.yml` e sobe com `docker compose up -d --wait`. O app roda
+ * fora do container (`npm run dev`), apontando pra URL que o comando imprime.
+ *
+ * O agente local saiu em 2026-10-09 (nunca chegou a subir — ver o cabeçalho de
+ * `generateComposeDev`); volta quando o agente tiver modo dev de verdade.
  *
  * `runDevExec` (`neetru dev exec`) segue no caminho de emulador Firebase
  * (`firebase emulators:exec`) — é outro comando, pra rodar scripts de CI.
@@ -22,7 +24,7 @@ import { log } from '../utils/logger.js';
 import { safeExit, setSafeExitCode } from '../utils/safe-exit.js';
 import { describeDevContext, resolveDevContext, loadLocalProductConfig } from '../lib/dev-local-context.js';
 import { neetruConfigSchema } from '../lib/config-schema.js';
-import { generateComposeDev } from '../lib/compose-generator.js';
+import { generateComposeDev, localDatabaseUrl } from '../lib/compose-generator.js';
 // ---------------------------------------------------------------------------
 // Constantes
 // ---------------------------------------------------------------------------
@@ -187,20 +189,14 @@ export async function runDevUp(opts = {}, deps = buildDevUpDeps()) {
         log.info('  3. Acesse http://localhost:3000');
         return;
     }
-    // ── Produto: gera e sobe Docker Compose com banco + agente ──────────────────
+    // ── Produto: gera e sobe Docker Compose com o banco ─────────────────────────
     const localConfig = loadLocalProductConfig(process.cwd());
     const slug = localConfig?.slug ?? 'app';
-    log.info(`Emulador de VM local — ${chalk.bold(dbEngine)}`);
+    log.info(`Banco local — ${chalk.bold(dbEngine)}`);
     log.dim(`  Produto: ${chalk.bold(slug)}`);
-    // Gera neetru-compose.dev.yml + Dockerfile.agent
     const composePath = path.join(process.cwd(), 'neetru-compose.dev.yml');
     const appPort = opts.corePort ?? 3000;
-    const composeContent = generateComposeDev({
-        productSlug: slug,
-        dbEngine,
-        appPort,
-        coreUrl: devContext?.corePath ? `http://localhost:${opts.corePort ?? 9003}` : 'https://core.neetru.com',
-    });
+    const composeContent = generateComposeDev({ productSlug: slug, dbEngine });
     fsSync.writeFileSync(composePath, composeContent, 'utf8');
     log.info(`Compose gerado: ${chalk.bold('neetru-compose.dev.yml')}`);
     // Sobe com Docker Compose. Detecção cross-platform (antes: paths fixos Unix).
@@ -213,7 +209,7 @@ export async function runDevUp(opts = {}, deps = buildDevUpDeps()) {
         setSafeExitCode(1);
         return;
     }
-    const composeSpinner = ora({ text: 'Subindo containers (banco + agente)…', color: 'blue' }).start();
+    const composeSpinner = ora({ text: 'Subindo o banco…', color: 'blue' }).start();
     try {
         // Docker Compose up — síncrono, espera healthy
         const { execSync } = await import('node:child_process');
@@ -222,16 +218,21 @@ export async function runDevUp(opts = {}, deps = buildDevUpDeps()) {
             stdio: 'pipe',
             timeout: 120_000,
         });
-        composeSpinner.succeed('Containers prontos');
+        composeSpinner.succeed('Banco pronto');
+        const dbUrl = localDatabaseUrl(dbEngine);
         log.info('');
-        log.info(chalk.bold.green('✓ Ambiente dev-local ativo!'));
-        log.info(`  App SaaS:   http://localhost:${appPort}`);
-        log.info(`  Banco:      ${dbEngine} (porta local padrão)`);
-        log.info(`  Agente:     conectado ao Core`);
+        log.info(chalk.bold.green('✓ Banco local ativo!'));
+        log.info(`  Banco:      ${dbEngine}`);
+        if (dbUrl)
+            log.info(`  Conexão:    ${dbUrl}`);
+        log.info('');
+        log.info(chalk.bold('Próximos passos:'));
+        if (dbUrl)
+            log.info('  1. Use a conexão acima como DATABASE_URL no .env.local');
+        log.info(`  ${dbUrl ? '2' : '1'}. Rode \`npm run dev\` e acesse http://localhost:${appPort}`);
         log.info('');
         log.dim('  Rode `docker compose -f neetru-compose.dev.yml down` para parar.');
-        log.dim(`  Rode \`neetru deploy --target vm --server dev-local-${slug}\` para deployar.`);
-        log.dim('  O agente vai receber o bundle, npm install, e subir o app automaticamente.');
+        log.dim('  O agente local ainda não existe: deploy e migração pelo agente só na VM.');
     }
     catch (err) {
         composeSpinner.fail('Docker Compose falhou.');

package/dist/commands/docs-produto.d.ts

@@ -0,0 +1,90 @@
+import { type CheckResult } from '../lib/product-docs/check.js';
+import { type InitDocsResult } from '../lib/product-docs/ops.js';
+import { type SyncResult } from '../lib/product-docs/sync.js';
+import { NeetruCliError } from '../cli-kit/errors.js';
+export interface DocsInitOptions {
+    comApi?: boolean;
+    migrar?: boolean;
+    dryRun?: boolean;
+    json?: boolean;
+}
+export declare function runDocsInit(opts: DocsInitOptions): Promise<void>;
+/**
+ * Chamado por `neetru init`/`neetru new` depois do scaffold. Nunca derruba o
+ * comando chamador: erro vira aviso.
+ */
+export declare function initDocsAfterScaffold(dir: string, opts?: {
+    quiet?: boolean;
+}): Promise<InitDocsResult | null>;
+export interface DocsNewOptions {
+    categoria?: string;
+    subcategoria?: string;
+    audience?: string;
+    descricao?: string;
+    data?: string;
+    dryRun?: boolean;
+    json?: boolean;
+}
+export declare function runDocsNew(tipo: string, titulo: string, opts: DocsNewOptions): Promise<void>;
+export interface DocsCheckOptions {
+    changed?: boolean;
+    strict?: boolean;
+    offline?: boolean;
+    json?: boolean;
+}
+export declare function runDocsCheck(opts: DocsCheckOptions): Promise<void>;
+export interface DocsSyncOptions {
+    dryRun?: boolean;
+    offline?: boolean;
+    json?: boolean;
+}
+/**
+ * As falhas de envio como UM erro tipado com filhos (P105 / bug_89d2497e,
+ * etapa 3 aplicada ao `docs sync`). Com docs que deram certo (enviados ou já
+ * iguais no Core) a falha se reporta como PARCIAL — no texto ("Falha parcial:
+ * 1 de 3 itens falharam") e no JSON (`partial`, `succeeded`, `failed`,
+ * `children`) — e sai com o código do filho mais grave. `null` sem falhas.
+ */
+export declare function erroDeSyncComFalhas(r: SyncResult): NeetruCliError | null;
+/** O desfecho do `docs sync`, o MESMO para a saída humana e o `--json`. */
+export interface DesfechoDoSync {
+    ok: boolean;
+    exit: number;
+    /** As falhas de envio como erro tipado, ou `null` sem falhas. */
+    erro: NeetruCliError | null;
+}
+/**
+ * Uma regra só para os dois modos (revisão do #87, BAIXO 2). Qualquer doc que
+ * falhou no envio faz o comando falhar com o código do filho mais grave —
+ * MESMO que o lote termine num status informativo (`core-sem-suporte` no meio
+ * do lote: o doc 1 tomou 500 e o doc 2 tomou 405). Antes a saída humana
+ * escondia a falha e saía 0 enquanto o `--json` saía 4. Sem falhas de envio,
+ * vale a regra de sempre: status de `SYNC_FAILURE` sai 1, o resto sai 0.
+ */
+export declare function desfechoDoSync(r: SyncResult): DesfechoDoSync;
+export declare function runDocsSync(opts: DocsSyncOptions): Promise<void>;
+export interface DeployDocsPrecheck {
+    ran: boolean;
+    ok?: boolean;
+    counts?: CheckResult['counts'];
+    /** Itens do mínimo do primeiro dia / CHANGELOG que faltam (PR002/PR004). */
+    diaUm?: string[];
+    error?: string;
+}
+/**
+ * Antes do deploy: roda `docs check` e SÓ AVISA (decisão do dono 2026-10-03).
+ * Nunca lança, nunca encerra o processo.
+ */
+export declare function deployDocsPrecheck(cwd: string, envName: string, json?: boolean): Promise<DeployDocsPrecheck>;
+export interface DeployDocsSync {
+    attempted: boolean;
+    reason?: string;
+    status?: SyncResult['status'];
+    message?: string;
+    enviados?: number;
+}
+/**
+ * Depois de um deploy de PRODUÇÃO bem-sucedido: publica os docs se
+ * `docs.publishOnDeploy` estiver ligado. Falha aqui NUNCA derruba o deploy.
+ */
+export declare function deployDocsPostSync(cwd: string, envName: string, json?: boolean): Promise<DeployDocsSync>;

package/dist/commands/docs-produto.js

@@ -0,0 +1,384 @@
+/**
+ * `neetru docs init | new | check | sync` — documentação do PRODUTO SaaS
+ * (PROTOCOLO_DOCS_PRODUTOS_SAAS v1, 2026-10-03).
+ *
+ * Os outros subcomandos de `neetru docs` (open/publish/list/get/delete) são o
+ * control plane dos docs do CORE e ficam em `docs.ts`.
+ *
+ * Decisões do dono (2026-10-03):
+ *   - `neetru deploy` só AVISA sobre docs — nunca bloqueia.
+ *   - Publicar no Core é opcional: `docs.publishOnDeploy: true` (deploy de
+ *     produção publica no fim) ou manual com `neetru docs sync`.
+ *   - `docs init --migrar` não move nem renomeia nada.
+ */
+import chalk from 'chalk';
+import { log } from '../utils/logger.js';
+import { safeExit } from '../utils/safe-exit.js';
+import { loadProductRepo, ProductConfigInvalidError, ProductConfigMissingError, } from '../lib/product-docs/config.js';
+import { checkProductDocs } from '../lib/product-docs/check.js';
+import { resolveTaxonomy } from '../lib/product-docs/taxonomy.js';
+import { createProductDoc, DocsNewError, initProductDocs, migrateProductDocs, } from '../lib/product-docs/ops.js';
+import { syncProductDocs } from '../lib/product-docs/sync.js';
+import { NeetruCliError } from '../cli-kit/errors.js';
+import { CliApiError, CliNetworkError } from '../lib/api-client.js';
+import { cliErrorFromApiError } from '../lib/api-error.js';
+import { exitWithCliError } from '../lib/cli-error.js';
+function fail(json, code, message) {
+    if (json)
+        console.log(JSON.stringify({ ok: false, error: code, message }));
+    else
+        log.error(message);
+    safeExit(1);
+}
+async function loadRepoOrExit(json, cwd = process.cwd()) {
+    try {
+        return await loadProductRepo(cwd);
+    }
+    catch (e) {
+        if (e instanceof ProductConfigMissingError)
+            fail(json, 'no_product_config', e.message);
+        if (e instanceof ProductConfigInvalidError)
+            fail(json, 'invalid_product_config', e.message);
+        throw e;
+    }
+}
+function printInit(r) {
+    const verb = r.dryRun ? 'Criaria' : 'Criado';
+    if (r.configKeysAdded.length)
+        log.success(`neetru.config.json: chave docs (${r.configKeysAdded.join(', ')})${r.dryRun ? ' — simulação' : ''}.`);
+    if (r.folders.length)
+        log.dim(`  ${r.dryRun ? 'Pastas que seriam criadas' : 'Pastas criadas'}: ${r.folders.length}`);
+    for (const f of r.created)
+        log.success(`${verb}: ${f}`);
+    if (r.skipped.length)
+        log.dim(`  Já existiam (não mexi): ${r.skipped.join(', ')}`);
+    if (!r.created.length && !r.folders.length && !r.configKeysAdded.length)
+        log.info('Nada a fazer: o mínimo do primeiro dia já existe.');
+    if (!r.withApi)
+        log.dim('  API_V1.md só entra com --com-api (ou quando o produto declara app móvel/integração).');
+}
+export async function runDocsInit(opts) {
+    const repo = await loadRepoOrExit(opts.json);
+    if (opts.migrar) {
+        const { taxonomy } = await resolveTaxonomy({ offline: true });
+        const r = await migrateProductDocs(repo, { dryRun: opts.dryRun, taxonomy });
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: true, mode: 'migrar', ...r }));
+            return;
+        }
+        log.heading(`Migração dos docs de ${repo.slug}${r.dryRun ? ' (simulação — nada foi escrito)' : ''}`);
+        const added = r.files.filter((f) => f.acao === 'frontmatter-adicionado');
+        log.info(`${r.files.length} arquivo(s) analisado(s); frontmatter ${r.dryRun ? 'seria acrescentado' : 'acrescentado'} em ${added.length}.`);
+        const kept = r.files.filter((f) => f.acao !== 'frontmatter-adicionado');
+        if (kept.length)
+            log.dim(`  ${kept.length} já tinham frontmatter e ficaram intocados.`);
+        const low = added.reduce((n, f) => n + f.inferencias.filter((i) => i.confianca === 'baixa').length, 0);
+        if (low)
+            log.warn(`${low} inferência(s) de confiança baixa — revise no relatório.`);
+        const moves = r.files.filter((f) => f.sugestaoDestino).length;
+        if (moves)
+            log.info(`${moves} arquivo(s) com sugestão de novo lugar (nada foi movido).`);
+        if (r.legacyNamesFile) {
+            log.info(r.legacyNamesFile.created
+                ? `${r.legacyNamesFile.path}: ${r.legacyNamesFile.count} nome(s) fora da regra tolerados.`
+                : `${r.legacyNamesFile.path} já existia — não foi alterado.`);
+        }
+        if (r.reportPath)
+            log.success(`Relatório: ${r.reportPath}`);
+        if (r.faltandoPrimeiroDia.length) {
+            log.dim(`  Falta do mínimo do primeiro dia: ${r.faltandoPrimeiroDia.join(', ')}.`);
+            log.dim('  Depois de mover os arquivos, rode `neetru docs init` (sem --migrar) para criar o que falta.');
+        }
+        log.dim('  Próximo passo: revisar o relatório, mover num PR à parte, `neetru docs check`.');
+        return;
+    }
+    const r = await initProductDocs(repo, { comApi: opts.comApi, dryRun: opts.dryRun });
+    if (opts.json) {
+        console.log(JSON.stringify({ ok: true, mode: 'init', ...r }));
+        return;
+    }
+    log.heading(`Docs de ${repo.slug}${r.dryRun ? ' (simulação — nada foi escrito)' : ''}`);
+    printInit(r);
+    log.dim('  Próximos passos: completar os rascunhos, `neetru docs check`.');
+}
+/**
+ * Chamado por `neetru init`/`neetru new` depois do scaffold. Nunca derruba o
+ * comando chamador: erro vira aviso.
+ */
+export async function initDocsAfterScaffold(dir, opts = {}) {
+    try {
+        const repo = await loadProductRepo(dir);
+        const r = await initProductDocs(repo);
+        if (!opts.quiet) {
+            log.info(`Docs: ${r.created.length} arquivo(s) do mínimo do primeiro dia criados em ${r.docsRoot}/ (\`neetru docs check\` confere).`);
+        }
+        return r;
+    }
+    catch (e) {
+        if (!opts.quiet)
+            log.warn(`Não deu para criar os docs (${e.message}). Rode \`neetru docs init\` depois.`);
+        return null;
+    }
+}
+export async function runDocsNew(tipo, titulo, opts) {
+    const repo = await loadRepoOrExit(opts.json);
+    try {
+        const r = await createProductDoc(repo, tipo, titulo, opts);
+        if (opts.json) {
+            const { content: _content, ...rest } = r;
+            console.log(JSON.stringify({ ok: true, ...rest }));
+            return;
+        }
+        log.success(`${r.dryRun ? 'Criaria' : 'Criado'}: ${chalk.bold(r.path)}`);
+        log.dim(`  tipo=${r.type} · ${r.category}/${r.subcategory} · audience=${r.audience} · status=${r.status}`);
+        if (r.categoriaPadrao)
+            log.dim('  Categoria padrão da pasta — ajuste com --categoria/--subcategoria se o assunto for outro.');
+        if (!opts.descricao)
+            log.dim('  Troque a `description` provisória por uma frase sua (ou use --descricao).');
+    }
+    catch (e) {
+        if (e instanceof DocsNewError)
+            fail(opts.json, e.code, e.message);
+        throw e;
+    }
+}
+const LEVEL_LABEL = { erro: 'erro', aviso: 'aviso', sugestao: 'sugestão' };
+function printFindings(res, maxPerLevel = Infinity) {
+    const byFile = new Map();
+    for (const f of res.findings) {
+        if (!byFile.has(f.file))
+            byFile.set(f.file, []);
+        byFile.get(f.file).push(f);
+    }
+    let shown = 0;
+    for (const [file, list] of byFile) {
+        if (shown >= maxPerLevel)
+            break;
+        console.log(`\n  ${chalk.bold(file)}`);
+        for (const f of list) {
+            const color = f.level === 'erro' ? chalk.red : f.level === 'aviso' ? chalk.yellow : chalk.dim;
+            console.log(`    ${color(`${f.code} ${LEVEL_LABEL[f.level]}`)}${f.line ? chalk.dim(` :${f.line}`) : ''}  ${f.message}`);
+            shown++;
+        }
+    }
+}
+export async function runDocsCheck(opts) {
+    const repo = await loadRepoOrExit(opts.json);
+    const tax = await resolveTaxonomy({ offline: opts.offline });
+    const res = await checkProductDocs(repo, { changed: opts.changed, strict: opts.strict, taxonomy: tax.taxonomy });
+    if (opts.json) {
+        console.log(JSON.stringify({
+            ok: res.ok,
+            product: repo.slug,
+            counts: res.counts,
+            filesChecked: res.filesChecked,
+            changed: !!opts.changed,
+            changedBase: res.changedBase ?? null,
+            changedFallback: !!res.changedFallback,
+            strict: !!opts.strict,
+            taxonomy: { source: tax.source, protocolVersion: tax.taxonomy.protocolVersion, aviso: tax.aviso ?? null },
+            findings: res.findings,
+        }));
+        if (!res.ok)
+            safeExit(1);
+        return;
+    }
+    log.heading(`Docs de ${repo.slug}${opts.changed ? ' (só os alterados)' : ''}`);
+    if (tax.aviso)
+        log.warn(tax.aviso);
+    if (res.changedFallback)
+        log.warn('Não deu para descobrir os arquivos alterados (sem git ou sem a branch principal) — chequei todos.');
+    if (res.findings.length)
+        printFindings(res);
+    console.log();
+    const summary = `${res.filesChecked} doc(s) · ${res.counts.erro} erro(s) · ${res.counts.aviso} aviso(s) · ${res.counts.sugestao} sugestão(ões)`;
+    log.dim(`  taxonomia ${tax.source === 'core' ? 'do Core' : 'embutida'} (protocolo v${tax.taxonomy.protocolVersion})`);
+    if (res.ok) {
+        log.success(summary);
+    }
+    else {
+        log.error(summary + (opts.strict && res.counts.erro === 0 ? ' — --strict trata aviso como erro' : ''));
+        safeExit(1);
+    }
+}
+function printSync(r) {
+    for (const e of r.enviados) {
+        log.success(`${r.dryRun ? 'Enviaria' : 'Enviado'}: ${e.slug}${e.version ? ` (v${e.version})` : ''}${e.visibility === 'public' ? chalk.dim(' · público') : ''}`);
+    }
+    if (r.inalterados.length)
+        log.dim(`  Sem mudança: ${r.inalterados.length}`);
+    for (const b of r.bloqueados)
+        log.warn(`Não enviado (erro no check: ${b.codes.join(', ')}): ${b.file}`);
+    for (const x of r.recusados)
+        log.warn(`Não pode subir: ${x.file} — ${x.motivo}.`);
+    // As falhas de envio saem no erro tipado (`erroDeSyncComFalhas`), uma vez só.
+    if (r.orfaos.length) {
+        log.warn(`${r.orfaos.length} doc(s) existem no Core mas não no repositório (nada foi apagado): ${r.orfaos.join(', ')}`);
+        log.dim('  A remoção de docs de produto ainda não existe no Core — eles continuam lá até o Core oferecer isso.');
+    }
+}
+/** Status de sync que contam como falha do comando `neetru docs sync`. */
+const SYNC_FAILURE = ['parcial', 'sem-login', 'limite-excedido', 'produto-nao-encontrado', 'falha'];
+/**
+ * Código de saída de um doc que o Core recusou: a MESMA tabela do
+ * `handleApiError` (401→2, 403→3, outro 4xx→1, 5xx e sem resposta→4), lida do
+ * próprio `cliErrorFromApiError` em vez de copiada.
+ */
+function exitDaFalha(httpStatus) {
+    const erro = httpStatus > 0 ? new CliApiError(httpStatus, 'docs_sync', '') : new CliNetworkError('');
+    return cliErrorFromApiError(erro).exit;
+}
+/**
+ * As falhas de envio como UM erro tipado com filhos (P105 / bug_89d2497e,
+ * etapa 3 aplicada ao `docs sync`). Com docs que deram certo (enviados ou já
+ * iguais no Core) a falha se reporta como PARCIAL — no texto ("Falha parcial:
+ * 1 de 3 itens falharam") e no JSON (`partial`, `succeeded`, `failed`,
+ * `children`) — e sai com o código do filho mais grave. `null` sem falhas.
+ */
+export function erroDeSyncComFalhas(r) {
+    if (r.falhas.length === 0)
+        return null;
+    const children = r.falhas.map((f) => new NeetruCliError(f.message, {
+        code: f.httpStatus > 0 ? `http_${f.httpStatus}` : 'sem_resposta',
+        exit: exitDaFalha(f.httpStatus),
+        details: { slug: f.slug, httpStatus: f.httpStatus },
+        human: `Falha em ${f.slug}: ${f.message}`,
+    }));
+    return new NeetruCliError(r.message, {
+        code: r.status === 'parcial' ? 'docs_sync_parcial' : 'docs_sync_falha',
+        children,
+        succeeded: r.enviados.length + r.inalterados.length,
+    });
+}
+/**
+ * Uma regra só para os dois modos (revisão do #87, BAIXO 2). Qualquer doc que
+ * falhou no envio faz o comando falhar com o código do filho mais grave —
+ * MESMO que o lote termine num status informativo (`core-sem-suporte` no meio
+ * do lote: o doc 1 tomou 500 e o doc 2 tomou 405). Antes a saída humana
+ * escondia a falha e saía 0 enquanto o `--json` saía 4. Sem falhas de envio,
+ * vale a regra de sempre: status de `SYNC_FAILURE` sai 1, o resto sai 0.
+ */
+export function desfechoDoSync(r) {
+    const erro = erroDeSyncComFalhas(r);
+    if (erro)
+        return { ok: false, exit: erro.exit, erro };
+    const failed = SYNC_FAILURE.includes(r.status);
+    return { ok: !failed, exit: failed ? 1 : 0, erro: null };
+}
+export async function runDocsSync(opts) {
+    const repo = await loadRepoOrExit(opts.json);
+    const tax = await resolveTaxonomy({ offline: opts.offline });
+    const r = await syncProductDocs(repo, {
+        taxonomy: tax.taxonomy,
+        dryRun: opts.dryRun,
+        onWait: opts.json
+            ? undefined
+            : (ms, motivo) => log.dim(`  ${motivo === 'ritmo' ? 'Respeitando o limite de envios do Core' : 'O Core pediu para esperar'}: aguardando ${Math.ceil(ms / 1000)} s…`),
+    });
+    const desfecho = desfechoDoSync(r);
+    if (opts.json) {
+        // O resultado inteiro de antes e, com falhas de envio, o agregado do erro
+        // tipado (`error`, `partial`, `succeeded`, `failed`, `children`).
+        let agregado = {};
+        if (desfecho.erro) {
+            const { ok: _ok, ...resto } = desfecho.erro.toJSON();
+            agregado = resto;
+        }
+        console.log(JSON.stringify({ ok: desfecho.ok, ...r, ...agregado }));
+        if (desfecho.exit !== 0)
+            safeExit(desfecho.exit);
+        return;
+    }
+    log.heading(`Publicar docs de ${repo.slug} no Core${r.dryRun ? ' (simulação)' : ''}`);
+    printSync(r);
+    if (desfecho.erro) {
+        // O cabeçalho é a mensagem do status (inclusive o "Core sem suporte"); as
+        // falhas de envio vêm logo abaixo, uma por doc — nunca somem.
+        exitWithCliError(desfecho.erro, false);
+        return;
+    }
+    if (r.status === 'core-sem-suporte' || r.status === 'desligado' || r.status === 'nada-a-enviar') {
+        log.info(r.message);
+        return;
+    }
+    if (desfecho.exit !== 0) {
+        log.error(r.message);
+        safeExit(desfecho.exit);
+    }
+    log.success(r.message);
+}
+/**
+ * Antes do deploy: roda `docs check` e SÓ AVISA (decisão do dono 2026-10-03).
+ * Nunca lança, nunca encerra o processo.
+ */
+export async function deployDocsPrecheck(cwd, envName, json) {
+    let repo;
+    try {
+        repo = await loadProductRepo(cwd);
+    }
+    catch {
+        return { ran: false };
+    }
+    try {
+        const tax = await resolveTaxonomy({ offline: true });
+        const res = await checkProductDocs(repo, { taxonomy: tax.taxonomy });
+        const diaUm = res.findings
+            .filter((f) => (f.code === 'PR002' || f.code === 'PR004') && f.level !== 'sugestao')
+            .map((f) => f.message);
+        if (!json) {
+            const prod = envName === 'prod' || envName === 'production';
+            if (res.counts.erro || res.counts.aviso) {
+                log.warn(`Docs: ${res.counts.erro} erro(s) e ${res.counts.aviso} aviso(s) — o deploy segue; rode \`neetru docs check\` para ver.`);
+                if (prod && diaUm.length) {
+                    log.warn('Docs: falta o mínimo do primeiro dia para produção:');
+                    for (const m of diaUm.slice(0, 6))
+                        log.dim(`    · ${m}`);
+                }
+            }
+            else {
+                log.dim('  Docs: check sem erros.');
+            }
+        }
+        return { ran: true, ok: res.ok, counts: res.counts, diaUm };
+    }
+    catch (e) {
+        return { ran: false, error: e.message };
+    }
+}
+/**
+ * Depois de um deploy de PRODUÇÃO bem-sucedido: publica os docs se
+ * `docs.publishOnDeploy` estiver ligado. Falha aqui NUNCA derruba o deploy.
+ */
+export async function deployDocsPostSync(cwd, envName, json) {
+    const prod = envName === 'prod' || envName === 'production';
+    if (!prod)
+        return { attempted: false, reason: 'nao-producao' };
+    let repo;
+    try {
+        repo = await loadProductRepo(cwd);
+    }
+    catch {
+        return { attempted: false, reason: 'sem-config' };
+    }
+    if (!repo.docs.publishOnDeploy)
+        return { attempted: false, reason: 'publishOnDeploy-desligado' };
+    try {
+        const tax = await resolveTaxonomy({ offline: true });
+        const r = await syncProductDocs(repo, { taxonomy: tax.taxonomy });
+        if (!json) {
+            if (r.status === 'ok')
+                log.success(`Docs publicados no Core: ${r.message}`);
+            else if (r.status === 'core-sem-suporte' || r.status === 'nada-a-enviar' || r.status === 'desligado')
+                log.info(`Docs: ${r.message}`);
+            else
+                log.warn(`Docs não publicados (${r.message}) — o deploy está OK; tente \`neetru docs sync\`.`);
+        }
+        return { attempted: true, status: r.status, message: r.message, enviados: r.enviados.length };
+    }
+    catch (e) {
+        if (!json)
+            log.warn(`Docs não publicados (${e.message}) — o deploy está OK; tente \`neetru docs sync\`.`);
+        return { attempted: true, status: 'falha', message: e.message };
+    }
+}
+//# sourceMappingURL=docs-produto.js.map