@orkastery/cli 0.6.0 → 0.6.2

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

@@ -446,7 +446,7 @@ exports.OPERACAO_RESTANTE_PT_BR = {
         },
     },
     mcp: {
-        uso: 'uso: ork mcp serve|install --project <raiz absoluta> --host codex|claude-code [--ship-transport github-ssh|forja-ssh|forja-https|bare-local] [--ssh-fingerprint SHA256:... somente install forja-ssh] [--child-permissions interactive|worktree] [--owner-permissions interactive|orchestrate somente install Codex] [--dry-run somente install]',
+        uso: 'uso: ork mcp serve|install --project <raiz absoluta> --host codex|claude-code|grok [--ship-transport github-ssh|forja-ssh|forja-https|bare-local] [--ssh-fingerprint SHA256:... somente install forja-ssh] [--child-permissions interactive|worktree] [--owner-permissions interactive|orchestrate somente install Codex] [--dry-run somente install]',
         erro: (detalhe) => `mcp: ${detalhe}`,
         simulacao: 'Simulacao: nenhuma escrita.',
         preparada: 'Configuracao MCP preparada.',
@@ -921,7 +921,7 @@ exports.OPERACAO_RESTANTE_EN = {
         },
     },
     mcp: {
-        uso: 'usage: ork mcp serve|install --project <absolute root> --host codex|claude-code [--ship-transport github-ssh|forja-ssh|forja-https|bare-local] [--ssh-fingerprint SHA256:... only for install with forja-ssh] [--child-permissions interactive|worktree] [--owner-permissions interactive|orchestrate only for Codex install] [--dry-run only for install]',
+        uso: 'usage: ork mcp serve|install --project <absolute root> --host codex|claude-code|grok [--ship-transport github-ssh|forja-ssh|forja-https|bare-local] [--ssh-fingerprint SHA256:... only for install with forja-ssh] [--child-permissions interactive|worktree] [--owner-permissions interactive|orchestrate only for Codex install] [--dry-run only for install]',
         erro: (detail) => `mcp: ${detail}`,
         simulacao: 'Simulation: no writes.',
         preparada: 'MCP configuration prepared.',

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',
@@ -211,6 +219,24 @@ exports.RETRY_PT_BR = {
     correcoesNaRodada: (n, rodada, veredito) => `${n} correcao(oes) na rodada ${rodada}` + (veredito !== null ? `; CHECK-REVERIFY: ${veredito}` : ''),
     semDespachoFalho: (fase, thread) => `nao ha despacho falho registrado em ${fase} com prompt gravado: ` +
         `rode a fase de novo com \`ork phase run ${thread} ${fase} --prompt "..."\``,
+    perfilPedidoRecusado: (id, runtime, motivo, detalhe) => `perfil pedido "${id}" (${runtime}) preservado, mas indisponivel por ${motivo}: ${detalhe}. ` +
+        'Nenhuma outra conta foi usada.',
+    correcaoDoPerfilPedido: (id, runtime, motivo, thread) => {
+        if (motivo === 'runtime.auth-missing')
+            return `refaca o login de assinatura do perfil "${id}" no ${runtime}, rode ` +
+                `\`ork accounts check ${id}\` e repita \`ork retry run ${thread}\``;
+        if (motivo === 'runtime.quota-exhausted')
+            return `aguarde o perfil "${id}" voltar a ativo em \`ork accounts list\` e ` +
+                `repita \`ork retry run ${thread}\`; para autorizar outra conta, rode a fase novamente sem \`--perfil\``;
+        if (motivo === 'runtime.profile-invalid')
+            return `rode \`ork accounts list\` e restaure o perfil "${id}" no runtime ${runtime}, ` +
+                'ou rode a fase novamente com um perfil valido ou sem `--perfil`';
+        if (motivo === 'cost.violation')
+            return `refaca o login de assinatura do perfil "${id}", rode ` +
+                `\`ork accounts check ${id}\` e repita \`ork retry run ${thread}\`; perfil de provider pago nunca despacha`;
+        return `confira o runtime ${runtime} e o perfil "${id}" com \`ork accounts check ${id}\`; depois repita ` +
+            `\`ork retry run ${thread}\``;
+    },
     semConfianca: (motivo, cwd, thread) => `${motivo}: o runtime ainda nao confia em ${cwd}; nada foi despachado. ` +
         `Rode \`cd ${cwd} && claude\`, aceite a confianca e repita \`ork retry run ${thread}\``,
     /** RM-063 (F3): a sessao viva na thread; redespachar abriria a segunda na mesma worktree. */
@@ -254,7 +280,8 @@ exports.RETRY_PT_BR = {
         pulos: { 'sem-fallback': 'o bloco nao tem fallback de runtime',
             'adaptador-ausente': 'nenhum fallback tem adaptador instalado neste projeto',
             'fallback-sem-destino': 'nenhum alvo do fallback do bloco tem perfil disponivel',
-            'sem-outro-perfil': 'o runtime nao tem outro perfil disponivel' },
+            'sem-outro-perfil': 'o runtime nao tem outro perfil disponivel',
+            'cota-sem-sinal-tipado': 'o runtime ainda nao tipa a cota esgotada e fica fora da troca automatica de conta' },
         resultados: { redespachada: 'redespachada', falhou: 'falhou', pulado: 'pulado', interrompido: 'interrompido' },
         linhaDoDegrau: (n, tipo, resultado, motivo) => `degrau ${n} (${tipo}): ${resultado}${motivo ? ` (${motivo})` : ''}`,
         noPlano: (n, tipo) => `  escada          degrau ${n} de 3, ${tipo}`,
@@ -367,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',
@@ -466,6 +501,24 @@ exports.RETRY_EN = {
     correcoesNaRodada: (n, rodada, veredito) => `${n} fix(es) in round ${rodada}` + (veredito !== null ? `; CHECK-REVERIFY: ${veredito}` : ''),
     semDespachoFalho: (fase, thread) => `no failed dispatch with a written prompt is recorded in ${fase}: ` +
         `run the phase again with \`ork phase run ${thread} ${fase} --prompt "..."\``,
+    perfilPedidoRecusado: (id, runtime, motivo, detalhe) => `requested profile "${id}" (${runtime}) was preserved but is unavailable because of ${motivo}: ${detalhe}. ` +
+        'No other account was used.',
+    correcaoDoPerfilPedido: (id, runtime, motivo, thread) => {
+        if (motivo === 'runtime.auth-missing')
+            return `sign profile "${id}" back in to its ${runtime} subscription, run ` +
+                `\`ork accounts check ${id}\`, and repeat \`ork retry run ${thread}\``;
+        if (motivo === 'runtime.quota-exhausted')
+            return `wait until profile "${id}" is active again in \`ork accounts list\`, then ` +
+                `repeat \`ork retry run ${thread}\`; to authorize another account, run the phase again without \`--perfil\``;
+        if (motivo === 'runtime.profile-invalid')
+            return `run \`ork accounts list\` and restore profile "${id}" under runtime ${runtime}, ` +
+                'or run the phase again with a valid profile or without `--perfil`';
+        if (motivo === 'cost.violation')
+            return `sign profile "${id}" back in through the subscription, run ` +
+                `\`ork accounts check ${id}\`, and repeat \`ork retry run ${thread}\`; a paid-provider profile is never dispatched`;
+        return `check runtime ${runtime} and profile "${id}" with \`ork accounts check ${id}\`; then repeat ` +
+            `\`ork retry run ${thread}\``;
+    },
     semConfianca: (motivo, cwd, thread) => `${motivo}: the runtime does not trust ${cwd} yet; nothing was dispatched. ` +
         `Run \`cd ${cwd} && claude\`, accept the trust and repeat \`ork retry run ${thread}\``,
     sessaoAindaViva: (sessao, thread) => `session ${sessao} is still working on the thread in the runtime; nothing was ` +
@@ -505,7 +558,8 @@ exports.RETRY_EN = {
             'outro-perfil': 'another runtime profile' },
         pulos: { 'sem-fallback': 'the block has no runtime fallback', 'adaptador-ausente': 'no fallback has an adapter installed in this project',
             'fallback-sem-destino': 'no target of the block fallback has an available profile',
-            'sem-outro-perfil': 'the runtime has no other available profile' },
+            'sem-outro-perfil': 'the runtime has no other available profile',
+            'cota-sem-sinal-tipado': 'the runtime does not type the exhausted quota yet and stays out of the automatic account switch' },
         resultados: { redespachada: 'dispatched again', falhou: 'failed', pulado: 'skipped', interrompido: 'interrupted' },
         linhaDoDegrau: (n, tipo, resultado, motivo) => `step ${n} (${tipo}): ${resultado}${motivo ? ` (${motivo})` : ''}`,
         noPlano: (n, tipo) => `  ladder          step ${n} of 3, ${tipo}`,

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}`,

package/dist/locale-ship.js

@@ -161,11 +161,15 @@ exports.SHIP_PT_BR = {
         situacoes: { 'proposto': 'proposto', 'agendado': 'agendado', 'vigente': 'vigente', 'expirado': 'expirado', 'revogado': 'revogado',
             'encerrado': 'encerrado' },
         origens: { 'envelope': 'pela lista do envelope', 'proposta': 'pela proposta que espera o dono', 'despacho': 'pelo log de despachos do arco',
-            'correlacao': 'pelo último despacho da thread' },
+            'correlacao': 'pelo último despacho da thread', 'rede': 'pela rede do arco' },
         doArco: (thread, arco, situacao, origem) => `noctum.guarda.thread-do-arco: a thread ${thread} é trabalho do arco ${arco} (${situacao}, ${origem})`,
         doArcoCorrecao: (arco) => `a entrega desta thread é do passo da entrega do arco ${arco}: o SHIP e o MASTER dela são do arco (ork noctum status ${arco})`,
         arcoIlegivel: (thread, arco, motivo) => `noctum.guarda.arco-ilegivel: o último despacho da thread ${thread} foi do arco ${arco}, e o arco não se lê (${motivo})`,
         arcoIlegivelCorrecao: (arco) => `inspecione o arco antes de entregar a thread por fora dele (ork noctum status ${arco})`,
+        redeIlegivel: (thread, arco, motivo) => `noctum.guarda.rede-ilegivel: a thread ${thread} é trabalho do arco ${arco}, encerrado nesta máquina, e a rede não se lê (${motivo})`,
+        redeIlegivelCorrecao: (arco) => `restaure a leitura da rede antes de entregar a thread por fora do arco (ork noctum status ${arco})`,
+        redeDoArco: (thread, arco, estado, trabalho) => `noctum.guarda.thread-do-arco: a thread ${thread} é o trabalho ${trabalho} do arco ${arco}, ainda ${estado} na rede`,
+        redeDoArcoCorrecao: (arco) => `espere o trabalho terminar na rede ou entregue-o pelo passo da entrega do arco ${arco} (ork noctum status ${arco})`,
         retencao: (thread, arco, situacao) => `noctum.guarda.thread-do-arco: o arco ${arco} (${situacao}) despachou a thread ${thread} por último; a batida e a Sentinela ` +
             'não a despacham, não a retomam nem a mesclam até um despacho fora do arco ou um arco novo que a liste',
         // A2 do CHECK: o arco terminou, e a sessão que ele despachou ainda conduz a thread.
@@ -452,11 +456,15 @@ exports.SHIP_EN = {
         situacoes: { 'proposto': 'proposed', 'agendado': 'scheduled', 'vigente': 'in force', 'expirado': 'expired', 'revogado': 'revoked',
             'encerrado': 'closed' },
         origens: { 'envelope': 'by the envelope list', 'proposta': 'by the proposal waiting for the owner', 'despacho': 'by the arc dispatch log',
-            'correlacao': 'by the last dispatch of the thread' },
+            'correlacao': 'by the last dispatch of the thread', 'rede': 'by the arc network' },
         doArco: (thread, arco, situacao, origem) => `noctum.guarda.thread-do-arco: thread ${thread} is work of arc ${arco} (${situacao}, ${origem})`,
         doArcoCorrecao: (arco) => `this thread is delivered by the delivery step of arc ${arco}: its SHIP and MASTER belong to the arc (ork noctum status ${arco})`,
         arcoIlegivel: (thread, arco, motivo) => `noctum.guarda.arco-ilegivel: the last dispatch of thread ${thread} came from arc ${arco}, and the arc cannot be read (${motivo})`,
         arcoIlegivelCorrecao: (arco) => `inspect the arc before delivering the thread outside it (ork noctum status ${arco})`,
+        redeIlegivel: (thread, arco, motivo) => `noctum.guarda.rede-ilegivel: thread ${thread} is work of arc ${arco}, closed on this machine, and its network cannot be read (${motivo})`,
+        redeIlegivelCorrecao: (arco) => `restore network reading before delivering the thread outside the arc (ork noctum status ${arco})`,
+        redeDoArco: (thread, arco, estado, trabalho) => `noctum.guarda.thread-do-arco: thread ${thread} is work ${trabalho} of arc ${arco}, still ${estado} on the network`,
+        redeDoArcoCorrecao: (arco) => `wait for the work to finish on the network or deliver it through the delivery step of arc ${arco} (ork noctum status ${arco})`,
         retencao: (thread, arco, situacao) => `noctum.guarda.thread-do-arco: arc ${arco} (${situacao}) dispatched thread ${thread} last; the beat and the Sentinel ` +
             'do not dispatch, resume or merge it until a dispatch outside the arc or a new arc that lists it',
         sessaoDoArco: (thread, arco, situacao, sessao) => `noctum.guarda.thread-do-arco: arc ${arco} is ${situacao}, and session ${sessao} that it dispatched still conducts thread ${thread}: ` +