@neetru/cli 2.31.0 → 2.32.0

package/dist/cli-kit/errors.js

@@ -0,0 +1,94 @@
+/**
+ * Erro tipado da CLI (bug_89d2497e, etapa 3).
+ *
+ * Antes cada comando decidia sozinho como morrer: montava a mensagem à mão,
+ * escolhia um `safeExit(n)` e, em `--json`, um formato de payload. O modelo é o
+ * `FirebaseError` do firebase-tools (`lib/error.js`): o erro carrega o código
+ * de saída, a causa original e os filhos agregados — e quem imprime/encerra é
+ * um ponto só (`exitWithCliError`, em `src/lib/cli-error.ts`).
+ *
+ * Função pura: nada aqui imprime nem encerra o processo. O cli-kit continua sem
+ * dependência de logger/process — quem decide a saída é o call site.
+ */
+/**
+ * Convenção ÚNICA de códigos de saída (a mesma do `handleApiError` desde a
+ * auditoria de 2026-06-20 — ver `src/lib/api-error.ts`):
+ *   1 — erro do cliente (entrada/recurso: 400, 404, 409, 422, validação)
+ *   2 — não autenticado (401)
+ *   3 — sem permissão (403)
+ *   4 — erro do servidor (5xx), rede ou desconhecido
+ */
+export const EXIT_CODES = {
+    client: 1,
+    unauthenticated: 2,
+    forbidden: 3,
+    server: 4,
+};
+export class NeetruCliError extends Error {
+    code;
+    exit;
+    children;
+    succeeded;
+    details;
+    human;
+    constructor(message, opts = {}) {
+        super(message, opts.cause !== undefined ? { cause: opts.cause } : undefined);
+        this.name = 'NeetruCliError';
+        this.code = opts.code ?? 'cli_error';
+        this.children = [...(opts.children ?? [])];
+        this.succeeded = Math.max(0, opts.succeeded ?? 0);
+        this.details = { ...(opts.details ?? {}) };
+        this.human = opts.human ?? message;
+        this.exit =
+            opts.exit ??
+                (this.children.length > 0
+                    ? Math.max(...this.children.map((c) => c.exit))
+                    : EXIT_CODES.client);
+    }
+    /** Falha parcial: parte do lote falhou e parte deu certo. */
+    get partial() {
+        return this.children.length > 0 && this.succeeded > 0;
+    }
+    /**
+     * Payload `--json`. Sem filhos, é exatamente `{ ok:false, error, ...details,
+     * message }` — o formato que os comandos já emitiam. Com filhos, acrescenta
+     * `partial`, `succeeded`, `failed` e `children`.
+     */
+    toJSON() {
+        return { ok: false, ...this.corpoJson() };
+    }
+    corpoJson() {
+        const base = {
+            error: this.code,
+            ...this.details,
+            message: this.message,
+        };
+        if (this.children.length === 0)
+            return base;
+        return {
+            ...base,
+            partial: this.partial,
+            succeeded: this.succeeded,
+            failed: this.children.length,
+            children: this.children.map((c) => c.corpoJson()),
+        };
+    }
+}
+export function isNeetruCliError(x) {
+    return x instanceof NeetruCliError;
+}
+/**
+ * Texto humano completo do erro, com os filhos indentados. Uma falha parcial
+ * diz que é parcial e quanto deu certo.
+ */
+export function renderCliError(error) {
+    if (error.children.length === 0)
+        return error.human;
+    const falhas = error.children.length;
+    const resumo = error.partial
+        ? `Falha parcial: ${falhas} de ${falhas + error.succeeded} itens falharam (${error.succeeded} deram certo).`
+        : `${falhas} ${falhas === 1 ? 'item falhou' : 'itens falharam'}.`;
+    const filhos = error.children.map((c) => `  - ${renderCliError(c).split('\n').join('\n    ')}`);
+    return [error.human, `  ${resumo}`, ...filhos].join('\n');
+}
+//# sourceMappingURL=errors.js.map

package/dist/cli-kit/index.d.ts

@@ -11,3 +11,11 @@ export type { Glyphs } from './glyphs.js';
 export { ok, err, warn, dim, heading } from './palette.js';
 export { step, errorBlock, sacredPause, } from './format.js';
 export type { ErrorBlockOpts, SacredPauseOpts } from './format.js';
+export { EXIT_CODES, NeetruCliError, isNeetruCliError, renderCliError } from './errors.js';
+export type { NeetruCliErrorOptions } from './errors.js';
+export { invalidChoiceError, formatChoices } from './choices.js';
+export type { InvalidChoiceInput } from './choices.js';
+export { installCommandContext, setCurrentCommand, getCurrentCommand, setRootCommand, getRootCommand, commandDeclaresFlag, commandDeclaresInput, declaredFlags, declaredInputs, commandExists, adviseFlag, adviseCommand, } from './command-context.js';
+export type { FlagAdvice, CommandAdvice } from './command-context.js';
+export { SYNONYMS, MIN_RATIO, MAX_SUGGESTIONS, isSubcommandVerb, wordScore, scoreCandidates, suggestCommands, suggestSubcommands, reservedVerbError, } from './suggest.js';
+export type { ReservedVerbInput } from './suggest.js';

package/dist/cli-kit/index.js

@@ -9,4 +9,12 @@
 export { GLYPHS } from './glyphs.js';
 export { ok, err, warn, dim, heading } from './palette.js';
 export { step, errorBlock, sacredPause, } from './format.js';
+// Camada de CORREÇÃO (bug_89d2497e): erro tipado, conselho validado contra o
+// comando em execução e valores válidos de enum vindos da fonte real.
+export { EXIT_CODES, NeetruCliError, isNeetruCliError, renderCliError } from './errors.js';
+export { invalidChoiceError, formatChoices } from './choices.js';
+export { installCommandContext, setCurrentCommand, getCurrentCommand, setRootCommand, getRootCommand, commandDeclaresFlag, commandDeclaresInput, declaredFlags, declaredInputs, commandExists, adviseFlag, adviseCommand, } from './command-context.js';
+// P105: verbo de subcomando nunca é valor livre; sugestão com piso de qualidade
+// (SYNONYMS + MIN_RATIO, o `suggest_commands` do gcloud).
+export { SYNONYMS, MIN_RATIO, MAX_SUGGESTIONS, isSubcommandVerb, wordScore, scoreCandidates, suggestCommands, suggestSubcommands, reservedVerbError, } from './suggest.js';
 //# sourceMappingURL=index.js.map

package/dist/cli-kit/suggest.d.ts

@@ -0,0 +1,74 @@
+import { NeetruCliError } from './errors.js';
+/** Verbo digitado → verbo(s) que a CLI usa. */
+export declare const SYNONYMS: Readonly<Record<string, readonly string[]>>;
+/** Mínimo da razão pontuação/pontuação-do-primeiro para entrar na sugestão. */
+export declare const MIN_RATIO = 0.7;
+/** No máximo isto de sugestões. */
+export declare const MAX_SUGGESTIONS = 10;
+/**
+ * A palavra é, de fato, verbo de subcomando DESTE comando? Sim quando é um dos
+ * subcomandos dados (nome ou apelido) ou um sinônimo (`SYNONYMS`) de um deles.
+ * Sem diferenciar caixa, sem espaços nas pontas.
+ *
+ * Revisão do #87 (BAIXO 6): a 1ª versão recusava uma lista GLOBAL de verbos em
+ * qualquer texto livre, e `neetru chat send show` (resposta comum em PT-BR)
+ * passou a ser recusado sem que `show` fosse subcomando de `chat`. A recusa
+ * agora depende dos subcomandos de verdade de quem pergunta: para `chat send`,
+ * só `channels`, `identity`/`apelido`, `send` e `history`; para
+ * `chat identity`, os verbos dele (`show`, `set`, `clear`…) e seus sinônimos.
+ */
+export declare function isSubcommandVerb(word: string, subcommands: readonly string[]): boolean;
+/**
+ * Pontuação de uma palavra digitada contra uma palavra de um comando — o
+ * `_WordScore` do gcloud, linha a linha. Sempre ≥ 0; zero = sem relação.
+ */
+export declare function wordScore(index: number, word: string, canonical: string, canonicalLength: number): number;
+/**
+ * Candidatos pontuados, do maior para o menor (empate: ordem lexicográfica).
+ * Só entra quem pontua > 0. Cada candidato é a lista de palavras do comando.
+ */
+export declare function scoreCandidates(words: readonly string[], candidates: ReadonlyArray<readonly string[]>): Array<{
+    command: readonly string[];
+    score: number;
+}>;
+/**
+ * Comandos sugeridos para as palavras digitadas — o `GetCommandSuggestions`
+ * do gcloud: só quem pontua > 0 e faz pelo menos `MIN_RATIO` da pontuação do
+ * primeiro, no máximo `MAX_SUGGESTIONS`. Vazio quando nada pontua.
+ */
+export declare function suggestCommands(words: readonly string[], candidates: ReadonlyArray<readonly string[]>): string[];
+/**
+ * Sugestões para a palavra digitada, entre os subcomandos dados. Vazio quando
+ * nada passa o piso — aí quem chama lista as escolhas, nunca chuta.
+ */
+export declare function suggestSubcommands(word: string, subcommands: readonly string[]): string[];
+export interface ReservedVerbInput {
+    /** O verbo recebido como valor, como a pessoa digitou. */
+    verb: string;
+    /** O comando onde ele chegou, sem o `neetru` (ex.: `'chat identity'`). */
+    command: string;
+    /**
+     * O comando cujos subcomandos são sugeridos, sem o `neetru`. Padrão:
+     * `command`. Ex.: a palavra chega em `chat send`, e os subcomandos são de `chat`.
+     */
+    parent?: string;
+    /** O que o comando esperava naquela posição (ex.: `'um apelido'`). */
+    what: string;
+    /**
+     * Os subcomandos/verbos que o comando aceita — a MESMA lista que ele usa
+     * para decidir. Vazio = sem sugestão possível (só a recusa).
+     */
+    subcommands: readonly string[];
+    /** Apelido → nome do subcomando (ex.: `apelido → identity`): a sugestão vai direto ao nome. */
+    aliases?: Readonly<Record<string, string>>;
+    /** Como passar a mesma palavra como texto, quando existe jeito. */
+    escapeHint?: string;
+    /** Código do JSON. Padrão: `'uso_invalido'`. */
+    code?: string;
+}
+/**
+ * Recusa um verbo usado como valor e sugere o subcomando certo — ou, sem
+ * sugestão que passe o piso, lista as escolhas. Exit 1 (erro do cliente). No
+ * JSON: `value`, `suggestions` (comandos completos) e `valid`.
+ */
+export declare function reservedVerbError(input: ReservedVerbInput): NeetruCliError;

package/dist/cli-kit/suggest.js

@@ -0,0 +1,207 @@
+/**
+ * Verbo de subcomando nunca é valor livre, e sugestão só com piso de qualidade
+ * (P105 / bug_89d2497e; o caso que nasceu daqui foi o bug_09574d4b).
+ *
+ * O bug: `neetru chat identity show` GRAVOU o apelido "show", e
+ * `identity set "X"` gravou "set". O comando recebia texto livre posicional e
+ * aceitava qualquer palavra — inclusive o verbo que a pessoa usou achando que
+ * era subcomando. O gcloud não teria aceitado essa string: ele sabe quais
+ * palavras são verbos e, quando a palavra não é escolha válida, sugere o
+ * comando certo ou lista as escolhas — nunca adivinha lixo.
+ *
+ * O MODELO é o `calliope/suggest_commands.py` do gcloud (lido no SDK instalado
+ * nesta máquina, `google-cloud-sdk/lib/googlecloudsdk/calliope`):
+ *  - `SYNONYMS`: verbo digitado → verbo que a CLI de fato usa. O gcloud mapeia
+ *    para os verbos DELE (`show → describe`); aqui o mapa aponta para os nossos
+ *    (`describe → show`), e um verbo pode ter mais de um correspondente.
+ *  - `_WordScore`: só pontua quando uma palavra CONTÉM a outra, e só em começo
+ *    de palavra (ou depois de `-`). Sem relação de texto, a pontuação é zero e
+ *    o candidato some. É esse o piso absoluto: nada de distância de edição, que
+ *    acha "parecido" em qualquer par de palavras curtas.
+ *  - `MIN_RATIO = 0.7`: entre os que pontuam, só entra quem faz pelo menos 70%
+ *    da pontuação do primeiro. `MAX_SUGGESTIONS = 10`.
+ *  - O histórico de uso do usuário (`_GetSurfaceHistoryFrequencies`) NÃO foi
+ *    portado: a CLI não guarda histórico de comandos, e inventar um seria pior
+ *    que não ranquear por ele.
+ *
+ * Quando nada passa o piso, quem chama LISTA as escolhas válidas (o gcloud faz
+ * o mesmo em erro de argumento, `parser_extensions.py`) em vez de sugerir.
+ */
+import { formatChoices } from './choices.js';
+import { EXIT_CODES, NeetruCliError } from './errors.js';
+/** Verbo digitado → verbo(s) que a CLI usa. */
+export const SYNONYMS = {
+    describe: ['show', 'get'],
+    get: ['show', 'describe'],
+    show: ['describe', 'get'],
+    view: ['show'],
+    ver: ['show'],
+    list: ['show'],
+    update: ['set'],
+    modify: ['set', 'update'],
+    patch: ['set', 'update'],
+    change: ['set', 'update'],
+    definir: ['set'],
+    unset: ['clear'],
+    remove: ['clear', 'delete'],
+    delete: ['clear', 'remove'],
+    reset: ['clear'],
+    limpar: ['clear'],
+};
+/** Mínimo da razão pontuação/pontuação-do-primeiro para entrar na sugestão. */
+export const MIN_RATIO = 0.7;
+/** No máximo isto de sugestões. */
+export const MAX_SUGGESTIONS = 10;
+/**
+ * A palavra é, de fato, verbo de subcomando DESTE comando? Sim quando é um dos
+ * subcomandos dados (nome ou apelido) ou um sinônimo (`SYNONYMS`) de um deles.
+ * Sem diferenciar caixa, sem espaços nas pontas.
+ *
+ * Revisão do #87 (BAIXO 6): a 1ª versão recusava uma lista GLOBAL de verbos em
+ * qualquer texto livre, e `neetru chat send show` (resposta comum em PT-BR)
+ * passou a ser recusado sem que `show` fosse subcomando de `chat`. A recusa
+ * agora depende dos subcomandos de verdade de quem pergunta: para `chat send`,
+ * só `channels`, `identity`/`apelido`, `send` e `history`; para
+ * `chat identity`, os verbos dele (`show`, `set`, `clear`…) e seus sinônimos.
+ */
+export function isSubcommandVerb(word, subcommands) {
+    const w = word.trim().toLowerCase();
+    if (!w)
+        return false;
+    if (subcommands.includes(w))
+        return true;
+    return (SYNONYMS[w] ?? []).some((s) => subcommands.includes(s));
+}
+/**
+ * Pontuação de uma palavra digitada contra uma palavra de um comando — o
+ * `_WordScore` do gcloud, linha a linha. Sempre ≥ 0; zero = sem relação.
+ */
+export function wordScore(index, word, canonical, canonicalLength) {
+    if (!word || !canonical)
+        return 0;
+    let shorter;
+    let longer;
+    if (canonical.includes(word)) {
+        shorter = word;
+        longer = canonical;
+    }
+    else if (word.includes(canonical)) {
+        shorter = canonical;
+        longer = word;
+    }
+    else {
+        return 0;
+    }
+    // O acerto no meio precisa cair em fronteira de palavra.
+    const hit = longer.indexOf(shorter);
+    if (hit > 0 && longer[hit - 1] !== '-')
+        return 0;
+    let score = 10;
+    if (canonicalLength === 1)
+        score += 30;
+    else if (canonicalLength === 2)
+        score += 20;
+    else if (canonicalLength === 3)
+        score += 10;
+    if (index === 0)
+        score += 25;
+    else if (index === 1)
+        score += 15;
+    else
+        score += 5;
+    let extra = longer.length - shorter.length;
+    if (extra <= 2) {
+        extra = 3 - extra;
+        if (longer.startsWith(shorter))
+            extra *= 2;
+        score += extra;
+    }
+    if (index === 0 && canonicalLength > 1)
+        score += 30;
+    else if (index > 0 && canonicalLength > index + 1)
+        score += 15;
+    return score;
+}
+/**
+ * Candidatos pontuados, do maior para o menor (empate: ordem lexicográfica).
+ * Só entra quem pontua > 0. Cada candidato é a lista de palavras do comando.
+ */
+export function scoreCandidates(words, candidates) {
+    const normalizadas = words.map((w) => w.trim().toLowerCase().replace(/_/g, '-')).filter(Boolean);
+    const out = [];
+    for (const cand of candidates) {
+        const casadas = new Set();
+        let score = 0;
+        cand.forEach((canonica, index) => {
+            for (const w of normalizadas) {
+                let inc = wordScore(index, w, canonica, cand.length);
+                for (const alt of SYNONYMS[w] ?? []) {
+                    inc = Math.max(inc, wordScore(index, alt, canonica, cand.length));
+                }
+                if (inc) {
+                    casadas.add(w);
+                    score += inc;
+                }
+            }
+        });
+        if (normalizadas.length > 0 && casadas.size === normalizadas.length)
+            score += 10;
+        if (score > 0)
+            out.push({ command: cand, score });
+    }
+    out.sort((a, b) => b.score - a.score || a.command.join(' ').localeCompare(b.command.join(' ')));
+    return out;
+}
+/**
+ * Comandos sugeridos para as palavras digitadas — o `GetCommandSuggestions`
+ * do gcloud: só quem pontua > 0 e faz pelo menos `MIN_RATIO` da pontuação do
+ * primeiro, no máximo `MAX_SUGGESTIONS`. Vazio quando nada pontua.
+ */
+export function suggestCommands(words, candidates) {
+    const pontuados = scoreCandidates(words, candidates);
+    if (pontuados.length === 0)
+        return [];
+    const topo = pontuados[0].score;
+    return pontuados
+        .filter((p) => p.score / topo >= MIN_RATIO)
+        .slice(0, MAX_SUGGESTIONS)
+        .map((p) => p.command.join(' '));
+}
+/**
+ * Sugestões para a palavra digitada, entre os subcomandos dados. Vazio quando
+ * nada passa o piso — aí quem chama lista as escolhas, nunca chuta.
+ */
+export function suggestSubcommands(word, subcommands) {
+    return suggestCommands([word], subcommands.map((s) => [s]));
+}
+/**
+ * Recusa um verbo usado como valor e sugere o subcomando certo — ou, sem
+ * sugestão que passe o piso, lista as escolhas. Exit 1 (erro do cliente). No
+ * JSON: `value`, `suggestions` (comandos completos) e `valid`.
+ */
+export function reservedVerbError(input) {
+    const pai = input.parent ?? input.command;
+    const apelidoDe = input.aliases?.[input.verb.trim().toLowerCase()];
+    const sugestoes = (apelidoDe ? [apelidoDe] : suggestSubcommands(input.verb, input.subcommands)).map((s) => `neetru ${pai} ${s}`);
+    const linhas = [
+        `"${input.verb}" é palavra de comando da CLI e não vale como ${input.what} em \`neetru ${input.command}\`.`,
+    ];
+    if (sugestoes.length > 0) {
+        linhas.push(`Você quis dizer: ${sugestoes.map((s) => `\`${s}\``).join(' ou ')}?`);
+    }
+    else if (input.subcommands.length > 0) {
+        linhas.push(`Subcomandos de \`neetru ${pai}\`: ${formatChoices(input.subcommands)}.`);
+    }
+    if (input.escapeHint)
+        linhas.push(input.escapeHint);
+    return new NeetruCliError(linhas.join('\n  '), {
+        code: input.code ?? 'uso_invalido',
+        exit: EXIT_CODES.client,
+        details: {
+            value: input.verb,
+            suggestions: sugestoes,
+            valid: [...input.subcommands],
+        },
+    });
+}
+//# sourceMappingURL=suggest.js.map

package/dist/commands/admin/oidc-login.js

@@ -202,7 +202,7 @@ export async function runOidcLoginList(opts) {
     }
     log.heading(`Login-clients OIDC — produto ${opts.productId} (${res.count})`);
     renderTable([
-        { header: 'CLIENT ID', value: (r) => r.clientId, maxWidth: 38 },
+        { header: 'CLIENT ID', value: (r) => r.clientId, identificador: true },
         { header: 'NOME', value: (r) => r.name, maxWidth: 24 },
         { header: 'REDIRECT_URI', value: (r) => (r.redirectUris ?? []).join(', '), maxWidth: 44 },
         {

package/dist/commands/admin/sdk-credential.js

@@ -120,7 +120,7 @@ export async function runSdkCredentialList(opts) {
     }
     log.heading(`Credenciais OIDC — produto ${opts.productId} (${res.count})`);
     renderTable([
-        { header: 'CLIENT ID', value: (r) => r.clientId, maxWidth: 38 },
+        { header: 'CLIENT ID', value: (r) => r.clientId, identificador: true },
         { header: 'NOME', value: (r) => r.name, maxWidth: 28 },
         { header: 'ESCOPOS', value: (r) => r.allowedScopes.join(', '), maxWidth: 40 },
         {

package/dist/commands/autocomplete.d.ts

@@ -6,7 +6,7 @@ export type Shell = 'bash' | 'zsh' | 'pwsh';
  * IMPORTANTE: incluir TODOS os `program.command('X')` de `src/index.ts`.
  * O regression test `top-level-commands-coverage.test.ts` exige >=95%.
  */
-export declare const TOP_LEVEL_COMMANDS: readonly ["add", "admin", "agent", "ai", "api-catalog", "ar", "archive", "artifact-registry", "audit", "auth", "autocomplete", "billing", "bootstrap", "bug", "build", "builds", "cloud-run", "code", "config", "customers", "db", "db-hosts", "deploy", "deployments", "dev", "dns", "docs", "doctor", "dr", "env", "hosting", "init", "login", "logout", "logs", "menu", "mobile", "mocks", "new", "open", "ops", "products", "promote", "publish", "schema", "servers", "smoke", "status", "support", "tenants", "ui", "upgrade", "validate", "vm", "whoami", "workspaces"];
+export declare const TOP_LEVEL_COMMANDS: readonly ["add", "admin", "agent", "ai", "api-catalog", "ar", "archive", "artifact-registry", "audit", "auth", "autocomplete", "billing", "bootstrap", "bug", "build", "builds", "cloud-run", "code", "config", "customers", "db", "db-hosts", "deploy", "deployments", "dev", "dns", "docs", "doctor", "dr", "env", "hosting", "init", "login", "logout", "logs", "menu", "mobile", "mocks", "new", "open", "ops", "products", "promote", "publish", "schema", "secrets", "servers", "smoke", "status", "support", "tenants", "ui", "upgrade", "validate", "vm", "whoami", "workspaces"];
 export interface AutocompleteOptions {
     shell?: string;
 }

package/dist/commands/autocomplete.js

@@ -73,6 +73,7 @@ export const TOP_LEVEL_COMMANDS = [
     'promote',
     'publish',
     'schema', // neetru schema — inspecionar spec OpenAPI do Core
+    'secrets', // neetru secrets — segredos do próprio produto (set/list/archive)
     'servers',
     'smoke', // neetru smoke — percorre páginas do produto local antes do deploy
     'status',

package/dist/commands/bug.d.ts

@@ -1,3 +1,61 @@
+interface BugRow {
+    id: string;
+    title?: string;
+    status?: string;
+    severity?: string;
+    category?: string;
+    assignedTo?: string;
+    productId?: string;
+    reportedAt?: unknown;
+    updatedAt?: unknown;
+    reportedBy?: {
+        actorType?: string;
+        actorId?: string;
+        email?: string;
+    };
+    description?: string;
+    reproductionSteps?: string;
+    expectedBehavior?: string;
+    actualBehavior?: string;
+    resolution?: {
+        summary?: string;
+        commitSha?: string;
+        resolvedBy?: string;
+        resolvedAt?: unknown;
+    };
+    comments?: Array<{
+        author: string;
+        body: string;
+        at?: unknown;
+    }>;
+    environment?: {
+        cliVersion?: string;
+        sdkVersion?: string;
+        nodeVersion?: string;
+        os?: string;
+    };
+}
+/**
+ * Limpa o que o usuário colou: espaços, reticências da tabela antiga, caixa
+ * alta, e aceita o hex sem o `bug_` na frente (`a4f84c1b` → `bug_a4f84c1b`).
+ */
+export declare function normalizarEntradaDeId(entrada: string): string;
+export type ResolucaoDeIdDeBug = {
+    ok: true;
+    id: string;
+} | {
+    ok: false;
+    motivo: 'curto_demais' | 'nao_encontrado' | 'ambiguo';
+    candidatos: BugRow[];
+};
+/** Pura: decide o id a partir da entrada e da lista. Testável sem rede. */
+export declare function escolherBugPorPrefixo(entrada: string, rows: BugRow[]): ResolucaoDeIdDeBug;
+/**
+ * Resolve o id que o usuário digitou pro id completo. Id completo não custa
+ * chamada extra; prefixo custa UMA listagem. Falha sai com mensagem que diz o
+ * que fazer, em vez do "não encontrado" que mentia.
+ */
+export declare function resolverIdDoBug(entrada: string, token: string, json?: boolean): Promise<string>;
 export interface BugReportOptions {
     title?: string;
     body?: string;
@@ -85,3 +143,4 @@ export interface BugCommentOptions {
  *   neetru bug comment bug_abc123 --body "Testei em Node 22 — reproduzível."
  */
 export declare function runBugComment(id: string, opts: BugCommentOptions): Promise<void>;
+export {};

package/dist/commands/bug.js

@@ -21,6 +21,108 @@ import { printWriteResult } from '../lib/cli-write.js';
 import { renderTable, fmtTimestamp } from '../lib/render.js';
 import { log } from '../utils/logger.js';
 import { safeExit } from '../utils/safe-exit.js';
+// ─── Id do bug: inteiro na tela, prefixo como atalho ─────────────────────────
+//
+// bug_a4f84c1b (2026-10-12): o id que o Core gera tem 36 caracteres
+// (`bug_` + uuid sem hífen) e a tabela cortava em 24 com `…`. O usuário copiava
+// o que via, e `bug show` respondia "não encontrado" — negando a EXISTÊNCIA de
+// um bug que existe. O próprio Dev Core caiu nisso consultando bug_a8375858.
+//
+// A tabela mostra o id INTEIRO: é o único handle que funciona sempre. A primeira
+// versão deste conserto mostrava um id curto (`bug_` + 8 hex), e a revisão
+// independente reproduziu em produção o defeito de novo: numa listagem filtrada
+// (`--status resolved`), 38 de 200 linhas estavam fora da janela que a resolução
+// de prefixo enxerga — a tabela imprimia de novo um handle que não resolvia.
+//
+// O prefixo continua aceito como ATALHO, pra quem digita ou cola o que o time
+// escreve no chat (`bug_a4f84c1b`). Ambíguo lista candidatos; não achado NUNCA
+// afirma que o bug não existe — só que não estava no que a listagem devolveu.
+/** Formato do id gerado pelo Core (`bug_${randomUUID().replace(/-/g, '')}`). */
+const ID_COMPLETO = /^bug_[0-9a-f]{32}$/;
+/** Mínimo de hex depois de `bug_` pra aceitar como prefixo. */
+const PREFIXO_MINIMO = 4;
+/** Teto do `?limit` da listagem no Core (`cli/v1/bugs/route.ts`). */
+const LIMITE_DA_LISTAGEM = 200;
+/**
+ * Limpa o que o usuário colou: espaços, reticências da tabela antiga, caixa
+ * alta, e aceita o hex sem o `bug_` na frente (`a4f84c1b` → `bug_a4f84c1b`).
+ */
+export function normalizarEntradaDeId(entrada) {
+    let s = entrada.trim().toLowerCase();
+    s = s.replace(/(…|\.\.\.)$/, '');
+    if (!s.startsWith('bug_') && /^[0-9a-f]+$/.test(s))
+        s = `bug_${s}`;
+    return s;
+}
+/** Pura: decide o id a partir da entrada e da lista. Testável sem rede. */
+export function escolherBugPorPrefixo(entrada, rows) {
+    const alvo = normalizarEntradaDeId(entrada);
+    if (ID_COMPLETO.test(alvo))
+        return { ok: true, id: alvo };
+    if (alvo.length < 'bug_'.length + PREFIXO_MINIMO) {
+        return { ok: false, motivo: 'curto_demais', candidatos: [] };
+    }
+    const candidatos = rows.filter((r) => typeof r.id === 'string' && r.id.startsWith(alvo));
+    if (candidatos.length === 1)
+        return { ok: true, id: candidatos[0].id };
+    return {
+        ok: false,
+        motivo: candidatos.length === 0 ? 'nao_encontrado' : 'ambiguo',
+        candidatos,
+    };
+}
+/**
+ * Resolve o id que o usuário digitou pro id completo. Id completo não custa
+ * chamada extra; prefixo custa UMA listagem. Falha sai com mensagem que diz o
+ * que fazer, em vez do "não encontrado" que mentia.
+ */
+export async function resolverIdDoBug(entrada, token, json) {
+    const direto = normalizarEntradaDeId(entrada);
+    if (ID_COMPLETO.test(direto))
+        return direto;
+    let rows = [];
+    try {
+        const res = await apiRequest(`/api/cli/v1/bugs?limit=${LIMITE_DA_LISTAGEM}`, { token });
+        rows = Array.isArray(res?.reports) ? res.reports : [];
+    }
+    catch (error) {
+        handleApiError(error, json);
+    }
+    const r = escolherBugPorPrefixo(entrada, rows);
+    if (r.ok)
+        return r.id;
+    let msg;
+    if (r.motivo === 'curto_demais') {
+        msg =
+            `Id "${entrada}" curto demais. Use ao menos bug_ + ${PREFIXO_MINIMO} caracteres ` +
+                '(ex.: bug_a4f8) ou o id completo de `neetru bug list --json`.';
+    }
+    else if (r.motivo === 'ambiguo') {
+        const lista = r.candidatos
+            .slice(0, 10)
+            .map((b) => `  ${b.id}  ${b.title ?? ''}`.trimEnd())
+            .join('\n');
+        msg = `Prefixo "${entrada}" casa com ${r.candidatos.length} bugs — use mais caracteres:\n${lista}`;
+    }
+    else {
+        // NUNCA afirmar que o bug não existe: a listagem tem teto (200) e, pra quem
+        // não é admin, ainda é filtrada por produto no Core. O que dá pra afirmar é
+        // só o que foi visto.
+        msg =
+            `Não achei bug começando com "${direto}" entre os ${rows.length} que a ` +
+                'listagem devolveu (os mais recentes que você pode ver). Use o id completo — ' +
+                'a coluna ID de `neetru bug list` mostra inteiro.';
+    }
+    if (json) {
+        // Mesmo formato do resto da CLI (`cli-write.ts`): `error` é o CÓDIGO, em texto.
+        console.log(JSON.stringify({ ok: false, error: `bug_id_${r.motivo}`, message: msg }));
+    }
+    else {
+        log.error(msg);
+    }
+    safeExit(1);
+    return '';
+}
 // ─── Formatação ──────────────────────────────────────────────────────────────
 function colorStatus(s) {
     if (!s)
@@ -187,12 +289,14 @@ export async function runBugList(opts) {
         return;
     }
     renderTable([
-        { header: 'ID', value: (b) => b.id, maxWidth: 24 },
+        { header: 'ID', value: (b) => b.id, identificador: true },
         { header: 'TÍTULO', value: (b) => b.title ?? '—', maxWidth: 40 },
         { header: 'STATUS', value: (b) => colorStatus(b.status) },
         { header: 'SEV', value: (b) => colorSeverity(b.severity) },
         { header: 'CATEGORIA', value: (b) => b.category ?? '—', maxWidth: 10 },
-        { header: 'RESPONSÁVEL', value: (b) => b.assignedTo ?? chalk.dim('—'), maxWidth: 24 },
+        // uid de 28 caracteres que `--assigned-to` aceita de volta: cortado em 24
+        // virava um uid que não existe (revisão do #75).
+        { header: 'RESPONSÁVEL', value: (b) => b.assignedTo ?? chalk.dim('—'), identificador: true },
         { header: 'REPORTADO', value: (b) => fmtTimestamp(b.reportedAt), maxWidth: 14 },
     ], res.reports);
     console.log();
@@ -209,6 +313,7 @@ export async function runBugShow(id, opts) {
         safeExit(1);
     }
     const token = await requireToken(opts.json);
+    id = await resolverIdDoBug(id, token, opts.json);
     const spinner = opts.json ? null : ora({ text: `Buscando bug ${id}…`, color: 'blue' }).start();
     let res;
     try {
@@ -286,6 +391,7 @@ export async function runBugClaim(id, opts) {
         safeExit(1);
     }
     const token = await requireToken(opts.json);
+    id = await resolverIdDoBug(id, token, opts.json);
     const spinner = opts.json ? null : ora({ text: `Assumindo bug ${id}…`, color: 'blue' }).start();
     let res;
     try {
@@ -352,6 +458,11 @@ export async function runBugResolve(id, opts) {
         safeExit(1);
     }
     const token = await requireToken(opts.json);
+    id = await resolverIdDoBug(id, token, opts.json);
+    // `--duplicate-of` também é id de bug: sem resolver, o Core gravaria a
+    // duplicata apontando pra um id que não existe.
+    if (duplicateOf)
+        duplicateOf = await resolverIdDoBug(duplicateOf, token, opts.json);
     const spinner = opts.json ? null : ora({ text: `Encerrando bug ${id}…`, color: 'blue' }).start();
     let res;
     try {
@@ -401,6 +512,7 @@ export async function runBugComment(id, opts) {
         safeExit(1);
     }
     const token = await requireToken(opts.json);
+    id = await resolverIdDoBug(id, token, opts.json);
     const spinner = opts.json ? null : ora({ text: `Comentando bug ${id}…`, color: 'blue' }).start();
     let res;
     try {