@orkastery/cli 0.6.1 → 0.6.3

package/dist/locale-claims.js

@@ -49,14 +49,21 @@ exports.CLAIMS_PT_BR = {
     avisoNegativa: 'AVISO: alegacao negativa sem comando de verificacao reprova em `ork verify`.',
     /** A linha do lint no `claims add` (no `ci prepare` o lint sai em pt-BR, como antes). */
     avisoDoLint: (linha, suiteInteira) => `AVISO: ${linha}${suiteInteira ? '. O `ci prepare` recusa esta claim.' : ''}`,
+    lintRecusado: (linhas) => `claim recusada antes de ser registrada:\n  ${linhas}`,
     linhaDoLint: (claim, nome, trecho, correcao) => `${claim} ${nome} (${trecho}); ${correcao}`,
     nomesDoLint: { 'suite-inteira': 'roda a suite inteira', 'sha-intermediario': 'fixa um SHA intermediario',
-        'contagem-de-commits': 'compara contagem de commits' },
+        'contagem-de-commits': 'compara contagem de commits', 'binario-rg': 'usa o binario rg ausente no runner',
+        'ork-fora-do-path': 'chama ork fora do PATH do runner', 'estado-local': 'le estado local fora do checkout',
+        'aspas-escapadas': 'leva aspas escapadas literalmente' },
     correcoesDoLint: {
         'suite-inteira': 'rode só o teste da claim (`node --test` no arquivo do teste, ou o comando do projeto que roda um arquivo) ' +
             'ou um script hermético do projeto',
         'sha-intermediario': 'ancore na base (`git diff "$(git merge-base origin/main HEAD)" HEAD`) ou prove ancestralidade com `git merge-base --is-ancestor <sha> HEAD`',
         'contagem-de-commits': 'use `git merge-base --is-ancestor <commit> HEAD`: contagem de commits quebra com rebase e merge',
+        'binario-rg': 'use `grep` (ou Node) com a mesma prova; o runner nao instala `rg`',
+        'ork-fora-do-path': 'use `node core/dist/index.js ...`; o runner nao instala `ork` no PATH',
+        'estado-local': 'prove somente arquivos versionados do checkout; `.orkastery/` e estado local e nao vai ao CI',
+        'aspas-escapadas': 'use aspas reais do shell; nao serialize `\\x22` ou `\\x27` dentro do comando',
     },
     // ork claims conferir
     usoConferir: 'uso: ork claims conferir <thread-id> --claims C1,C2 | --tarefa T1 [--prazo S] [--json]',
@@ -138,14 +145,21 @@ exports.CLAIMS_EN = {
     estado: (estado) => ESTADOS_EN[estado] ?? estado,
     avisoNegativa: 'WARNING: a negative statement without a verification command fails in `ork verify`.',
     avisoDoLint: (linha, suiteInteira) => `WARNING: ${linha}${suiteInteira ? '. `ci prepare` refuses this claim.' : ''}`,
+    lintRecusado: (linhas) => `claim refused before it was recorded:\n  ${linhas}`,
     linhaDoLint: (claim, nome, trecho, correcao) => `${claim} ${nome} (${trecho}); ${correcao}`,
     nomesDoLint: { 'suite-inteira': 'runs the whole suite', 'sha-intermediario': 'pins an intermediate SHA',
-        'contagem-de-commits': 'compares a commit count' },
+        'contagem-de-commits': 'compares a commit count', 'binario-rg': 'uses the rg binary missing from the runner',
+        'ork-fora-do-path': 'calls ork outside the runner PATH', 'estado-local': 'reads local state outside the checkout',
+        'aspas-escapadas': 'passes escaped quotes literally' },
     correcoesDoLint: {
         'suite-inteira': 'run only the claim test (`node --test` on the test file, or the project command that runs one file) ' +
             'or a hermetic project script',
         'sha-intermediario': 'anchor on the base (`git diff "$(git merge-base origin/main HEAD)" HEAD`) or prove ancestry with `git merge-base --is-ancestor <sha> HEAD`',
         'contagem-de-commits': 'use `git merge-base --is-ancestor <commit> HEAD`: a commit count breaks with rebase and merge',
+        'binario-rg': 'use `grep` (or Node) for the same proof; the runner does not install `rg`',
+        'ork-fora-do-path': 'use `node core/dist/index.js ...`; the runner does not install `ork` in PATH',
+        'estado-local': 'prove only versioned checkout files; `.orkastery/` is local state and is not sent to CI',
+        'aspas-escapadas': 'use real shell quotes; do not serialize `\\x22` or `\\x27` inside the command',
     },
     usoConferir: 'usage: ork claims conferir <thread-id> --claims C1,C2 | --tarefa T1 [--prazo S] [--json]',
     conferencia: (thread) => `Spot check of thread ${thread} (no receipt: \`ork verify\` is still what verifies)`,

package/dist/locale-grafo.js

@@ -1,7 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GRAFO_EN = exports.GRAFO_PT_BR = void 0;
-/** RM-061 F3d: moldura humana do grafo; schemas, códigos e JSON continuam em pt-BR. */
+/** RM-061 F3e: traduz somente o detalhe humano; o código tipado continua canônico. */
+const erroDoGrafoEmIngles = (mensagem) => {
+    const trocas = [
+        [/quem roda o CLI nao le a raiz do repositorio/g, 'the CLI process cannot read the repository root'],
+        [/nao e pasta real/g, 'is not a real directory'], [/de outro dono/g, 'has a different owner'],
+        [/ com modo /g, ' with mode '], [/ ausente/g, ' missing'], [/\(erro\)/g, '(error)'],
+        [/nao bate com o tamanho/g, 'does not match the size'], [/nao bate com o digest/g, 'does not match the digest'],
+        [/fora do manifesto/g, 'outside the manifest'], [/sem unidades/g, 'without units'],
+        [/o ork grafo limpar o remove/g, 'ork grafo limpar removes it'], [/nenhum indice guardado/g, 'no stored index'],
+        [/sem-commit/g, 'no-commit'], [/revisao-mudou/g, 'revision-changed'],
+        [/rastreado fora da leitura/g, 'tracked outside the read'], [/ e mais (\d+)/g, ' and $1 more'],
+        [/o incremental a partir de ([^ ]+) falhou e a extracao foi completa/g, 'the incremental build from $1 failed and extraction was full'],
+        [/o incremental da base ([^ ]+) falhou/g, 'the incremental build from base $1 failed'],
+        [/o indice guardado difere da extracao nova/g, 'the stored index differs from the new extraction'],
+        [/sem indice do HEAD ([^;]+); rode/g, 'no index for HEAD $1; run'],
+        [/ha indice do HEAD ([^ ]+) de outro extrator/g, 'HEAD $1 has an index from another extractor'],
+        [/perfil diferente/g, 'different profile'], [/pacotes dos analisadores/g, 'analyzer packages'],
+        [/codigo do extrator/g, 'extractor code'], [/ no indice/g, ' in the index'], [/ aqui/g, ' here'],
+        [/o HEAD ([^ ]+) nao tem indice; o guardado e de outra revisao/g, 'HEAD $1 has no index; the stored index is from another revision'],
+        [/; rode /g, '; run '],
+        [/com a mesma instalacao do ork e o mesmo Node de quem consulta/g, 'with the same Ork installation and Node used by the caller'],
+        [/\(o servidor MCP consulta com a dele\)/g, '(the MCP server uses its own installation)'],
+        [/ tem (\d+) candidatos/g, ' has $1 candidates'], [/no vazio/g, 'empty node'],
+        [/ precisa ser inteiro de /g, ' must be an integer from '], [/tipo de aresta desconhecido/g, 'unknown edge type'],
+        [/nenhum tipo de aresta/g, 'no edge type'], [/sentido desconhecido/g, 'unknown direction'],
+        [/chamadores pede um simbolo; para arquivo, use importadores ou vizinhos/g, 'chamadores expects a symbol; for a file, use importadores or vizinhos'],
+        [/importadores pede um arquivo ou um simbolo/g, 'importadores expects a file or symbol'],
+        [/teto deve ser inteiro de/g, 'ceiling must be an integer from'], [/borda sem leitor da thread/g, 'edge has no thread reader'],
+        [/HEAD mudou durante a leitura; repita a consulta/g, 'HEAD changed during the read; repeat the query'],
+        [/ tem (\d+) bytes, acima do teto de (\d+)/g, ' has $1 bytes, above the $2-byte ceiling'],
+        [/o caminho nao se corta/g, 'the path cannot be truncated'], [/use --teto-bytes maior/g, 'use a larger --teto-bytes'],
+        [/o caminho de (\d+) passo\(s\)/g, 'the $1-step path'], [/a resposta com (\d+) aresta\(s\)/g, 'the response with $1 edge(s)'],
+    ];
+    return trocas.reduce((texto, [padrao, troca]) => texto.replace(padrao, troca), mensagem);
+};
+/** RM-061 F3d/F3e: moldura humana do grafo; schemas, códigos e JSON continuam em pt-BR. */
 exports.GRAFO_PT_BR = {
     uso: [
         'uso: ork grafo indexar [--verificar] [--forcar] [--json]',
@@ -15,6 +50,7 @@ exports.GRAFO_PT_BR = {
         '     ork grafo limpar [--tudo] [--json]',
     ],
     erroUso: (motivo) => `grafo.uso: ${motivo}`,
+    erroTipado: (mensagem) => mensagem,
     motivos: {
         semSub: 'falta o subcomando', desconhecido: (sub) => `subcomando desconhecido: ${sub}`,
         repetida: (nome) => `--${nome} repetida`, semValor: (nome) => `--${nome} nao leva valor`,
@@ -34,6 +70,15 @@ exports.GRAFO_PT_BR = {
         determinismo: (ordem, digest, relatorio, unidades, igual) => `  determinismo ${ordem}: digest ${digest}, relatorio ${relatorio}, unidades ${unidades}, ${igual ? 'igual' : 'DIFERENTE'}`,
         incremental: (base, igual) => `  incremental  a partir do indice de ${base}: ${igual ? 'igual a completa nos quatro arquivos' : 'DIFERENTE'}`,
         naoConferido: (motivo) => `  incremental  nao conferido: ${motivo}`, aprovado: 'aprovado', semBase: 'sem base',
+        extracao: {
+            lista: (itens) => itens.length ? ` (${itens.slice(0, 5).join(', ')}${itens.length > 5 ? ` e mais ${itens.length - 5}` : ''})` : '',
+            incremental: (base, alterados, novos, removidos) => `  extracao     incremental a partir do indice de ${base}: ${alterados} alterado(s), ${novos} novo(s), ${removidos} removido(s)`,
+            tsInteiro: (motivo) => `TypeScript inteiro (${motivo ?? ''})`,
+            tsParcial: (reextraidos, lista, programa, reaproveitados) => `TypeScript parcial, ${reextraidos} reextraido(s)${lista} num programa de ${programa}, ${reaproveitados} da base`,
+            tsBase: (reaproveitados) => `TypeScript todo da base (${reaproveitados})`,
+            markdown: (reextraidos, lista, reaproveitados) => `               Markdown: ${reextraidos} reextraido(s)${lista}, ${reaproveitados} da base`,
+            completa: (motivo) => `  extracao     completa${motivo ? `: ${motivo}` : ''}`,
+        },
     },
     status: {
         titulo: (head, arvore) => `grafo: HEAD ${head}, arvore ${arvore}`,
@@ -81,6 +126,7 @@ exports.GRAFO_EN = {
         '       ork grafo amostra [--por-estrato N] | ork grafo amostra --conferir FILE [--json]', '       ork grafo limpar [--tudo] [--json]',
     ],
     erroUso: (reason) => `grafo.uso: ${reason}`,
+    erroTipado: erroDoGrafoEmIngles,
     motivos: {
         semSub: 'missing subcommand', desconhecido: (sub) => `unknown subcommand: ${sub}`, repetida: (name) => `--${name} repeated`,
         semValor: (name) => `--${name} takes no value`, exigeValor: (name) => `--${name} requires a value`, opcao: (sub, value) => `unknown option for ${sub}: ${value}`,
@@ -96,6 +142,15 @@ exports.GRAFO_EN = {
         determinismo: (order, digest, report, units, equal) => `  determinism   ${order}: digest ${digest}, report ${report}, units ${units}, ${equal ? 'equal' : 'DIFFERENT'}`,
         incremental: (base, equal) => `  incremental  from index ${base}: ${equal ? 'equal to the full build in all four files' : 'DIFFERENT'}`,
         naoConferido: (reason) => `  incremental  not checked: ${reason}`, aprovado: 'approved', semBase: 'no base',
+        extracao: {
+            lista: (items) => items.length ? ` (${items.slice(0, 5).join(', ')}${items.length > 5 ? ` and ${items.length - 5} more` : ''})` : '',
+            incremental: (base, changed, added, removed) => `  extraction   incremental from index ${base}: ${changed} changed, ${added} added, ${removed} removed`,
+            tsInteiro: (reason) => `full TypeScript program (${erroDoGrafoEmIngles(reason ?? '')})`,
+            tsParcial: (reextracted, list, program, reused) => `partial TypeScript program, ${reextracted} re-extracted${list} in a program of ${program}, ${reused} reused from the base`,
+            tsBase: (reused) => `TypeScript entirely from the base (${reused})`,
+            markdown: (reextracted, list, reused) => `               Markdown: ${reextracted} re-extracted${list}, ${reused} reused from the base`,
+            completa: (reason) => `  extraction   full${reason ? `: ${erroDoGrafoEmIngles(reason)}` : ''}`,
+        },
     },
     status: {
         titulo: (head, tree) => `graph: HEAD ${head}, tree ${tree}`, indice: (key, state) => `  HEAD index     ${key} ${state}`,

package/dist/locale-maestro.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAESTRO_EN = exports.MAESTRO_PT_BR = void 0;
+/** RM-061 F3e: moldura humana do panorama Maestro; o snapshot JSON continua canônico. */
+exports.MAESTRO_PT_BR = {
+    help: 'ork maestro [--json] [--thread ID] [--section NOME --offset N]\nConsulta sem criar ou despachar trabalho. Na conversa, diga: orkastery maestro.',
+    origem: {
+        installation: 'fixado na instalação', cwd: 'pelo diretório atual', worktree: 'pela worktree da thread',
+        selection: 'pedido explicitamente (--projeto ou ORK_PROJETO)',
+    },
+    titulo: (projeto) => `${projeto} · panorama Maestro`,
+    consulta: (data) => `• Consulta: ${data}`,
+    projeto: (nome, raiz, remoto, origem) => `• Projeto consultado: ${nome}${raiz ? ` · ${raiz}` : ''}${remoto === undefined ? '' : ` · ${remoto}`} · ${origem}`,
+    semRemoto: 'sem remoto',
+    naoLido: (itens) => `• Não lido: ${itens}`,
+    secao: (nome, estado, retornados, total, mais) => `• ${nome}: ${estado} · ${retornados}/${total ?? '?'}${mais ? ' · mais itens disponíveis' : ''}`,
+    thread: (titulo, fase, estado) => `  ${titulo}: ${fase} · ${estado}`,
+    recomendacao: (conflitos, lacunas) => `• Recomendo: ${conflitos ? 'reler as fontes em conflito'
+        : lacunas ? 'conferir as lacunas antes de agir' : 'escolher uma thread para ver o detalhe'}.`,
+    final: 'Use ork maestro --json para cobertura e ações; --thread ID consulta o detalhe nativo.',
+};
+exports.MAESTRO_EN = {
+    help: 'ork maestro [--json] [--thread ID] [--section NAME --offset N]\nRead without creating or dispatching work. In the conversation, say: orkastery maestro.',
+    origem: {
+        installation: 'fixed by the installation', cwd: 'from the current directory', worktree: 'from the thread worktree',
+        selection: 'explicitly selected (--projeto or ORK_PROJETO)',
+    },
+    titulo: (project) => `${project} · Maestro overview`,
+    consulta: (date) => `• Read at: ${date.replace('(horário de Brasília)', '(Brasilia time)')}`,
+    projeto: (name, root, remote, origin) => `• Project read: ${name}${root ? ` · ${root}` : ''}${remote === undefined ? '' : ` · ${remote}`} · ${origin}`,
+    semRemoto: 'no remote',
+    naoLido: (items) => `• Not read: ${items}`,
+    secao: (name, state, returned, total, more) => `• ${name}: ${state} · ${returned}/${total ?? '?'}${more ? ' · more items available' : ''}`,
+    thread: (title, phase, state) => `  ${title}: ${phase} · ${state}`,
+    recomendacao: (conflicts, gaps) => `• Recommendation: ${conflicts ? 'reread the conflicting sources'
+        : gaps ? 'check the gaps before acting' : 'choose a thread to read its details'}.`,
+    final: 'Use ork maestro --json for coverage and actions; --thread ID reads the native details.',
+};

package/dist/locale-network.js

@@ -111,12 +111,13 @@ exports.NETWORK_PT_BR = {
     nomeEmUso: (maquina, quem, dica) => `rede.nome-em-uso: outra instalacao ja publica como "${maquina}"${quem}${dica}`,
     quemHostname: (hostname, batida) => ` (hostname ${hostname}, batida ${batida})`,
     quemIlegivel: ' (num retrato que esta versao nao le)',
-    dicaMesmoHostname: '; o retrato tem o hostname desta maquina: se for ela mesma, com ~/.orkastery apagada ou copiada, retome o nome com ' +
-        'ork network entrar --forcar; se for outra maquina ou instalacao com o mesmo hostname, escolha outro nome com --maquina NOME',
-    dicaOutroNome: '; escolha outro nome com ork network entrar --maquina NOME, ou tome este com --forcar',
+    dicaNomeEmUso: '; se for esta maquina com ~/.orkastery apagada ou copiada, retome o nome com ' +
+        'ork network entrar --forcar; se for outra maquina ou instalacao, escolha outro nome com --maquina NOME',
     concorrencia: (n) => `rede.concorrencia: ${n} pushes recusados seguidos; tente de novo em instantes`,
     foraDaRede: 'rede.fora: esta maquina nao esta na rede; ork network entrar',
     nomeInvalido: (maquina) => `rede.maquina: nome de maquina invalido ("${maquina}"); use ork network entrar --maquina NOME (letras, numeros, ponto, _ ou -)`,
+    nomeGenericoAusente: 'rede.maquina-generica: escolha um nome generico com ork network entrar --maquina maquina-a; ' +
+        'o mapa fica somente em ~/.orkastery/maquina.json, fora do git',
     ocupadoAoEntrar: (trava) => `rede.ocupado: outra publicacao desta maquina esta em andamento (${trava}); rode ork network entrar de novo em instantes`,
     semHttpsAoSair: (cli, ref) => `rede.sem-https: saiu da rede aqui, mas ${cli} devolveu para ${ref} uma URL sem https; o retrato fica na casa`,
     ocupadoAoSair: (trava) => `rede.ocupado: saiu da rede aqui, mas outra publicacao desta maquina segura a casa (${trava}); rode ork network sair de novo`,
@@ -294,12 +295,13 @@ exports.NETWORK_EN = {
     nomeEmUso: (maquina, quem, dica) => `rede.nome-em-uso: another installation already publishes as "${maquina}"${quem}${dica}`,
     quemHostname: (hostname, batida) => ` (hostname ${hostname}, heartbeat ${batida})`,
     quemIlegivel: ' (in a snapshot this version does not read)',
-    dicaMesmoHostname: '; the snapshot has this machine\'s hostname: if it is this machine, with ~/.orkastery deleted or copied, take the name back with ' +
-        '`ork network entrar --forcar`; if it is another machine or installation with the same hostname, pick another name with `--maquina NAME`',
-    dicaOutroNome: '; pick another name with `ork network entrar --maquina NAME`, or take this one with `--forcar`',
+    dicaNomeEmUso: '; if it is this machine with ~/.orkastery deleted or copied, take the name back with ' +
+        '`ork network entrar --forcar`; if it is another machine or installation, pick another name with `--maquina NAME`',
     concorrencia: (n) => `rede.concorrencia: ${n} pushes refused in a row; try again in a moment`,
     foraDaRede: 'rede.fora: this machine is not in the network; `ork network entrar`',
     nomeInvalido: (maquina) => `rede.maquina: invalid machine name ("${maquina}"); use \`ork network entrar --maquina NAME\` (letters, digits, dot, _ or -)`,
+    nomeGenericoAusente: 'rede.maquina-generica: choose a generic name with `ork network entrar --maquina maquina-a`; ' +
+        'the mapping stays only in ~/.orkastery/maquina.json, outside git',
     ocupadoAoEntrar: (trava) => `rede.ocupado: another publication from this machine is in progress (${trava}); run \`ork network entrar\` again in a moment`,
     semHttpsAoSair: (cli, ref) => `rede.sem-https: left the network here, but ${cli} returned a URL without https for ${ref}; the snapshot stays in the home`,
     ocupadoAoSair: (trava) => `rede.ocupado: left the network here, but another publication from this machine holds the home (${trava}); run \`ork network sair\` again`,

package/dist/locale-onboarding.js

@@ -43,6 +43,13 @@ exports.ONBOARDING_PT_BR = {
     /** Aviso de preferencia invalida que o manifesto gravou ao carregar (pt-BR): traduzido so na impressao (D14). */
     avisoDaPreferencia: (aviso) => aviso,
     experienciaAviso: (aviso) => `Aviso: ${aviso}; o adapter install pula o pacote até ork onboarding set maestro corrigir.`,
+    syncPor: 'onboarding.input.invalid: sync não aceita --por; informe autoria em set ou reset.',
+    syncResultado: (regime, motivo, respondidas, gravadas, duplicadas, falhas) => `${regime}${motivo ? ` (${motivo})` : ''}: ${regime === 'orkmind' && falhas === 0
+        ? `${gravadas} nova(s), ${duplicadas} já existente(s); ${respondidas} etapa(s) publicada(s).`
+        : 'Entrevista preservada em arquivos; publicação semântica não concluída. Consulte ork memory status.'}`,
+    experienciaUninstallUso: 'uso: ork experiencia uninstall claude-code|codex [--dry-run] [--json]',
+    experienciaUninstall: (dryRun, arquivos) => `${dryRun ? 'Simulação de remoção' : 'Remoção concluída'}: ${arquivos} arquivo(s). O adaptador permanece instalado. ` +
+        'Para manter o pacote desativado, configure owner.experience:false no onboarding.',
 };
 /** Os avisos de `validarPreferencias` (`core/src/experiencia.ts`), pela frase exata que o manifesto grava. */
 const AVISOS_DA_PREFERENCIA_EN = {
@@ -89,4 +96,11 @@ exports.ONBOARDING_EN = {
         return traduzido === undefined ? aviso : traduzido + (texto === aviso ? '' : '; the default is used for now');
     },
     experienciaAviso: (aviso) => `Warning: ${aviso}; \`ork adapter install\` skips the package until \`ork onboarding set maestro\` fixes it.`,
+    syncPor: 'onboarding.input.invalid: sync does not accept --por; record authorship with set or reset.',
+    syncResultado: (regime, motivo, respondidas, gravadas, duplicadas, falhas) => `${regime}${motivo ? ` (${motivo})` : ''}: ${regime === 'orkmind' && falhas === 0
+        ? `${gravadas} new, ${duplicadas} already present; ${respondidas} step(s) published.`
+        : 'Interview preserved in files; semantic publication did not finish. See ork memory status.'}`,
+    experienciaUninstallUso: 'usage: ork experiencia uninstall claude-code|codex [--dry-run] [--json]',
+    experienciaUninstall: (dryRun, files) => `${dryRun ? 'Removal dry run' : 'Removal complete'}: ${files} file(s). The adapter remains installed. ` +
+        'To keep the package disabled, set owner.experience:false in onboarding.',
 };

package/dist/locale-operacao-restante.js

@@ -339,23 +339,23 @@ exports.OPERACAO_RESTANTE_PT_BR = {
         deveriaAusente: (valor, vezes) => `"${valor}" deveria estar AUSENTE da skill e aparece ${vezes}x`,
         naoExiste: (valor, skill, porque) => `"${valor}" nao existe em skills/.../${skill}/SKILL.md (${porque})`,
         ancora: 'todas as ancoras deste caso estao dentro da tabela de racionalizacoes: a skill lista a desculpa mas nao carrega a regra que responde a ela',
-        filtroVazio: 'filtro de canários vazio: nenhuma prova foi executada',
-        canarioAusente: (id) => `canário solicitado ausente: ${id}`,
+        filtroVazio: 'filtro de cenários vazio: nenhuma prova foi executada',
+        cenarioAusente: (id) => `cenário solicitado ausente: ${id}`,
         casoAusente: (nome) => `${nome}: falta caso.json`,
-        fixtureDiverge: 'id da fixture diverge do canário solicitado',
-        semExecutor: (nome, id) => `${nome}: nenhum executor registrado para o canario "${id}"`,
-        semGit: 'git nao esta nesta maquina: o canario sai unavailable, nunca passing',
+        fixtureDiverge: 'id da fixture diverge do cenário solicitado',
+        semExecutor: (nome, id) => `${nome}: nenhum executor registrado para o cenario "${id}"`,
+        semGit: 'git nao esta nesta maquina: o cenario sai unavailable, nunca passing',
         divergencia: (esperado, observado) => `esperado ${esperado}, observado ${observado}`,
-        canarioSemFixture: (id) => `o canario ${id} existe no codigo e nao tem eval/fixtures/${id}/caso.json`,
+        cenarioSemFixture: (id) => `o cenario ${id} existe no codigo e nao tem eval/fixtures/${id}/caso.json`,
         skillSemEval: (skill) => `skill sem eval nao entra no catalogo: falta eval/casos/${skill}.json`,
         evalSemSkill: 'ha casos para uma skill que nao existe no catalogo',
         titulo: (catalogo) => `ork eval, catalogo em ${catalogo}`,
-        canarios: 'Canarios (comportamento real do nucleo, contra git de verdade)',
-        colunasCanarios: ['CANARIO', 'ESTADO', 'SOBRE'],
+        cenarios: 'Cenarios (comportamento real do nucleo, contra git de verdade)',
+        colunasCenarios: ['CENARIO', 'ESTADO', 'SOBRE'],
         estados: { passou: 'passou', unavailable: 'unavailable', falhou: 'falhou' },
         skills: 'Corpus das skills (a metade estatica: as regras que precisam existir no arquivo)',
         colunasSkills: ['SKILL', 'CASOS', 'ASSERCOES', 'FALHAS'], falhas: 'Falhas',
-        resumoCanarios: (passaram, total, indisponiveis) => `canarios: ${passaram}/${total} verdes${indisponiveis > 0 ? ` (${indisponiveis} unavailable)` : ''}`,
+        resumoCenarios: (passaram, total, indisponiveis) => `cenarios: ${passaram}/${total} verdes${indisponiveis > 0 ? ` (${indisponiveis} unavailable)` : ''}`,
         resumoSkills: (skills, casos, assercoes, falhas) => `skills: ${skills} | casos: ${casos} | assercoes: ${assercoes} | falhas: ${falhas}`,
         metade: 'metade comportamental (o agente resiste a desculpa?): unavailable, julgada por humano ou por modelo, nunca por este runner',
         veredito: (ok) => `VEREDITO: ${ok ? 'verde' : 'vermelho'}`,
@@ -815,23 +815,23 @@ exports.OPERACAO_RESTANTE_EN = {
         deveriaAusente: (value, times) => `"${value}" should be ABSENT from the skill and appears ${times} time(s)`,
         naoExiste: (value, skill, why) => `"${value}" does not exist in skills/.../${skill}/SKILL.md (${why})`,
         ancora: 'every anchor in this case is inside the rationalizations table: the skill lists the excuse but does not carry the rule that answers it',
-        filtroVazio: 'empty canary filter: no evidence was executed',
-        canarioAusente: (id) => `requested canary is missing: ${id}`,
+        filtroVazio: 'empty scenario filter: no evidence was executed',
+        cenarioAusente: (id) => `requested scenario is missing: ${id}`,
         casoAusente: (name) => `${name}: caso.json is missing`,
-        fixtureDiverge: 'fixture id differs from the requested canary',
-        semExecutor: (name, id) => `${name}: no executor registered for canary "${id}"`,
-        semGit: 'git is not on this machine: the canary is unavailable, never passing',
+        fixtureDiverge: 'fixture id differs from the requested scenario',
+        semExecutor: (name, id) => `${name}: no executor registered for scenario "${id}"`,
+        semGit: 'git is not on this machine: the scenario is unavailable, never passing',
         divergencia: (expected, observed) => `expected ${expected}, observed ${observed}`,
-        canarioSemFixture: (id) => `canary ${id} exists in code but has no eval/fixtures/${id}/caso.json`,
+        cenarioSemFixture: (id) => `scenario ${id} exists in code but has no eval/fixtures/${id}/caso.json`,
         skillSemEval: (skill) => `a skill without eval does not enter the catalog: eval/casos/${skill}.json is missing`,
         evalSemSkill: 'there are cases for a skill that does not exist in the catalog',
         titulo: (catalog) => `ork eval, catalog at ${catalog}`,
-        canarios: 'Canaries (real core behavior, against real git)',
-        colunasCanarios: ['CANARY', 'STATE', 'SUBJECT'],
+        cenarios: 'Scenarios (real core behavior, against real git)',
+        colunasCenarios: ['SCENARIO', 'STATE', 'SUBJECT'],
         estados: { passou: 'passed', unavailable: 'unavailable', falhou: 'failed' },
         skills: 'Skills corpus (the static half: rules that must exist in the file)',
         colunasSkills: ['SKILL', 'CASES', 'ASSERTIONS', 'FAILURES'], falhas: 'Failures',
-        resumoCanarios: (passed, total, unavailable) => `canaries: ${passed}/${total} green${unavailable > 0 ? ` (${unavailable} unavailable)` : ''}`,
+        resumoCenarios: (passed, total, unavailable) => `scenarios: ${passed}/${total} green${unavailable > 0 ? ` (${unavailable} unavailable)` : ''}`,
         resumoSkills: (skills, cases, assertions, failures) => `skills: ${skills} | cases: ${cases} | assertions: ${assertions} | failures: ${failures}`,
         metade: 'behavioral half (does the agent resist the excuse?): unavailable, judged by a human or a model, never by this runner',
         veredito: (ok) => `VERDICT: ${ok ? 'green' : 'red'}`,

package/dist/locale-preflight.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PREFLIGHT_EN = exports.PREFLIGHT_PT_BR = void 0;
+/** RM-061 F3e: apresentação humana de `ork doctor --modo`. */
+exports.PREFLIGHT_PT_BR = {
+    nomes: {
+        node: 'node', git: 'git', repositorio: 'repositorio', manifesto: 'manifesto', modo: 'modo', abbrev: 'abbrev',
+        trio: 'trio', runtime: 'runtime', contas: 'contas', sandbox: 'sandbox de despacho', provider: 'provider', umask: 'umask',
+        'permissoes do estado': 'permissoes do estado', 'pasta privada': 'pasta privada',
+    },
+    storeInvalido: (detalhe) => `store de perfis invalido: ${detalhe}`,
+    semPerfil: (runtime) => `${runtime} sem perfil configurado: despacho pelo ambiente do processo`,
+    estadoConta: {
+        providerPago: 'provider pago, nunca despacha', loginInconclusivo: 'conferencia de login inconclusiva', semLogin: 'sem login', pronto: 'pronto',
+        esgotadoAte: (estado, ate) => `${estado}${ate ? ` ate ${ate}` : ''}`,
+    },
+    contas: (runtime, estados) => `${runtime}: ${estados}`,
+    contasCorrecao: 'ork accounts check marca os perfis; ork accounts add refaz o login pelo proprio CLI',
+    limites: [
+        'Sonda contextual local: não inventaria sessões, não inicia modelo e não autoriza despacho.',
+        'Aceitação do modelo, instalação do adaptador/MCP, contexto da thread, gates e policies do pedido são revalidados no despacho; com perfis, o login de cada conta é conferido aqui e de novo no despacho.',
+        'Trio sem override; um override posterior exige resolver e verificar novamente o despacho.',
+        'VERIFY/SHIP MCP exigem executor Codex isolado próprio e transporte SHIP válido; a sonda de despacho não comprova entrega.',
+    ],
+    node: 'Node 20 ou superior necessário', gitOk: 'Git disponível', gitAusente: 'Git ausente',
+    repo: 'Repositório Git local necessário', manifestoAusente: 'Manifesto ausente',
+    manifestoInvalido: 'Manifesto inválido; corrija antes do despacho', manifestoValido: 'Manifesto válido',
+    modo: (modo) => `Modo solicitado: ${modo}`, abbrev: 'Identidade curta do projeto validada',
+    trio: 'Runtime/modelo/esforço resolvidos pelo mesmo contrato do despacho; aceitação nativa não comprovada',
+    runtimeOk: (runtime) => `${runtime} disponível`, runtimeAusente: (runtime) => `${runtime} ausente`,
+    sandboxOk: 'Sonda Codex sem modelo executou',
+    sandboxFalhou: 'Sonda Codex falhou; não altere o sandbox para contornar a falha',
+    providerIncompativel: (nomes) => `Nomes de provider incompatíveis com assinatura: ${nomes}`,
+    providerAlheio: 'Há nomes de provider alheios ao runtime; não usar credenciais pagas',
+    providerNenhum: 'Nenhum nome de provider pago ativo',
+    trioInvalido: 'Setup/trio ou sonda inválidos; complete o modelo e confira o runtime no setup canônico',
+    titulo: (modo) => `ork doctor contextual: ${modo}`,
+    check: (nivel, nome, detalhe) => `${nivel}: ${nome}: ${detalhe}`,
+    checkDoBloco: (nivel, nome, detalhe) => `  ${nivel}: ${nome}: ${detalhe}`,
+    bloco: (numero, fases, trio) => `bloco ${numero} ${fases}: ${trio ?? 'trio pendente'}`,
+    resumo: (primeiro, todos) => `Primeiro bloco: ${primeiro ? 'sonda pronta' : 'bloqueado'}; ` +
+        `todos os blocos: ${todos ? 'sonda pronta' : 'dependências pendentes'}`,
+};
+exports.PREFLIGHT_EN = {
+    nomes: {
+        node: 'node', git: 'git', repositorio: 'repository', manifesto: 'manifest', modo: 'mode', abbrev: 'abbrev',
+        trio: 'runtime/model/effort', runtime: 'runtime', contas: 'accounts', sandbox: 'dispatch sandbox', provider: 'provider', umask: 'umask',
+        'permissoes do estado': 'state permissions', 'pasta privada': 'private folder',
+    },
+    storeInvalido: (detail) => `invalid profile store: ${detail}`,
+    semPerfil: (runtime) => `${runtime} has no configured profile: dispatch uses the process environment`,
+    estadoConta: {
+        providerPago: 'paid provider, never dispatches', loginInconclusivo: 'inconclusive login check', semLogin: 'not signed in',
+        pronto: 'ready', esgotadoAte: (state, until) => `${state}${until ? ` until ${until}` : ''}`,
+    },
+    contas: (runtime, states) => `${runtime}: ${states}`,
+    contasCorrecao: '`ork accounts check` marks profiles; `ork accounts add` signs in again through the CLI itself',
+    limites: [
+        'Local contextual probe: it does not invent sessions, start a model or authorize dispatch.',
+        'Model acceptance, adapter/MCP installation, thread context, gates and request policies are checked again at dispatch; with profiles, each account login is checked here and again at dispatch.',
+        'No override in the runtime/model/effort set; a later override requires resolving and checking dispatch again.',
+        'MCP VERIFY/SHIP require their own isolated Codex executor and a valid SHIP transport; the dispatch probe does not prove delivery.',
+    ],
+    node: 'Node 20 or later required', gitOk: 'Git available', gitAusente: 'Git missing',
+    repo: 'Local Git repository required', manifestoAusente: 'Manifest missing',
+    manifestoInvalido: 'Invalid manifest; fix it before dispatch', manifestoValido: 'Valid manifest',
+    modo: (mode) => `Requested mode: ${mode}`, abbrev: 'Short project identity checked',
+    trio: 'Runtime/model/effort resolved by the same dispatch contract; native acceptance not proved',
+    runtimeOk: (runtime) => `${runtime} available`, runtimeAusente: (runtime) => `${runtime} missing`,
+    sandboxOk: 'Codex probe without a model ran', sandboxFalhou: 'Codex probe failed; do not change the sandbox to bypass the failure',
+    providerIncompativel: (names) => `Provider names incompatible with subscription-only: ${names}`,
+    providerAlheio: 'There are provider names unrelated to the runtime; do not use paid credentials',
+    providerNenhum: 'No paid-provider name active',
+    trioInvalido: 'Invalid setup/runtime set or probe; complete the model and check the runtime in canonical setup',
+    titulo: (mode) => `ork contextual doctor: ${mode}`,
+    check: (level, name, detail) => `${level}: ${name}: ${detail}`,
+    checkDoBloco: (level, name, detail) => `  ${level}: ${name}: ${detail}`,
+    bloco: (number, phases, trio) => `block ${number} ${phases}: ${trio ?? 'runtime/model/effort pending'}`,
+    resumo: (first, all) => `First block: ${first ? 'probe ready' : 'blocked'}; all blocks: ${all ? 'probe ready' : 'dependencies pending'}`,
+};

package/dist/locale-projetos.js

@@ -26,6 +26,9 @@ exports.PROJETOS_PT_BR = {
         '`ork network roadmap` (tool ork_network_roadmap).',
     opcaoSemValor: '--projeto sem valor',
     usoOpcao: 'Uso: --projeto <nome|caminho>; os nomes registrados estão em `ork projetos`.',
+    initNaoLeProjeto: 'uso: ork init cria o projeto no diretório atual; entre nele e rode ork init, sem --projeto',
+    mcpNaoLeProjeto: 'uso: o servidor MCP recebe a raiz por --project <raiz absoluta>, não por --projeto',
+    comandoNaoLeProjeto: (comando) => `uso: ork ${comando} não lê projeto; tire --projeto`,
     hostCaminho: (valor) => `no host o projeto vem pelo nome registrado; o caminho "${valor}" não é aceito`,
     hostUseNome: 'Use o nome de um projeto de `ork projetos` (ex.: --projeto orkastery).',
     precisaEscolher: (total) => `${total} projetos conhecidos nesta máquina e nenhum foi pedido; o ork não escolhe pelo diretório do gateway`,
@@ -74,6 +77,9 @@ exports.PROJETOS_EN = {
         '`ork network roadmap` (tool ork_network_roadmap).',
     opcaoSemValor: '--projeto has no value',
     usoOpcao: 'Usage: --projeto <name|path>; registered names are listed by `ork projetos`.',
+    initNaoLeProjeto: 'usage: ork init creates the project in the current directory; enter it and run ork init without --projeto',
+    mcpNaoLeProjeto: 'usage: the MCP server receives its root through --project <absolute root>, not --projeto',
+    comandoNaoLeProjeto: (command) => `usage: ork ${command} does not read a project; remove --projeto`,
     hostCaminho: (value) => `on a host, select a project by its registered name; path "${value}" is not accepted`,
     hostUseNome: 'Use a project name from `ork projetos` (for example: --projeto orkastery).',
     precisaEscolher: (total) => `${total} projects are known on this machine and none was requested; ork does not choose from the gateway directory`,

package/dist/locale-prompts.js

@@ -31,15 +31,15 @@ exports.PROMPTS_PT_BR = {
         'Passos irreversiveis (push, merge, delecao) so acontecem quando o modo autoriza.',
     ],
     regraDasEsperas: 'Esperas: nunca dispare verify, build ou suite com `&` dentro do comando, porque o processo se perde e a sessao ' +
-        'espera um aviso que nunca vem; rode o `ork verify` em primeiro plano, com `timeout` (ele espera a vez na fila de ' +
-        'recursos pesados), ou use a execucao em segundo plano do host, que avisa quando termina; nunca espere com ' +
+        'espera um aviso que nunca vem; prefira `ork_verify` assíncrono e consulte `ork_verify_status` a cada 30–60 s; sem essa ' +
+        'ferramenta, rode o `ork verify` em primeiro plano, com `timeout` (ele espera a vez na fila de recursos pesados), ou use a execucao em segundo plano do host, que avisa quando termina; nunca espere com ' +
         '`pgrep -f` cujo padrao aparece no proprio comando, porque o laco acha a si mesmo e nao termina: espere pelo ' +
         'arquivo de saida com prazo, ou pelo PID guardado.',
     fechoDoGo: (t) => [
         '## Fecho obrigatório do GO',
         '',
-        `Antes de encerrar o bloco com GO, rode \`ork verify ${t}\` e o build declarado no manifesto, ambos em primeiro plano.`,
-        `Gere o bundle com \`ork ci prepare ${t}\` e faça o commit atômico final \`ci(${t}): bundle ...\`.`,
+        `Antes de encerrar o bloco com GO, use \`ork_verify\` e aguarde o veredito verde por \`ork_verify_status\`; sem a consulta assíncrona, rode \`ork verify ${t}\` em primeiro plano. Rode também o build declarado no manifesto em primeiro plano.`,
+        `Com o veredito verde, gere o bundle com \`ork ci prepare ${t}\`, faça o commit atômico final \`ci(${t}): bundle ...\` e siga para CHECK e SHIP conforme os gates.`,
         `Grave \`.orkastery/threads/${t}/pr-body.md\` curto, no idioma do projeto, com o modo do CHECK da rodada (Agile Check ou Classic Check, da linha \`check\` do \`ork verify\`); ` +
             'se o perfil não puder gravá-lo pelo transporte autorizado, devolva o corpo completo no resumo final.',
         'O rito é idêntico em Claude Code e Codex. Ele fecha o GO, mas não autoriza SHIP, push, PR ou merge.',
@@ -125,14 +125,14 @@ exports.PROMPTS_EN = {
         'Irreversible steps (push, merge, deletion) happen only when the mode authorizes them.',
     ],
     regraDasEsperas: 'Waiting: never start verify, build, or a test suite with `&` inside the command; the process may be lost while the session ' +
-        'waits for a notice that never comes. Run `ork verify` in the foreground with `timeout` (it waits for the heavy-resource queue), ' +
-        'or use the host background execution that reports completion. Never wait with `pgrep -f` when its pattern appears in the command itself; ' +
+        'waits for a notice that never comes. Prefer asynchronous `ork_verify` and query `ork_verify_status` every 30–60 seconds; without that ' +
+        'tool, run `ork verify` in the foreground with `timeout` (it waits for the heavy-resource queue), or use the host background execution that reports completion. Never wait with `pgrep -f` when its pattern appears in the command itself; ' +
         'the loop finds itself and never ends. Wait for an output file with a deadline, or for a stored PID.',
     fechoDoGo: (t) => [
         '## Mandatory GO closing',
         '',
-        `Before ending a block that includes GO, run \`ork verify ${t}\` and the build declared in the manifest, both in the foreground.`,
-        `Generate the bundle with \`ork ci prepare ${t}\` and make the final atomic commit \`ci(${t}): bundle ...\`.`,
+        `Before ending a block that includes GO, use \`ork_verify\` and wait for its green verdict through \`ork_verify_status\`; without the asynchronous query, run \`ork verify ${t}\` in the foreground. Also run the manifest build in the foreground.`,
+        `After the green verdict, generate the bundle with \`ork ci prepare ${t}\`, make the final atomic commit \`ci(${t}): bundle ...\`, and continue to CHECK and SHIP as their gates allow.`,
         `Write a short \`.orkastery/threads/${t}/pr-body.md\` in the project language, naming the CHECK mode of the round (Agile Check or Classic Check, from the \`check\` line of \`ork verify\`); ` +
             'if the profile cannot write it through the authorized transport, return the full body in the final summary.',
         'The ritual is identical in Claude Code and Codex. It closes GO, but it does not authorize SHIP, push, PR, or merge.',

package/dist/locale-pulse.js

@@ -192,7 +192,9 @@ exports.PULSE_PT_BR = {
         'tree.blocked': 'a arvore de destino nao esta disponivel para o merge (branch em check-out com alteracao nao commitada, ou worktree que nao pode ser montada)',
         'lease.busy': 'lease ocupado por outra thread',
         'lease.resume-unavailable': 'retomada indisponivel; libere o lease explicitamente com --forcar',
+        'concurrency.lease-indeterminado': 'a vida do dono do lease nao pode ser provada deste host ou namespace; desconhecido nunca e orfao',
         'conducao.em-andamento': 'outra conducao ja executa na worktree da thread (I-36): o pedido foi recusado com quem conduz e as tres acoes (esperar, acompanhar, assumir)',
+        'conducao.acao-necessaria': 'a sessao parou de proposito e deixou um comando exato para a conducao executar fora do sandbox',
         'hitl.formato': 'o pedido HITL saiu fora do formato obrigatorio (pergunta em uma frase, de 3 a 5 alternativas rotuladas com consequencia, exatamente uma com o selo Recomendacao e o porque, corpo em lista; texto livre so com dependencia tecnica tipada)',
         'human.pending': 'gate humano do modo de conducao ainda nao autorizou',
     },
@@ -342,7 +344,9 @@ exports.PULSE_EN = {
         'tree.blocked': 'the target tree is not available for the merge (branch checked out with uncommitted changes, or a worktree that cannot be set up)',
         'lease.busy': 'lease held by another thread',
         'lease.resume-unavailable': 'resume unavailable; release the lease explicitly with `--forcar`',
+        'concurrency.lease-indeterminado': 'the lease owner life cannot be proven from this host or namespace; unknown is never orphaned',
         'conducao.em-andamento': 'another conduction already runs on the thread worktree (I-36): the request was refused with who conducts and the three actions (wait, follow, take over)',
+        'conducao.acao-necessaria': 'the session stopped on purpose and left an exact command for the conductor to run outside the sandbox',
         'hitl.formato': 'the HITL request came out of the required format (question in one sentence, 3 to 5 labeled alternatives with a consequence each, exactly one with the Recommendation seal and the reason, body as a list; free text only with a typed technical dependency)',
         'human.pending': 'the human gate of the conduction mode has not authorized yet',
     },

package/dist/locale-retry.js

@@ -107,10 +107,18 @@ exports.RETRY_PT_BR = {
             porque: 'o lease e de outra thread e vai ser liberado: a fila ja serializa, entao a acao e tentar de novo quando chegar a vez, nunca furar a fila',
             correcao: 'ork lease list mostra a fila; a vez chega sem ninguem forcar',
         },
+        'concurrency.lease-indeterminado': {
+            porque: 'o sandbox nao conseguiu provar se o dono do lease esta vivo ou morto: ausencia de PID visivel nao prova orfandade, e reexecutar poderia abrir duas operacoes pesadas',
+            correcao: 'espere com --esperar; se a observacao continuar inconclusiva, execute pela conducao o comando exato do pedido aberto',
+        },
         'conducao.em-andamento': {
             porque: 'outra conducao executa na mesma worktree agora: a vez chega quando ela terminar, e furar a fila e o incidente de 19/09/2026',
             correcao: 'ork conducao status <thread> mostra quem conduz; repita o pedido com --esperar <min> para seguir sozinho quando liberar',
         },
+        'conducao.acao-necessaria': {
+            porque: 'a sessao parou de proposito porque a proxima operacao exige a autoridade da conducao; reexecutar a fase antes desse comando so repete a mesma parada',
+            correcao: 'execute o comando exato do pedido no canal da conducao; depois retome a mesma fase',
+        },
         'hitl.formato': {
             porque: 'o pedido HITL saiu fora do formato obrigatorio: quem errou foi o emissor, e a correcao e reemitir com alternativas rotuladas, consequencia por alternativa e exatamente uma recomendada com o porque',
             correcao: 'ork fix open <thread> abre a rodada com a spec exata do formato',
@@ -386,10 +394,18 @@ exports.RETRY_EN = {
             porque: 'the lease belongs to another thread and will be released: the queue already serializes, so the action is to try again when the turn comes, never to jump the queue',
             correcao: '`ork lease list` shows the queue; the turn comes with nobody forcing it',
         },
+        'concurrency.lease-indeterminado': {
+            porque: 'the sandbox could not prove whether the lease owner is alive or dead: an invisible PID does not prove orphanhood, and rerunning could open two heavy operations',
+            correcao: 'wait with `--esperar`; if observation stays inconclusive, run the exact command from the open request through the conductor',
+        },
         'conducao.em-andamento': {
             porque: 'another conduction runs on the same worktree now: the turn comes when it finishes, and jumping the queue is the 2026-09-19 incident',
             correcao: '`ork conducao status <thread>` shows who conducts; repeat the request with `--esperar <min>` to go on by itself when it frees up',
         },
+        'conducao.acao-necessaria': {
+            porque: 'the session stopped on purpose because the next operation needs conductor authority; rerunning the phase before that command only repeats the same stop',
+            correcao: 'run the exact request command in the conductor channel; then resume the same phase',
+        },
         'hitl.formato': {
             porque: 'the HITL request came out of the required format: the issuer made the mistake, and the fix is to issue it again with labeled alternatives, a consequence per alternative and exactly one recommended, with the reason',
             correcao: '`ork fix open <thread>` opens the round with the exact format spec',

package/dist/locale-security-scan.js

@@ -2,15 +2,47 @@
 /**
  * The `securityScan` family of the message catalog: `ork security-scan` output (stdout summary, `report.md`) and its
  * usage error. pt-BR is the source; English is typed by it. No import from the core. Values that are data (tool names,
- * states, reasons, rule ids, paths) are printed as recorded, in both languages.
+ * states, reasons, rule ids, paths) remain unchanged in report.json. The human render translates the known reason
+ * vocabulary without rewriting the stored data.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SECURITY_SCAN_EN = exports.SECURITY_SCAN_PT_BR = void 0;
+const motivoEmPtBR = (reason) => {
+    const exact = new Map([
+        ['not in the catalog', 'não está no catálogo'], ['unbalanced JSON', 'JSON desbalanceado'],
+        ['truncated JSON', 'JSON truncado'], ['empty stream', 'fluxo vazio'], ['invalid JSON', 'JSON inválido'],
+        ['expected a JSON array', 'era esperado um array JSON'], ['expected a JSON object', 'era esperado um objeto JSON'],
+        ['unreadable output', 'saída ilegível'], ['commit-range-unresolved', 'intervalo de commits não resolvido'],
+        ['timeout', 'tempo esgotado'], ['no-requirements-file', 'nenhum arquivo requirements'],
+        ['zero-commits-scanned', 'nenhum commit varrido'], ['disabled', 'desabilitada'], ['unsupported-ci', 'CI não suportada'],
+    ]);
+    const conhecida = exact.get(reason);
+    if (conhecida !== undefined)
+        return conhecida;
+    return reason
+        .replace(/not in the catalog/g, 'não está no catálogo')
+        .replace(/unbalanced JSON/g, 'JSON desbalanceado')
+        .replace(/truncated JSON/g, 'JSON truncado')
+        .replace(/empty stream/g, 'fluxo vazio')
+        .replace(/invalid JSON/g, 'JSON inválido')
+        .replace(/expected a JSON array/g, 'era esperado um array JSON')
+        .replace(/expected a JSON object/g, 'era esperado um objeto JSON')
+        .replace(/unexpected "([^"]+)" outside a JSON value/g, '"$1" inesperado fora de um valor JSON')
+        .replace(/missing key "([^"]+)"/g, 'chave "$1" ausente')
+        .replace(/tool reported "([^"]+)"/g, 'a ferramenta relatou "$1"')
+        .replace(/must be a list of strings/g, 'deve ser uma lista de strings')
+        .replace(/expected an object/g, 'era esperado um objeto')
+        .replace(/expected a list/g, 'era esperada uma lista')
+        .replace(/\(no fingerprint\)/g, '(sem fingerprint)')
+        .replace(/missing-output/g, 'saída-ausente');
+};
 exports.SECURITY_SCAN_PT_BR = {
     usage: 'uso: ork security-scan [--base <ref>] [--json] [--check classic|agile]',
     // RM-072 (D9): o modo da varredura aceita so os dois valores.
     checkInvalido: (valor) => `--check inválido: ${valor === null ? '(sem valor)' : JSON.stringify(valor)} (aceitos: classic, agile)`,
     unknownFlag: (flag) => `opção desconhecida: ${flag}`,
+    error: (message) => motivoEmPtBR(message),
+    reason: (reason) => motivoEmPtBR(reason),
     // report.md
     title: 'Varredura de segurança',
     headBase: (head, base) => `HEAD \`${head.slice(0, 12)}\`, base \`${base ? base.slice(0, 12) : '(não resolvida)'}\``,
@@ -42,6 +74,8 @@ exports.SECURITY_SCAN_EN = {
     usage: 'usage: ork security-scan [--base <ref>] [--json] [--check classic|agile]',
     checkInvalido: (valor) => `invalid --check: ${valor === null ? '(no value)' : JSON.stringify(valor)} (accepted: classic, agile)`,
     unknownFlag: (flag) => `unknown option: ${flag}`,
+    error: (message) => message,
+    reason: (reason) => reason,
     title: 'Security scan',
     headBase: (head, base) => `HEAD \`${head.slice(0, 12)}\`, base \`${base ? base.slice(0, 12) : '(unresolved)'}\``,
     generatedAt: (iso) => `Generated at ${iso}`,