@orkastery/cli 0.5.3 → 0.6.0

package/dist/index.js

@@ -40,8 +40,12 @@ exports.avisoRoadmapSemAssociacao = avisoRoadmapSemAssociacao;
 exports.extrairOpcaoDeProjeto = extrairOpcaoDeProjeto;
 exports.main = main;
 const company_brain_cli_1 = require("./company-brain-cli");
+const conhecimento_1 = require("./conhecimento");
+const conhecimento_consulta_1 = require("./conhecimento-consulta");
 const estado_thread_1 = require("./estado-thread");
 const intelligence_graph_cli_1 = require("./intelligence-graph-cli");
+const cli_1 = require("./security-scan/cli");
+const check_modo_1 = require("./check-modo");
 const mcp_grafo_1 = require("./mcp-grafo");
 const maestro_cli_1 = require("./maestro-cli");
 const hitl_public_receipt_1 = require("./hitl-public-receipt");
@@ -86,6 +90,7 @@ const board_1 = require("./board");
 const hitl_1 = require("./hitl");
 const pulse_1 = require("./pulse");
 const pulse_resposta_1 = require("./pulse-resposta");
+const pulse_consentimento_1 = require("./pulse-consentimento");
 const pulse_cadencia_1 = require("./pulse-cadencia");
 const decisao_autonoma_1 = require("./decisao-autonoma");
 const hitl_contract_1 = require("./hitl-contract");
@@ -93,8 +98,10 @@ const orquestracao_1 = require("./orquestracao");
 const divida_1 = require("./divida");
 const ciclos_1 = require("./ciclos");
 const claims_1 = require("./claims");
+const claims_conferir_1 = require("./claims-conferir");
 const catalogo_1 = require("./catalogo");
 const doctor_1 = require("./doctor");
+const doctor_forja_1 = require("./doctor-forja");
 const preflight_1 = require("./preflight");
 const evalrunner_1 = require("./evalrunner");
 const gates_1 = require("./gates");
@@ -118,7 +125,7 @@ const horario_1 = require("./horario");
 const onboarding_1 = require("./onboarding");
 const experiencia_1 = require("./experiencia");
 const hosts_2 = require("./hosts");
-const init_2 = require("./init");
+const locale_1 = require("./locale");
 const memoria_1 = require("./memoria");
 const orkmind_1 = require("./orkmind");
 const indice_vetorial_1 = require("./indice-vetorial");
@@ -130,6 +137,9 @@ const ratelimit_1 = require("./ratelimit");
 const retry_1 = require("./retry");
 const prova_minima_1 = require("./prova-minima");
 const versao_1 = require("./versao");
+const noctum_cli_1 = require("./noctum-cli");
+const noctum_envelope_1 = require("./noctum-envelope");
+const noctum_modo_1 = require("./noctum-modo");
 const modos_1 = require("./modos");
 const modos_migracao_1 = require("./modos-migracao");
 const setup_1 = require("./setup");
@@ -137,12 +147,18 @@ const runtime_profiles_1 = require("./runtime-profiles");
 const claude_bg_1 = require("./adapters/claude-bg");
 const codex_1 = require("./adapters/codex");
 const conducao_1 = require("./conducao");
+const conducao_sentinela_1 = require("./conducao-sentinela");
+const autorizacao_duravel_1 = require("./autorizacao-duravel");
+const atualizar_branch_1 = require("./atualizar-branch");
+const conducao_batida_1 = require("./conducao-batida");
+const pulse_delivery_1 = require("./pulse-delivery");
 const phase_1 = require("./phase");
 const prompts_1 = require("./prompts");
 const sessoes_2 = require("./sessoes");
 const util_1 = require("./util");
 const ship_1 = require("./ship");
 const ci_1 = require("./ci");
+const dado_privado_1 = require("./dado-privado");
 const thread_1 = require("./thread");
 const docs_1 = require("./docs");
 const roadmap_reservas_1 = require("./roadmap-reservas");
@@ -150,6 +166,7 @@ const fabrica_estado_1 = require("./fabrica-estado");
 const branch_de_estado_1 = require("./branch-de-estado");
 const network_roadmap_1 = require("./network-roadmap");
 const fabrica_publicar_1 = require("./fabrica-publicar");
+const fabrica_batida_1 = require("./fabrica-batida");
 const maquina_1 = require("./maquina");
 const rede_1 = require("./rede");
 const rede_adesao_1 = require("./rede-adesao");
@@ -159,13 +176,19 @@ const rede_status_1 = require("./rede-status");
 const ledger_1 = require("./ledger");
 const tokens_1 = require("./tokens");
 const types_1 = require("./types");
+const dependencias_da_worktree_1 = require("./dependencias-da-worktree");
 const verify_1 = require("./verify");
+const fila_pesada_1 = require("./fila-pesada");
 const worktree_1 = require("./worktree");
 const claim_lint_1 = require("./claim-lint");
 const licoes_1 = require("./licoes");
 const demo_1 = require("./demo");
 const entrega_pr_1 = require("./entrega-pr");
+const ship_publicar_1 = require("./ship-publicar");
 const projeto_alvo_1 = require("./projeto-alvo");
+const worktree_local_1 = require("./worktree-local");
+const mcp_transportes_1 = require("./mcp-transportes");
+const postura_local_1 = require("./postura-local");
 /** A versao publicada em `@orkastery/cli`, lida do package.json (`versao.ts`). */
 // Antes de qualquer arquivo ou despacho: sem escrita de grupo nem de outros, que o sensor recusaria.
 (0, preflight_1.endurecerUmask)();
@@ -201,13 +224,22 @@ function parseArgs(argv) {
 function texto(v) {
     return typeof v === 'string' ? v : undefined;
 }
+/**
+ * RM-058 N2 (A1 da rodada 2 do CHECK): a fila de recursos pesados de um comando que verifica por dentro, pelo `--esperar`
+ * dele, com o aviso no stderr e o comando que a recusa sugere. Sem `--esperar`, vale o padrão curto do verify.
+ */
+function filaPesadaDoCli(args, operacao, comandoDeEsperar) {
+    const m = (0, locale_1.msg)().verify;
+    return { esperarMs: conducaoDoCli(args).esperarMs, comandoDeEsperar,
+        aoEsperar: (ocupantes) => console.error(m.filaPesadaEsperando(operacao, ocupantes.map((o) => m.filaPesadaOcupante(o.operacao, o.thread, (0, horario_1.formatarDataHora)(o.desde))).join('; '))) };
+}
 /**
  * I-36 (D2, D6): o que o CLI declara sobre a conducao. `--canal` (sem ele, o que a borda exporta),
  * `--correlacao` (conversa ou mensagem de origem) e `--esperar [minutos]` (sem valor, 30).
  */
 function conducaoDoCli(args) {
     if (args.opcoes.canal === true)
-        throw new Error('uso: --canal <claude-code|hermes|openclaw|codex|mcp|cli>');
+        throw new Error((0, locale_1.msg)().phase.canalUso);
     const bruto = args.opcoes.esperar;
     let esperarMs;
     if (bruto === true)
@@ -215,377 +247,49 @@ function conducaoDoCli(args) {
     else if (typeof bruto === 'string') {
         const minutos = Number(bruto);
         if (!Number.isFinite(minutos) || minutos <= 0 || minutos > 24 * 60)
-            throw new Error('uso: --esperar [minutos], de 1 a 1440 (sem valor, 30)');
+            throw new Error((0, locale_1.msg)().phase.esperarUso);
         esperarMs = Math.round(minutos * 60_000);
     }
     return { canal: (0, conducao_1.canalDoProcesso)(texto(args.opcoes.canal)), correlacao: texto(args.opcoes.correlacao) ?? null, esperarMs };
 }
-const AJUDA = `ork ${VERSAO}, nucleo de orquestracao do Orkastery
-
-Uso: ork [--projeto <nome|caminho>] <comando> [argumentos]
-
-  --projeto <nome|caminho>                  Projeto-alvo de qualquer comando (RM-052): vence ORK_PROJETO, que vence o
-                                            diretorio atual; nome ambiguo ou desconhecido recusa com os candidatos (saida 4)
-  projetos [--json]                         Projetos conhecidos desta maquina (~/.orkastery/projetos.json)
-  projetos registrar [caminho]              Registra a copia (init, thread new e fabrica entrar ja registram)
-  projetos esquecer <nome|caminho>          Tira do registro a copia que sumiu ou sobrou (nada no disco e apagado)
-
-  doctor                                    O que vale nesta maquina agora (sai != 0 se bloqueado)
-  init [--force] [--name N] [--abbrev A]    Gera o orkastery.yaml do repositorio
-  modos                                     Tabela dos ${modos_1.ORDEM_DOS_MODOS.length} modos de conducao vivos por #TAG
-
-  setup                                     Pauta da entrevista #setup: runtime/modelo/esforco
-                                            por bloco de cada modo (default claude-bg/opus/high; #Fast: sonnet)
-  onboarding [show|set <etapa>|reset [etapa]] Pauta e respostas do projeto (9 etapas)
-        [--conteudo JSON] [--por Q] [--json]  Segredos ficam ${onboarding_1.ONDE_FICAM_OS_SEGREDOS}
-        [--reset [etapa]]                    Reset seletivo ou total, idempotente
-  onboarding sync [--json]                  Publicação opcional na memória, com degradação
-  experiencia show [--json]                 Preferências efetivas; configure por onboarding set maestro --conteudo '{"owner":{"experience":true}}'
-  experiencia uninstall <host> [--dry-run] [--json]
-                                            Remove o bloco de Claude Code/Codex; sem --dry-run aplica a remoção
-  setup <modo>                              Config atual de cada bloco do modo
-  setup <modo> --bloco N [--runtime R]      Edita o bloco (runtimes: claude-bg, codex);
-        [--model M] [--effort E] [--por Q]       evento setup_configured no ledger do projeto
-        [--fallback R:M[:E],...]                  ordem de fallback de runtime do bloco (I-33)
-  accounts list [--json]                    Perfis de conta por runtime, sem segredo (I-33)
-  accounts add <id> --runtime R --dir D     Cria o perfil e roda o login do proprio CLI com o env
-        [--sem-login]                            do perfil (nunca copia credencial)
-  accounts remove <id>                      Desativa o perfil (diretorio e login ficam onde estao)
-  accounts check [<id>]                     Confere o login de cada perfil e marca o store
-  accounts esgotamentos [--desde 7d] [--json]
-                                            Despachos numa conta que outro projeto desta maquina viu esgotada
-                                            (RM-040), so leitura: conta opaca, perfil pelo id, sem diretorio
-  setup [<modo>] --reset                    Volta o modo (ou tudo) ao default
-  setup versionar                           Leva o setup que vale para orkastery.setup.json: por PR, vale em
-                                            todas as maquinas e passa a ser o arquivo editado (I-52)
-
-  thread new <nome> --modo <MODO>           Cria a thread, o slug de 3 partes e o ledger
-        [--exige-runtime-diferente]              o CHECK precisa de runtime que o GO nao usou
-        [--done "<criterio> :: <comando>"]       criterio de pronto EXECUTAVEL (use ;; para varios)
-        [--slug S] [--assunto A] [--worktree auto|DIR] [--dry-run]
-        [--sem-worktree]                         cria sem worktree (na branch base, o ship barra a entrega com
-                                                 push_direto_na_base: block, o padrão do ork init); com
-                                                 worktree.por_thread: true, a worktree nasce sem flag
-        [--roadmap RM-NNN]                       reserva o item do roadmap antes de criar (I-47)
-  thread list [--todas] [--json]            Threads NAO fechadas do projeto (--todas inclui as fechadas)
-  thread close <id> --motivo orfa|engano|superada --por Q --justificativa J
-  thread entrega <id> --arquivo A --sha256 H --por Q
-  thread status <thread-id> [--json]        Estado da thread, cruzado com o runtime
-
-  portfolio inspect <id> --json              Entidade, origem e ciclos com lacunas explícitas
-  creation start --input-file F --json       Criação durável com identidade do processo local
-  creation show|list|events [id] --json       Consulta journal e recuperação
-  creation resume|compensate <id> --expected-version N --json
-  portfolio create <product|project|initiative> <id> --title T [--parent ID]
-  portfolio list [product|project|initiative] [--parent ID] [--json]
-  portfolio show <id> [--json]              Catálogo prod -> proj -> init
-        [--constraints A;B] [--outcomes A;B] [--threads N]
-        [--execution-runtime R] [--validation-runtimes R1,R2]
-  objective ...                             Aposentado na I-43: as duas vigas viraram
-                                            --exige-runtime-diferente e --done de thread
-
-  phase run <thread-id> <FASE> --prompt "<texto>"
-        [--runtime R] [--model M]           Despacha a fase como background agent
-        [--effort E] [--dry-run]                 (runtime: CLI > setup do bloco > manifesto;
-                                             so --model assume --effort high; o trio
-                                             efetivo vai ao ledger como fato verificavel)
-        [--canal C] [--correlacao ID]        Canal de origem (sem ele, o que o host declara)
-        [--esperar [min]]                    Com a thread ja conduzida, espera a vez (sem: recusa na hora)
-        [--perfil ID]                        Conta do despacho (ork accounts list); inexistente, de outro
-                                             runtime, esgotado ou sem login recusa com motivo tipado
-  phase list <thread-id>                    Historico do ledger da thread
-                                            (mostra o modelo/esforco reais de cada fase)
-  ledger stats --desde 7d [--ate ISO]       Telemetria economica do ledger (intervalo [desde,ate))
-        [--thread T] [--modo M] [--runtime R] [--json]
-  ledger estimate <thread-id> --sem-ia H --ia-sem-ork H --por Q --metodo M --premissas P
-        [--incerteza I]                     Registra estimativas explicitas da fase PLAN
-
-  sessions [--all] [--global] [--json]      Inventário Claude e Codex da conta do processo e de cada perfil
-        [--exigir-limpo]                    Sai != 0 com fonte inválida ou sessão sem thread
-  sessions adopt <id> [--json]             Adota identidade real sem executar prompt
-  sessions event --tipo T --sessao ID       Ingere JSON limitado no stdin; observa sem aprovar gates
-  sessions watch --thread T [--sessao ID]   Observa somente a sessão selecionada; --once faz uma varredura
-  sessions limpar-fantasmas [--dry-run]     Solta do ork (sessao_morta no ledger) a sessao sem pid e sem processo;
-        [--json]                             nunca toca no runtime (RM-056)
-  sessions logs <sessao> [--linhas N]       Logs de uma sessao
-  sessions supersede <thread> <UUID> --fase F --runtime R  Confirma encerramento de sessão superada
-  sessions request <thread> <UUID> --fase F --runtime R --pergunta P  Abre pedido vinculado ao prompt nativo
-  sessions answer <thread> <pedido> --stdin --origem telegram --canal C --por ID --mensagem REF [--conta ID]  Confirma entrega autenticada
-  sessions reconcile <thread> <pedido>      Fecha envio pendente so com thread e pedido; consulta recibo, nunca reenvia
-  sessions stop <sessao>                    Para uma sessao
-  sessions attach <sessao>                  Imprime o comando de attach (precisa de TTY)
-  pulse [--json] [--registrar]             Fila unificada de atenção humana e retry de órfãs
-  pulse responder --resposta-stdin --origem telegram --canal C --por ID --mensagem REF [--conta ID]
-                                            Recebe o que o dono digitou no canal do resumo (P4EJ a, 1a 2c)
-  pulse cadencia [<tag>] [--por P] [--json] Mostra ou troca a cadencia do resumo: OrkPulseOn, OrkPulseOn-15m,
-                                            -30m, -60m ou OrkPulseOff; pergunta nova sai na hora (I-50)
-  sessions hitl [--json] [--so-paradas]     Radar de sessoes que exigem acao humana AGORA:
-        [--atencao N] [--sem-logs]              classifica o estado de cada sessao do runtime,
-        [--so-da-raiz] [--exigir-limpo]         le a pergunta que a sessao trava e diz o que
-                                                destrava (pega HITL de sessao SEM thread)
-
-  claims add <thread-id> <arquivo> --claim "<alegacao>" [--verificar "<comando>"] [--fase F]
-                                            Registra alegacao verificavel da thread
-  claims list <thread-id>                   Claims da thread e o estado de cada uma
-  decisao registrar <thread-id> --decidido D --porque P --como-mudar C --custo-agora A --custo-depois B
-        --criterio manifesto:CHAVE|ledger:REF|medicao:COMANDO --quem Q --evidencia E [--razao R] [--reverte ID]
-                                            Decisao tomada sem perguntar: chega ao dono no resumo
-  decisao placar <thread-id> [--json]       Decididas contra perguntas por fase, reversoes e o limiar
-  claims verificar <thread-id> <claim-id> --comando "<comando>"
-                                            Anexa o comando que comprova uma claim ja feita
-  claims retirar <thread-id> <claim-id> --motivo "<motivo>"
-                                            Retira a alegacao (o historico fica no claims.jsonl)
-  claims ausente <thread-id> --paths A,B --motivo "<motivo>" [--commit SHA]
-                                            Ciclo sem CHECK: declara no ledger o que ficou sem prova
-  verify <thread-id> [--baseline]           Reexecuta claims e verify do manifesto no HEAD real
-        [--so-claims]                       --baseline grava o estado do mundo antes do GO
-        [--canal C] [--esperar [min]]       So executa com a conducao da thread (sai 3 se outra conduz)
-  ci prepare <thread-id>                    Exporta claims/comandos para a candidata (.ork-ci/<thread>.json)
-  ci run [<thread-id>] [--bundle ARQ]       Executa o CHECK no runner independente
-        [--branch B]                         acha o bundle da thread pelo nome da branch (o CI usa)
-  ci status [--sha SHA] [--remoto origin]   Consulta o check exato publicado no GitHub
-
-  gate next <thread-id> [--proximo FASE]    Gate de tokens: mesma sessao ou nova sessao
-        [--ocupacao 0..1] [--fonte F] [--transcript ARQ] [--janela N] [--refazer]
-  gate request <thread-id> [--motivo M]     Apresenta pedido HITL correlacionado à pausa
-        [--formato telegram|terminal]           no contrato curto, com o codigo estavel para responder
-  gate answer <thread-id> <pedido>          Recebe envelope do ingresso humano autenticado
-        --resposta-stdin --por Q --mensagem ID --origem telegram [--canal hermes|openclaw]
-        [--conta ID]  conta homologada do canal; obrigatoria no canal openclaw
-  gate approve                             Aposentado: aprovação sem pedido é recusada
-
-  retry policy [--motivo M] [--json]        Politica de retry por motivo tipado de gate
-  retry plan <thread-id> [--motivo M]       O que o ork faria pelo ultimo gate reprovado
-        [--fase F] [--json]                      (calcula, nao executa, nao gasta tentativa)
-  retry run <thread-id> [--reverify]        Executa a acao tipada do ultimo gate reprovado
-        [--por Q] [--dry-run]                    (--por autoriza quando o bloco do modo pausa)
-  retry list [--json]                       Fila DURAVEL de rate limit do projeto
-  retry resume [--id R1] [--agora ISO]      Retoma a fase morta por rate limit na janela seguinte
-        [--ocupacao 0..1] [--forcar] [--dry-run] (playbooks: mesma-sessao, nova-sessao, escalada)
-  retry cancel <id> --motivo M              Tira um pedido da fila, com motivo registrado
-  retry parse --stderr "<texto>"            Le o horario de reset do stderr do adapter
-
-  fix open <thread-id> [--so-claims]        GO-FIX: deriva a spec exata do CHECK reprovado
-        [--reverify] [--json]                    (uma correcao por motivo tipado, tipo A ou B)
-  fix list <thread-id> [--rodada N]         Correcoes da rodada e o veredito de cada uma
-  fix reverify <thread-id> [--rodada N]     CHECK-REVERIFY com veredito POR correcao
-        [--parcial] [--json]                     (--parcial e RECUSADO se houver tipo B)
-
-  handoff export <thread-id>                Handoff triado CRITICO/IMPORTANTE/RESUMIVEL
-        [--proxima-fase FASE] [--slug S]
-  handoff recall <thread-id> <ponteiro>     Resolve um ponteiro path#ancora de volta ao conteudo
-
-  recall <thread-id> --fase FASE            Recuperacao TARDIA: resolve so os ponteiros do
-        [--id ptr-N] [--todos] [--forcar]        momento (retrieve_when), nunca a janela inteira
-        [--sem-conteudo] [--json]                (orkmind por tag, files por path#ancora)
-
-  brain status|inventory|get|query|receipts|context|dossie|sync|reconcile|apply|rollback|bind
-  brain dossie --thread T [--decisao ID]    Dossie de decisao: vinculo, contexto citavel, alternativas,
-                                            quem decidiu e evidencia, com os ids do Brain (so leitura)
-  memory status [--json] [--sondar]         Regime efetivo (files|orkmind), tenant, degradacao e embeddings
-                                            (--sondar: uma chamada real de embedding, com a latencia)
-  memory sync [<thread-id>] [--json]        Publica decisoes, policies, handoff, licao e roadmap
-  memory inventory --escopo <threads> [--json]                 Inventaria fontes canonicas e tenants excluidos, sem gravar
-  memory migrate --operadora <thread> --escopo <threads> [--dry-run] [--json]                   Migra handoffs por G3, com pacote integral e readback
-  memory search --tags '<json>' [--colecao C]  Busca deterministica por tag (mandatory sempre volta)
-        [--thread ID] [--restrito] [--janela N] [--limite N] [--json]
-  memory search --texto "<frase>"          Busca por significado (I-38): vetor + FTS por RRF no tenant,
-        [--modo hibrido|vetor|fts]               NAO deterministica; nao combina com --tags nem --thread
-        [--colecao C] [--limite N] [--json]
-  memory index [--modelo primario|fallback|todos] Indice vetorial local do tenant (I-38), idempotente,
-        [--dry-run] [--json]                     com tokens e custo estimados; --dry-run nao chama o provider
-
-  grafo indexar [--verificar] [--forcar]    Indice do grafo de codigo do HEAD limpo (RM-031 KG3) no estado do projeto:
-        [--json]                                 pastas 0700, chave por revisao e extrator, idempotente; incremental (KG4)
-                                                 a partir do indice ancestral, ou completo com o motivo; --forcar extrai
-                                                 completo; --verificar confere contrato, bytes, determinismo e o incremental
-                                                 contra a completa; precisa de typescript e micromark
-  grafo status [--json]                     Indices guardados, o do HEAD, os analisadores e o tamanho
-  grafo contexto <thread> [--json]          Pacote da thread com evidencias e medida em bytes [--teto-bytes N]
-  grafo vizinhos <no> [--profundidade N]    Vizinhanca de arquivo ou simbolo, com extrator e evidencia de cada aresta
-        [--sentido entrada|saida|ambos] [--tipo T,...] [--limite N] [--json]
-  grafo chamadores <simbolo>                Quem chama (arestas calls que chegam) [--profundidade N] [--limite N] [--json]
-  grafo importadores <arquivo|simbolo>      Quem importa (arestas imports que chegam) [--profundidade N] [--limite N] [--json]
-  grafo caminho <de> <para>                 Menor caminho pelas arestas [--sentido saida|entrada|ambos] [--tipo T,...] [--json]
-        [--json --teto-bytes N]                  Nas quatro consultas (KG5): JSON compacto de no maximo N bytes; as arestas mais
-                                                 longe do alvo saem ate caber, e o caminho que nao cabe recusa
-  grafo amostra [--por-estrato N]           Amostra de arestas para auditoria manual; --conferir ARQ confere a auditada
-  grafo limpar [--tudo] [--json]            Apaga os indices que nao sao do HEAD e as sobras com mais de uma hora
-
-  ship <thread-id> --para <branch>          Merge --no-ff serializado por lease e push PROVADO
-  ship registrar-pr <thread-id>|--todas    A entrega feita por PR vira ship_done: merge ship(<thread>) na base
-        [--remoto R] [--json]                    remota e CI verde no head do PR; depois, ork master <thread> --aceitar-omissao
-        [--repo <dono/nome> --pr <n>]            PR mesclado em repositorio externo de ci.external_repositories
-        [--dry-run]                              Ensaio: as mesmas conferencias, sem gravar ship_done, fase nem fabrica
-        [--de <branch>] [--remoto origin] [--autorizar-push <quem>] [--sem-push] [--dry-run]
-
-  board [--all] [--sem-remoto]              Visao unica das threads (todos os perfis com --all); com a
-                                            fabrica compartilhada, tambem as outras maquinas (I-51)
-  board plan                                Escalonador: quem avanca agora, quem espera e por que
-
-  orquestracao status [--all] [--json]      Monitor PROATIVO de pausas e impedimentos: quem esta
-        [--atencao N] [--so-paradas]             parado, esperando o que, ha quanto tempo e o que
-        [--sem-runtime] [--exigir-limpo]         destrava (alias curto: ork monitor)
-
-  worktree ensure <thread-id>               Garante a worktree da thread (base resolvida pelo ork)
-  worktree sync <thread-id> [--dry-run]     Rebasa a branch da thread quando a base avancou
-  worktree audit <thread-id>                Confere a worktree no proprio git (sai != 0 se divergir)
-  worktree release <thread-id> [--forcar]   Remove a worktree e limpa o registro
-
-  activation plan|status|enable|disable     Escrita escopada com aceite, hash, leases e recibo
-  lease list                                Leases, familias e as filas (merge e colisao de regiao)
-  lease acquire <nome> --thread T --motivo M   Toma um lease tipado (entra na fila se colidir)
-  lease release <nome> [--thread T] [--forcar]
-  conducao status <thread-id> [--json]      Quem conduz a thread agora (canal, sessao, fase, desde)
-  conducao assumir <thread-id> --por Q --motivo M
-                                            Handoff: encerra a conducao atual pelo runtime e registra quem assumiu
-
-  master propor <id> --score N --justificativa J --por <agente>
-  master batch --aceitar <thread:assinatura,...> --por <humano>
-  master migrar --dry-run --por Q           Inspeciona correções sem alterar originais
-  master digest <enviar|preview|responder>  Digest semanal com recibos do host
-  master <thread-id> --score 0-5 --justificativa "<texto>" --por <seu-nome>
-        [--classe C[,C]] [--resumo R] [--refazer]
-                                            Fecha a thread: POSTMORTEM + MASTER log + score (so do terminal;
-                                            de processo de host e recusado com master.prova-de-canal)
-  master pedir <thread-id> [--formato telegram|terminal|json]
-                                            Pede a nota ao dono com codigo curto; ele responde pelo Telegram
-                                            (<codigo> <0 a 5> <porque>) e a nota vai ao ledger com o recibo (RM-048)
-  master [--todas] [--json]                 As entregas, com o indice derivado do ledger
-  master <thread-id> --aceitar-omissao      Aceita por omissao SO a entrega desta thread, com registro (ou --thread T)
-        [--dry-run] [--json]                     --dry-run lista o que seria fechado, sem gravar
-  master --aceitar-omissao [--dry-run] [--json]
-                                            Aceita TODAS as entregues por omissao, listando cada uma
-                                            (de processo de agente com mais de uma, avisa em stderr)
-  master classes                            As classes de falha fixas do POSTMORTEM
-  licoes [--json]                           O que volta no GOAL e no PLAN da proxima thread (POSTMORTEM e
-                                            MASTER) e as propostas de policy por recorrencia (I-55)
-
-  demo [--manter] [--dir D]                 A promessa em 30 s: uma afirmacao falsa reprovada e a corrigida aceita,
-                                            offline, num repositorio temporario (I-56)
-  ciclos                                    Variantes de ciclo de "ork thread new --ciclo"
-  modos --do-pedido "<texto>" [--json]      Le a #TAG do pedido do builder (usado pelos adaptadores)
-  modos migrar [--dry-run] [--por Q]        Tira modo aposentado do orkastery.yaml e do setup.json
-        [--json]                             (idempotente, com backup; nao toca em historico)
-
-  prompt list                               Templates de prompt (embutidos e os do projeto)
-  prompt lint [--template ID]               Reprova template quebrado antes de ele virar despacho
-  prompt render <thread-id> --fase F        Mostra o prompt exato, com o sha256 que vai ao ledger
-        [--pedido "<texto>"] [--template ID]
-  prompt render --exemplo --fase F --modo M Renderiza sem thread nenhuma, para revisar o texto
-
-  roadmap status [--json]                   Status report unico do roadmap: grupos com icones, #HITL no que espera
-                                            voce e o fecho com o que precisa de voce e o que vem a seguir (RM-048)
-  roadmap reservas [--json] [--remoto R]    Quem esta com cada item do roadmap, lido da branch ork/roadmap-reservas
-        [--soltar-orfas]                     marca a reserva de thread ja fechada (orfa) e, com a opcao, solta
-                                             ou passa para outra thread aberta do mesmo item, com registro
-  roadmap pegar <RM-NNN> [--thread T]       Reserva o item para esta maquina (push atomico: o primeiro vence)
-        [--nota N] [--por Q] [--maquina M]       maquina = --maquina, ORK_MAQUINA ou o hostname
-        [--forcar --motivo M]                    tomar a reserva de outra maquina fica registrado
-  roadmap soltar <RM-NNN> [--forcar --motivo M]  Devolve o item
-  roadmap feat [--thread T] [--nota N]      Reserva o proximo numero de FEAT na mesma branch (push atomico: duas
-                                            maquinas nunca levam o mesmo numero; numero reservado nao volta)
-  fabrica [--json] [--sem-remoto]           O que cada maquina conduz, lido da branch ork/fabrica-estado (I-51)
-  fabrica entrar [--maquina NOME]           Esta maquina entra na fabrica compartilhada deste usuario, com
-                                            este nome (~/.orkastery/maquina.json), e publica o primeiro retrato
-  fabrica publicar [--forcar] [--json]      Grava o retrato desta maquina na branch (push atomico, sem forca);
-                                            depois de entrar, sai sozinho ao criar thread, despachar fase,
-                                            entregar e fechar, e a cada batida do pulse
-  fabrica sair                              Para de publicar daqui e tira o retrato desta maquina da branch
-  network status [--json] [--sem-remoto]    A Orkastery Network desta pessoa: as maquinas, de qualquer diretorio,
-                                            com a fonte, as lacunas e o que nao foi lido (RM-053)
-  network entrar [--maquina NOME]           Esta maquina entra na rede: repositorio privado <usuario>/orkastery-network
-        [--forja github|gitlab] [--repositorio [DONO/]NOME]  na forja (criado se falta) e o primeiro retrato;
-        [--forcar]                               --forcar toma um nome que outra instalacao usa (fica no commit)
-  network publicar [--forcar] [--json]      Grava o retrato desta maquina na casa da rede (push sem forca); depois de
-                                            entrar, sai sozinho na batida do pulse e nos eventos de thread
-  network sair                              Para de publicar daqui e tira o retrato desta maquina da casa
-  network roadmap [--projeto P] [--json]    Roadmap, reservas e threads de cada maquina de cada projeto, de qualquer diretorio:
-        [--sem-remoto]                           fonte e hora de cada parte, lacuna tipada no que nao leu. P = caminho do clone,
-                                                 github:dono/repo, gitlab:grupo/repo ou nome conhecido; sem clone, le a forja (RM-054)
-  docs verificar [--json] [--pr]            Documentacao de produto e roadmap contra o codigo e o git; no PR (--pr),
-                                            o merge de outra thread e o indice que divergem da main so avisam
-                                            (padrao do dono: frontmatter, leitura, paridade; sai != 0 com erro)
-  docs sincronizar [--escrever]             Fatos do ledger e do git para o roadmap (merge, fase) e indices;
-                                            sem --escrever so mostra; nunca muda status por passagem de tempo
-        [--so RM-NNN[,RM-MMM]] [--todos]     so esses itens (e os indices); na worktree de uma thread com item,
-                                             o padrao e o item dela; --todos volta a todo item (RM-037)
-  docs init                                 Cria padroes, modelos, indices e o lint de Markdown no projeto
-
-  mcp serve --project RAIZ --host HOST       Servidor MCP stdio deste projeto (codex|claude-code)
-  mcp install --project RAIZ --host HOST     Prepara MCP; aceita --dry-run, --ship-transport, --child-permissions e --owner-permissions (Codex)
-
-  adapter list                              Adaptadores de host (Camada 1) e o destino de cada um
-  adapter show <host>                       Os 3 pitfalls de instalacao do host
-  adapter install <host> [--dir D]          Instala o adaptador (claude-code|codex|hermes|openclaw)
-        [--dry-run] [--force]                    divergencia segura resolve sozinha; o resto pergunta
-        [--aceitar-catalogo <arquivo>]           sobrescreve a copia com o catalogo, arquivo a arquivo
-        [--manter-copia <arquivo>]               deixa a copia como esta, arquivo a arquivo
-
-  eval [--skill S] [--canario C]            Canarios de comportamento + corpus das skills finas
-        [--so-canarios] [--so-skills] [--json]   (sai != 0 em qualquer falha)
-
-  audit packs [--estagio E] [--pack P]      Os 7 packs, o estagio que os ativa e a postura
-  audit run <pack> [--profile P]            Monta o prompt do pack e despacha pelo runtime adapter
-        [--since Nd] [--tudo] [--effort E] [--model M] [--agora "<quem>"] [--forcar] [--dry-run]
-  audit list                                Rodadas de auditoria do projeto
-  audit show <rodada> [--ledger]            Contexto, achados e propostas de uma rodada
-  audit prompt <pack> [--since Nd]          O prompt exato do pack, com o sha256 que vai ao ledger
-  audit lint                                Reprova template de auditoria quebrado (auditors/)
-  audit ingest <rodada> --arquivo J         Registra em lote os achados que o auditor escreveu
-  audit finding add <rodada> --regra R      Registra um achado com evidencia, claim e proposta
-        --titulo T --arquivo caminho:linha --impacto I --fix F --estimativa E
-        [--severidade critico|maior|menor] [--irreversivel "<passo>"] [--verificar "<comando>"]
-  audit verify <rodada>                     Reexecuta as claims dos achados (auditor sem self-report)
-  audit report <rodada> [--publicar]        Relatorio com o bloco OBRIGATORIO de propostas
-  audit divida [--pack P] [--todos]         Board de divida: propostas abertas e recorrencia
-  audit surface [<dir>] [--regra SPn]       Varredura DETERMINISTICA da superficie de ataque de rede
-        [--limite N] [--json]                    (SP8..SP12; sai != 0 quando ha achado)
-  audit surface --registrar <rodada>        Grava os achados da varredura no board da rodada
-  audit finding estado <id> <estado>        Carimba o achado (aberto|adiado|resolvido|descartado)
-
-  thread new <nome> --from-finding <ID>     Abre a thread a partir de um achado de auditoria
-        [--modo M] [--worktree auto] [--sem-worktree] [--dry-run]
-                                                 (evidencia, claim e proposta viajam junto; a worktree segue
-                                                 worktree.por_thread como no thread new)
-
-Regimes de memoria: files (fallback honesto) e orkmind (bloco B6, base propria por tenant
-declarada em memory.database_url_env pelo NOME da variavel de ambiente, sem fallback).
-Colecoes gravadas no OrkMind: decision, handoff, rule, learning, roadmap (source=agent,
-nunca mandatory: regra critica so nasce de humano autenticado).
-
-Retry tipado (bloco B3): reexecutar, corrigir-dirigido, sincronizar-worktree,
-escalar-esforco, esperar-janela, escalar-humano, sem-retry. Violacao de custo
-(cost.violation) NUNCA recebe retry automatico. O limite de escalacao do manifesto
-(retry.max_tentativas) pausa QUALQUER modo, inclusive #Auto.
-
-Monitor de orquestracao (ork orquestracao status / ork monitor): duas naturezas de parada.
-pausa-humana e a parada PREVISTA pelo modo (o bloco fechou e espera veredito, com o
-pausaSobre do bloco dizendo o que o humano decide); impedimento e a nao prevista
-(lease.busy, runtime.rate-limited, concurrency.limite e os demais gates tipados). Tudo e
-DERIVADO de thread.json, ledger.jsonl e das filas em disco: o monitor le, nunca grava.
---exigir-limpo sai != 0 enquanto houver thread parada, para virar watchdog do orquestrador.
-
-Fases: GOAL PLAN GO CHECK SHIP MASTER. Modos: ${modos_1.ORDEM_DOS_MODOS.map((m) => modos_1.MODOS[m].tag).join(' ')}.
-Familias de lease: main-tree, worktree-write:<thread>, path:<glob>, board:<card>, service:<porta>.
-Ciclos: greenfield, merge-branch, goal-plan, gap, feature-xl-faseada.
-Fontes de medida do gate de tokens: runtime_reported, estimated, informada, unavailable.
-Hosts de Camada 1: claude-code, codex, hermes, openclaw. Canarios: fx-happy, fx-hallucination,
-fx-stale-base, fx-wiki-destroy, fx-schema-drift, fx-concurrency.
-Packs de auditoria: clean-code, reuse, architecture, data-model, ux, security-privacy, process.
-Superficie de ataque de rede (SP8..SP12, varredura deterministica): rota sem auth, endpoint de
-administracao exposto, rota sem rate limit, CORS permissivo, rota sem esquema de payload.
-Estagios do produto: nascente, crescendo, maduro (hardening gradual, visao secao 5.2).
-`;
+/** RM-061 (F2a): o que a ajuda interpola; a redacao mora no catalogo (`msg().ajuda`, D10). */
+function dadosDaAjuda(locale = (0, locale_1.localeAtivo)()) {
+    return { versao: VERSAO, modos: modos_1.ORDEM_DOS_MODOS.length, segredos: (0, locale_1.msg)(locale).onboarding.segredos,
+        tags: modos_1.ORDEM_DOS_MODOS.map((m) => modos_1.MODOS[m].tag).join(' ') };
+}
+/** A ajuda em pt-BR, o texto de sempre: o `docs verificar` a compara com a referencia do CLI. */
+const AJUDA = (0, locale_1.msg)('pt-BR').ajuda.texto(dadosDaAjuda('pt-BR'));
+/**
+ * RM-061 (F2a): a ajuda segue o locale como os comandos cobertos: `owner.language` do projeto de
+ * `--projeto` ou do diretorio, senao `LC_ALL`, `LC_MESSAGES` e `LANG`. Manifesto ilegivel nao derruba a ajuda.
+ */
+function localeDaAjuda(projeto) {
+    // A ajuda sai antes de o projeto-alvo ser fixado: com `--projeto`, vale o manifesto dele (D14).
+    let raiz;
+    if (projeto !== undefined) {
+        try {
+            raiz = (0, projeto_alvo_1.resolverProjetoAlvo)({ opcao: projeto })?.raiz;
+        }
+        catch { /* nome ambiguo ou desconhecido: o cwd */ }
+    }
+    let ownerLanguage;
+    try {
+        ownerLanguage = (0, manifest_1.carregarManifesto)(raiz)?.manifesto.owner?.language;
+    }
+    catch { /* vale o ambiente */ }
+    return (0, locale_1.resolverLocale)(ownerLanguage).locale;
+}
 function comandoThread(args) {
     if (args.posicionais[1] === 'close' || args.posicionais[1] === 'entrega') {
         const raiz = (0, manifest_1.exigirManifesto)().raiz, id = args.posicionais[2];
         if (!id)
-            throw new Error('informe o id da thread');
+            throw new locale_1.ErroDoCatalogo((m) => m.thread.informeOId);
         const por = texto(args.opcoes.por) ?? '';
-        const r = args.posicionais[1] === 'close'
+        // RM-061 (F3b, D3): o fechamento e a entrega gravam (ledger, thread.json, a soltura do que a thread segurava) no
+        // escopo pt-BR; a recusa vem do catalogo e a entrada do CLI a remonta no locale do comando. O resultado e JSON.
+        const r = (0, locale_1.comLocale)('pt-BR', () => args.posicionais[1] === 'close'
             ? (0, thread_close_1.fecharAdministrativamente)(raiz, id, { motivo: texto(args.opcoes.motivo) ?? '', por, justificativa: texto(args.opcoes.justificativa) ?? '' })
-            : (0, thread_close_1.registrarArtefato)(raiz, id, texto(args.opcoes.arquivo) ?? '', texto(args.opcoes.sha256) ?? '', por);
+            : (0, thread_close_1.registrarArtefato)(raiz, id, texto(args.opcoes.arquivo) ?? '', texto(args.opcoes.sha256) ?? '', por));
         console.log(JSON.stringify(r, null, 2));
         return 0;
     }
@@ -596,8 +300,14 @@ function comandoThread(args) {
         // O nome posicional passa a ser opcional, porque o titulo do achado ja serve de nome.
         const doAchado = texto(args.opcoes['from-finding']) ?? texto(args.opcoes['do-achado']);
         if (doAchado) {
+            const mf = (0, locale_1.msg)().thread.fromFinding;
             const brutoModoAchado = texto(args.opcoes.modo) ?? texto(args.opcoes.mode);
             let modoAchado;
+            // RM-058 N6 (D1): thread em modo #Noctum não existe; a recusa diz se falta o envelope ou se a lista do arco é fechada.
+            if (brutoModoAchado !== undefined && (0, noctum_modo_1.ehModoNoctum)(brutoModoAchado)) {
+                console.error((0, noctum_modo_1.recusaDoModoNaThread)(carregado.raiz).message);
+                return 2;
+            }
             if (brutoModoAchado !== undefined) {
                 try {
                     modoAchado = (0, modos_1.exigirModoVivo)(brutoModoAchado);
@@ -627,11 +337,12 @@ function comandoThread(args) {
                 dryRun: args.opcoes['dry-run'] === true,
             });
             if (!r.ok) {
-                console.error(`Thread a partir do achado ${r.achado.id} RECUSADA.`);
-                console.error(`  ${auditoria_1.DESCRICAO_DO_MOTIVO_DE_AUDITORIA[r.motivo ?? 'claims.failed']}`);
-                console.error(`  motivo tipado: ${r.motivo}`);
-                console.error(`  detalhe: ${r.detalhe}`);
-                console.error(`  correcao: ${r.correcao}`);
+                const motivo = r.motivo ?? 'claims.failed';
+                console.error(mf.recusada(r.achado.id));
+                console.error(`  ${mf.descricaoDoMotivo(motivo, auditoria_1.DESCRICAO_DO_MOTIVO_DE_AUDITORIA[motivo])}`);
+                console.error(mf.motivoTipado(r.motivo));
+                console.error(mf.detalhe(r.detalhe));
+                console.error(mf.correcao(r.correcao));
                 return 1;
             }
             const gravadaDoAchado = args.opcoes['dry-run'] !== true;
@@ -640,8 +351,8 @@ function comandoThread(args) {
             if (avisoDoRegistroDoAchado)
                 console.error(avisoDoRegistroDoAchado);
             console.log(gravadaDoAchado
-                ? `Thread criada a partir do achado ${r.achado.id}.`
-                : 'Simulacao (--dry-run), nada foi gravado.');
+                ? mf.criada(r.achado.id)
+                : mf.simulacao);
             console.log((0, divida_1.textoDoAchado)(r.achado));
             console.log('');
             if (r.thread) {
@@ -671,26 +382,32 @@ function comandoThread(args) {
                 }));
             }
             if (gravadaDoAchado && r.thread) {
-                console.log(`  origem do GOAL: .orkastery/threads/${r.thread.id}/achado.json`);
+                console.log(mf.origemDoGoal(r.thread.id));
                 console.log('');
-                console.log('Pedido de GOAL ja montado a partir do achado:');
+                console.log(mf.pedidoMontado);
                 console.log('');
                 console.log(r.pedido);
                 console.log('');
-                console.log('Proximo passo:');
-                console.log(`  ork phase run ${r.thread.id} GOAL --prompt "$(cat .orkastery/threads/${r.thread.id}/pedido-goal.md)"`);
+                console.log(mf.proximoPasso);
+                console.log(mf.comandoDoProximoPasso(r.thread.id));
             }
             return 0;
         }
         const nome = args.posicionais[2];
+        const mt = (0, locale_1.msg)().thread;
         if (!nome) {
-            console.error('uso: ork thread new <nome> --modo <MODO>');
+            console.error(mt.usoNew);
             return 2;
         }
         const avisoRoadmap = avisoRoadmapSemAssociacao(nome, texto(args.opcoes.roadmap));
         if (avisoRoadmap)
             console.error(avisoRoadmap);
         const brutoModo = texto(args.opcoes.modo) ?? texto(args.opcoes.mode);
+        // RM-058 N6 (D1): thread em modo #Noctum não existe; a recusa diz se falta o envelope ou se a lista do arco é fechada.
+        if (brutoModo !== undefined && (0, noctum_modo_1.ehModoNoctum)(brutoModo)) {
+            console.error((0, noctum_modo_1.recusaDoModoNaThread)(carregado.raiz).message);
+            return 2;
+        }
         let modo;
         try {
             modo = brutoModo !== undefined
@@ -710,17 +427,31 @@ function comandoThread(args) {
         const doneWhen = (texto(args.opcoes.done) ?? '').split(';;').map((p) => p.trim()).filter(Boolean)
             .map((entrada) => {
             const corte = entrada.indexOf('::');
-            if (corte < 0) {
-                throw new Error(`done.sem-comando: "${entrada}" nao traz comando. `
-                    + 'Use --done "<criterio> :: <comando que o prova>"; criterio sem comando e prosa, nao criterio de pronto.');
-            }
+            if (corte < 0)
+                throw new Error(mt.doneSemComando(entrada));
             const criterio = entrada.slice(0, corte).trim();
             const comando = entrada.slice(corte + 2).trim();
             if (!criterio || !comando)
-                throw new Error(`done.incompleto: "${entrada}" precisa de criterio E comando`);
+                throw new Error(mt.doneIncompleto(entrada));
             return { criterio, comando };
         });
         const dryRun = args.opcoes['dry-run'] === true;
+        // RM-059 (T6.0): o pedido do builder, guardado para o render da fase quando falta `--pedido`.
+        if (args.opcoes.pedido === true) {
+            console.error(mt.usoPedido);
+            return 2;
+        }
+        const pedidoDoBuilder = texto(args.opcoes.pedido);
+        // A4 do CHECK: pedido invalido e erro de uso, e sai antes da reserva do roadmap, que vai ao remoto.
+        if (pedidoDoBuilder !== undefined) {
+            try {
+                (0, thread_1.prepararPedido)(pedidoDoBuilder);
+            }
+            catch (e) {
+                console.error(mt.usoComMotivo((0, locale_1.mensagemDoErro)(e)));
+                return 2;
+            }
+        }
         // `--worktree auto` (ou `--worktree` sozinho) cria a worktree isolada da thread; um caminho reusa um
         // diretorio que ja existe. P4 do ensaio da 0.5.0: sem flag, `worktree.por_thread: true` cria como o
         // `--worktree auto`, e `--sem-worktree` cria sem ela. Uso invalido sai antes da reserva do roadmap.
@@ -735,13 +466,13 @@ function comandoThread(args) {
         const brutoCiclo = texto(args.opcoes.ciclo) ?? texto(args.opcoes.variante);
         const variante = brutoCiclo ? (0, ciclos_1.parseVariante)(brutoCiclo) : null;
         if (brutoCiclo && !variante) {
-            console.error(`variante de ciclo invalida: "${brutoCiclo}". Use uma de: ${Object.keys(ciclos_1.VARIANTES).join(', ')}`);
+            console.error(mt.varianteInvalida(brutoCiclo, Object.keys(ciclos_1.VARIANTES).join(', ')));
             return 2;
         }
         // P4 do ensaio da 0.5.0 (D4, CHECK): a recusa do ciclo sai antes da reserva do roadmap, como os outros erros de
         // uso; a do `novaThread` fica como defesa de quem o chama direto.
         if (variante && (0, ciclos_1.definicaoDaVariante)(variante).exigeWorktree && pedido.origem === 'sem-worktree') {
-            console.error(`uso: o ciclo ${variante} exige worktree isolada: crie a thread sem --sem-worktree ou escolha outro ciclo`);
+            console.error(mt.cicloExigeWorktree(variante));
             return 2;
         }
         const brutoFatias = texto(args.opcoes.fatias);
@@ -749,10 +480,11 @@ function comandoThread(args) {
         // atomico entre maquinas (o primeiro push vence); a thread e local. Se a criacao falhar,
         // a reserva e devolvida; se der certo, ela passa a apontar para a thread.
         const itemDoRoadmap = dryRun ? undefined : texto(args.opcoes.roadmap);
-        const itemReservado = itemDoRoadmap ? (0, roadmap_reservas_1.pegarItem)(carregado.raiz, itemDoRoadmap).item : undefined;
+        // RM-061 (F2a, D6): o que grava estado (reserva, thread, ledger, worktree, registro, publicacoes) roda em pt-BR.
+        const itemReservado = itemDoRoadmap ? (0, locale_1.comLocale)('pt-BR', () => (0, roadmap_reservas_1.pegarItem)(carregado.raiz, itemDoRoadmap).item) : undefined;
         let criada;
         try {
-            criada = (0, thread_1.novaThread)(carregado, {
+            criada = (0, locale_1.comLocale)('pt-BR', () => (0, thread_1.novaThread)(carregado, {
                 nome,
                 modo,
                 slug: texto(args.opcoes.slug),
@@ -767,47 +499,53 @@ function comandoThread(args) {
                 exigeRuntimeDiferente,
                 doneWhen,
                 roadmap: itemReservado,
-            });
+                ...(pedidoDoBuilder !== undefined ? { pedido: pedidoDoBuilder } : {}),
+            }));
         }
         catch (e) {
             if (itemDoRoadmap) {
                 try {
-                    (0, roadmap_reservas_1.soltarItem)(carregado.raiz, itemDoRoadmap);
+                    (0, locale_1.comLocale)('pt-BR', () => (0, roadmap_reservas_1.soltarItem)(carregado.raiz, itemDoRoadmap));
                 }
                 catch { /* fica reservado; `ork roadmap soltar` resolve */ }
             }
             throw e;
         }
         const { thread, gravada } = criada;
-        const reservaDoItem = itemDoRoadmap && gravada ? (0, roadmap_reservas_1.pegarItem)(carregado.raiz, itemDoRoadmap, { thread: thread.id }) : null;
+        const reservaDoItem = itemDoRoadmap && gravada
+            ? (0, locale_1.comLocale)('pt-BR', () => (0, roadmap_reservas_1.pegarItem)(carregado.raiz, itemDoRoadmap, { thread: thread.id })) : null;
         // I-51 (RM-047): com a fabrica compartilhada, as outras maquinas veem a thread nova.
         if (gravada)
-            (0, fabrica_publicar_1.publicarEmSegundoPlano)(carregado.raiz);
+            (0, locale_1.comLocale)('pt-BR', () => (0, fabrica_publicar_1.publicarEmSegundoPlano)(carregado.raiz));
         // RM-052 (D7): quem abre thread aqui conhece este projeto; o aviso nunca derruba a criacao.
-        const avisoDoRegistro = gravada ? (0, projeto_alvo_1.registrarProjetoEmSilencio)(carregado.raiz, 'thread new') : null;
+        const avisoDoRegistro = gravada ? (0, locale_1.comLocale)('pt-BR', () => (0, projeto_alvo_1.registrarProjetoEmSilencio)(carregado.raiz, 'thread new')) : null;
         if (avisoDoRegistro)
             console.error(avisoDoRegistro);
-        console.log(gravada ? 'Thread criada.' : 'Simulacao (--dry-run), nada foi gravado.');
+        console.log(gravada ? mt.criada : mt.simulacao);
         if (reservaDoItem)
-            console.log(`  roadmap: ${reservaDoItem.item} reservado para esta maquina (${reservaDoItem.reserva?.maquina})`);
+            console.log(mt.roadmapReservado(reservaDoItem.item, reservaDoItem.reserva?.maquina));
         console.log((0, thread_1.resumoDaThread)(thread));
         console.log('');
-        console.log(`  slug em 3 partes: ${(0, phase_1.descreverSlug)(thread.slug)}`);
+        console.log(mt.slugEm3Partes((0, phase_1.descreverSlug)(thread.slug)));
         const linhaDaWorktreeNova = (0, thread_1.linhaDaWorktree)(criada.worktreePor, gravada, variante);
         if (linhaDaWorktreeNova)
             console.log(linhaDaWorktreeNova);
+        relatarDependencias(criada.dependencias, thread.worktree ?? '');
         const avisoDaWorktreeNova = criada.worktreeFalharia ? (0, thread_1.avisoDeWorktreeQueFalharia)(criada.worktreeFalharia)
             : (0, thread_1.avisoDaWorktree)(pedido.origem, criada, carregado.manifesto);
         const avisoSemBase = (0, thread_1.avisoDeThreadSemBase)(thread, gravada);
+        if (thread.pedido) {
+            console.log(mt.pedidoGuardado(gravada, `.orkastery/threads/${thread.id}/${thread.pedido.arquivo}`, (0, util_1.shaCurto)(thread.pedido.sha256), thread.pedido.bytes));
+        }
         if (gravada) {
-            console.log(`  estado: .orkastery/threads/${thread.id}/thread.json`);
+            console.log(mt.estado(thread.id));
             // Bloco B6: a origem da thread e as policies do projeto vao para a memoria
             // semantica quando ela esta ligada. Em regime files nada muda nesta saida.
-            relatarPublicacao((0, memoria_1.publicar)(carregado, thread.id));
+            relatarPublicacao((0, locale_1.comLocale)('pt-BR', () => (0, memoria_1.publicar)(carregado, thread.id)));
             // Thread sem base nao tem fase para rodar: o proximo passo e o do aviso.
             if (!avisoSemBase) {
                 console.log('');
-                console.log(`Proximo passo: ork phase run ${thread.id} ${thread.faseAtual} --prompt "<pedido>"`);
+                console.log(mt.proximoPasso(thread.id, thread.faseAtual));
             }
         }
         if (avisoDaWorktreeNova)
@@ -833,8 +571,9 @@ function comandoThread(args) {
     if (sub === 'status') {
         const carregado = (0, manifest_1.exigirManifesto)();
         const id = args.posicionais[2];
+        const mt = (0, locale_1.msg)().thread;
         if (!id) {
-            console.error('uso: ork thread status <thread-id>');
+            console.error(mt.usoStatus);
             return 2;
         }
         const thread = (0, thread_1.lerThread)(carregado.raiz, id);
@@ -848,20 +587,19 @@ function comandoThread(args) {
         console.log((0, thread_1.resumoDaThread)(thread, (0, conducao_1.conducaoDaThread)(carregado.raiz, thread.id)));
         console.log('');
         if (thread.sessoes.length === 0) {
-            console.log('  nenhuma sessao despachada ainda');
+            console.log(mt.nenhumaSessao);
         }
         else {
-            console.log('  sessoes despachadas (estado real conferido em `ork sessions`)');
+            console.log(mt.sessoesDespachadas);
             for (const s of thread.sessoes) {
-                console.log(`    ${s.slug.padEnd(24)} ${s.fase.padEnd(6)} ${s.sessionId.slice(0, 8)}  ` +
-                    `verificada no runtime: ${s.verificada ? 'sim' : 'nao'}  canal: ${(0, thread_1.canalDaSessao)(s)}`);
+                console.log(`    ${s.slug.padEnd(24)} ${s.fase.padEnd(6)} ${s.sessionId.slice(0, 8)}  ` + mt.sessao(s.verificada, (0, thread_1.canalDaSessao)(s)));
             }
         }
         console.log('');
-        console.log(`  pausas humanas do modo: ${(0, modos_1.pausasDoModo)(thread.modo)}`);
+        console.log(mt.pausasDoModo((0, modos_1.pausasDoModo)(thread.modo)));
         return 0;
     }
-    console.error(`subcomando desconhecido: thread ${sub}`);
+    console.error((0, locale_1.msg)().cli.subcomandoDesconhecido('thread', sub));
     return 2;
 }
 /**
@@ -873,7 +611,7 @@ function comandoThread(args) {
  * Toda edicao vira evento `setup_configured` no ledger do projeto.
  */
 function comandoOnboarding(args) {
-    const invalido = () => { throw new Error('onboarding.input.invalid: use ork onboarding [show|set <etapa>|reset [etapa]] --conteudo <JSON> [--por Q] [--json]'); };
+    const invalido = () => { throw new Error((0, locale_1.msg)().onboarding.usoInvalido); };
     if (Object.keys(args.opcoes).some(k => !['conteudo', 'por', 'json', 'reset'].includes(k)))
         invalido();
     if ('json' in args.opcoes && args.opcoes.json !== true)
@@ -902,6 +640,7 @@ function comandoOnboarding(args) {
         return 0;
     }
     let estado;
+    // RM-061 (F2a, D6): a recusa de uso sai no locale do comando; a gravacao roda em pt-BR (o dado nao muda).
     if (sub === 'set') {
         let conteudo;
         try {
@@ -910,10 +649,13 @@ function comandoOnboarding(args) {
         catch {
             return invalido();
         }
-        estado = (0, onboarding_1.gravarEtapa)(raiz, etapa, conteudo, por);
+        (0, onboarding_1.validarPedidoDeEtapa)(etapa, conteudo, por);
+        estado = (0, locale_1.comLocale)('pt-BR', () => (0, onboarding_1.gravarEtapa)(raiz, etapa, conteudo, por));
+    }
+    else if (sub === 'reset') {
+        (0, onboarding_1.validarPedidoDeEtapa)(etapa, undefined, por);
+        estado = (0, locale_1.comLocale)('pt-BR', () => (0, onboarding_1.resetarOnboarding)(raiz, etapa, por));
     }
-    else if (sub === 'reset')
-        estado = (0, onboarding_1.resetarOnboarding)(raiz, etapa, por);
     else
         estado = (0, onboarding_1.lerOnboarding)(raiz);
     console.log(args.opcoes.json === true ? JSON.stringify(estado, null, 2) : (0, onboarding_1.textoDaPauta)(estado, (0, manifest_1.exigirManifesto)(raiz).manifesto.owner));
@@ -935,14 +677,19 @@ function aspasDeShell(valor) {
 function avisarChavesDePerfis(carregado) {
     for (const a of carregado.avisos)
         if (a.startsWith('runtime_profiles.'))
-            console.error(`aviso: ${a}`);
+            console.error((0, locale_1.msg)().phase.aviso(a));
 }
 function comandoAccounts(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
     avisarChavesDePerfis(carregado);
     const raiz = carregado.raiz;
     const sub = args.posicionais[1] ?? 'list';
-    const conferir = (p) => p.runtime === 'claude-bg' ? (0, claude_bg_1.conferirAuth)(p) : (0, codex_1.conferirAuth)(p);
+    // RM-061 (F3b, GO-FIX 1): a conferencia roda no escopo pt-BR (o detalhe vai ao store), e a impressao o traduz.
+    const conferir = (p) => (0, locale_1.comLocale)('pt-BR', () => p.runtime === 'claude-bg' ? (0, claude_bg_1.conferirAuth)(p) : (0, codex_1.conferirAuth)(p));
+    const detalhe = (auth) => ma.detalheDoLogin((0, locale_1.remontar)(auth.detalhe));
+    // RM-061 (F3b, D3): o texto pelo catalogo; o que se grava (store de perfis, registro de contas) roda no escopo pt-BR,
+    // e o id, o runtime, o diretorio, o motivo tipado e o detalhe que o CLI do runtime devolve saem como vieram.
+    const ma = (0, locale_1.msg)().accounts;
     const imprimir = () => {
         const store = (0, runtime_profiles_1.lerPerfis)(raiz);
         if (args.opcoes.json === true) {
@@ -951,8 +698,7 @@ function comandoAccounts(args) {
         }
         // I-49: a tabela mostra o que o despacho enxerga, com o que outra fabrica viu na mesma conta.
         const visto = (0, runtime_profiles_1.lerPerfisComContas)(raiz);
-        console.log(visto.perfis.length === 0 ? 'Nenhum perfil configurado: cada runtime despacha pelo ambiente do processo.'
-            : (0, util_1.tabela)(runtime_profiles_1.COLUNAS_DE_PERFIS, (0, runtime_profiles_1.linhasDePerfis)(visto)));
+        console.log(visto.perfis.length === 0 ? ma.semPerfis : (0, util_1.tabela)([...ma.colunas], (0, runtime_profiles_1.linhasDePerfis)(visto)));
         // I-35: a tabela mostra horario do dono; o fuso sai uma vez, no fim da mensagem.
         if ((0, runtime_profiles_1.perfisComHorario)(store))
             console.log((0, horario_1.legendaDoFuso)());
@@ -964,7 +710,7 @@ function comandoAccounts(args) {
     if (sub === 'add') {
         const id = args.posicionais[2], runtime = texto(args.opcoes.runtime), dirBruto = texto(args.opcoes.dir);
         if (!id || !runtime || !dirBruto) {
-            console.error('uso: ork accounts add <id> --runtime claude-bg|codex --dir <diretorio> [--sem-login]');
+            console.error(ma.usoAdd);
             return 2;
         }
         const dir = path.resolve(dirBruto);
@@ -973,12 +719,12 @@ function comandoAccounts(args) {
             // A7: diretorio inacessivel ou de outro usuario e recusado antes de qualquer gravacao no store.
             (0, runtime_profiles_1.prepararDiretorioDoPerfil)(dir);
             const desativado = (0, runtime_profiles_1.lerPerfis)(raiz).perfis.some(p => p.id === id && p.estado === 'desativado');
-            perfil = (0, runtime_profiles_1.adicionarPerfil)(raiz, { id, runtime, dir });
+            perfil = (0, locale_1.comLocale)('pt-BR', () => (0, runtime_profiles_1.adicionarPerfil)(raiz, { id, runtime, dir }));
             if (desativado)
-                console.log(`Perfil ${id} reativado: mesmo id, runtime e diretorio do perfil desativado.`);
+                console.log(ma.reativado(id));
         }
         catch (e) {
-            console.error(`perfil recusado: ${e.message}`);
+            console.error(ma.recusado((0, locale_1.mensagemDoErro)(e)));
             return 1;
         }
         const despacho = (0, runtime_profiles_1.perfilDeDespacho)(perfil);
@@ -991,59 +737,76 @@ function comandoAccounts(args) {
             (0, node_child_process_1.spawnSync)(comando[0], comando.slice(1), { stdio: 'inherit', env });
         }
         else {
-            console.log(`Login pendente: rode ${variavel}=${aspasDeShell(dir)} ${comando.join(' ')} e depois ork accounts check ${id}`);
+            console.log(ma.loginPendente(variavel, aspasDeShell(dir), comando.join(' '), id));
         }
         const auth = conferir(despacho);
         // A14: conferencia inconclusiva nao marca sem-auth; o preflight do proximo despacho confere de novo.
         if (!auth.ok && !auth.transitorio)
-            (0, runtime_profiles_1.marcarFalhaDePerfil)(raiz, id, auth.pago
+            (0, locale_1.comLocale)('pt-BR', () => (0, runtime_profiles_1.marcarFalhaDePerfil)(raiz, id, auth.pago
                 ? { estado: 'provider-pago', esgotadoAte: null, motivo: 'cost.violation', detalhe: auth.detalhe }
-                : { estado: 'sem-auth', esgotadoAte: null, motivo: 'runtime.auth-missing', detalhe: auth.detalhe });
-        console.log(`Perfil ${id} (${perfil.runtime}) em ${dir}: ${auth.ok ? 'login de assinatura conferido'
-            : auth.transitorio ? `conferencia de login inconclusiva (${auth.detalhe}); o proximo despacho confere de novo`
-                : auth.pago ? `provider pago (${auth.detalhe}); nunca recebe despacho` : `sem login (${auth.detalhe}); fora do rodizio`}`);
+                : { estado: 'sem-auth', esgotadoAte: null, motivo: 'runtime.auth-missing', detalhe: auth.detalhe }));
+        console.log(ma.resultadoAdd(id, perfil.runtime, dir, auth.ok ? ma.conferido
+            : auth.transitorio ? ma.inconclusivaAdd(detalhe(auth))
+                : auth.pago ? ma.pagoAdd(detalhe(auth)) : ma.semLoginAdd(detalhe(auth))));
         return 0;
     }
     if (sub === 'remove') {
         const id = args.posicionais[2];
         if (!id) {
-            console.error('uso: ork accounts remove <id>');
+            console.error(ma.usoRemove);
             return 2;
         }
         try {
-            (0, runtime_profiles_1.desativarPerfil)(raiz, id);
+            (0, locale_1.comLocale)('pt-BR', () => (0, runtime_profiles_1.desativarPerfil)(raiz, id));
         }
         catch (e) {
-            console.error(e.message);
+            console.error((0, locale_1.mensagemDoErro)(e));
             return 1;
         }
-        console.log(`Perfil ${id} desativado: o diretorio e o login do CLI ficam onde estao.`);
+        console.log(ma.desativado(id));
         return 0;
     }
     if (sub === 'check') {
         const alvo = args.posicionais[2];
+        const expirados = new Set((0, locale_1.comLocale)('pt-BR', () => (0, runtime_profiles_1.expirarPerfisVencidos)(raiz)).map(p => p.id));
         const perfis = (0, runtime_profiles_1.lerPerfis)(raiz).perfis.filter(p => p.estado !== 'desativado' && (alvo === undefined || p.id === alvo));
         if (alvo !== undefined && perfis.length === 0) {
-            console.error(`perfil ativo "${alvo}" nao existe (veja: ork accounts list)`);
+            console.error(ma.perfilAtivoNaoExiste(alvo));
             return 1;
         }
+        const inventario = (0, sessoes_inventario_1.inventariarSessoes)(raiz, { global: true });
         let falhas = 0;
         for (const p of perfis) {
             const auth = conferir((0, runtime_profiles_1.perfilDeDespacho)(p));
-            if (auth.ok && (p.estado === 'sem-auth' || p.estado === 'provider-pago'))
-                (0, runtime_profiles_1.reativarPerfil)(raiz, p.id);
+            (0, locale_1.comLocale)('pt-BR', () => {
+                if (auth.ok && (p.estado === 'sem-auth' || p.estado === 'provider-pago'))
+                    (0, runtime_profiles_1.reativarPerfil)(raiz, p.id);
+                if (!auth.ok && auth.transitorio)
+                    (0, runtime_profiles_1.registrarConferenciaInconclusiva)(raiz, p.id, auth.detalhe);
+                else if (!auth.ok) {
+                    (0, runtime_profiles_1.marcarFalhaDePerfil)(raiz, p.id, auth.pago
+                        ? { estado: 'provider-pago', esgotadoAte: null, motivo: 'cost.violation', detalhe: auth.detalhe }
+                        : { estado: 'sem-auth', esgotadoAte: null, motivo: 'runtime.auth-missing', detalhe: auth.detalhe });
+                }
+            });
             if (!auth.ok)
                 falhas++;
-            if (!auth.ok && auth.transitorio)
-                (0, runtime_profiles_1.registrarConferenciaInconclusiva)(raiz, p.id, auth.detalhe);
-            else if (!auth.ok) {
-                (0, runtime_profiles_1.marcarFalhaDePerfil)(raiz, p.id, auth.pago
-                    ? { estado: 'provider-pago', esgotadoAte: null, motivo: 'cost.violation', detalhe: auth.detalhe }
-                    : { estado: 'sem-auth', esgotadoAte: null, motivo: 'runtime.auth-missing', detalhe: auth.detalhe });
-            }
-            console.log(`${p.id} (${p.runtime}): ${auth.ok ? 'login de assinatura conferido'
-                : auth.transitorio ? `conferencia de login inconclusiva, estado mantido (${auth.detalhe})`
-                    : auth.pago ? `provider pago, nunca despacha (${auth.detalhe})` : `sem login (${auth.detalhe})`}`);
+            const atual = (0, runtime_profiles_1.lerPerfis)(raiz).perfis.find(x => x.id === p.id) ?? p;
+            const sessoes = inventario.sessoes.filter(s => s.viva && s.runtime === p.runtime && s.perfil === p.id);
+            const cargas = [...new Set(sessoes.flatMap(s => s.vinculos.length
+                    ? s.vinculos.map(v => `${v.thread}:${v.fase}`) : [ma.sessaoSemVinculo(s.sessionId.slice(0, 8))]))];
+            const carga = !inventario.ok ? ma.cargaInconclusiva : cargas.length ? ma.cargaDaConta(cargas.join(', ')) : ma.cargaVazia;
+            const volta = atual.esgotadoAte ?? auth.cota?.resetEm ?? null;
+            const operacional = [
+                ma.limiteDaConta(ma.tipoDeLimite((0, runtime_profiles_1.tipoDeLimiteDoPerfil)(atual))),
+                ma.cotaDaConta(auth.cota ? ma.cotaMedida(auth.cota.usada, auth.cota.limite, auth.cota.unidade) : ma.cotaIndisponivel),
+                carga,
+                volta ? ma.voltaEm((0, horario_1.formatarDataHoraRotulada)(volta)) : ma.voltaSemMedida,
+                ...(expirados.has(p.id) ? [ma.marcaExpirada] : []),
+            ].join('; ');
+            console.log(`${ma.resultadoCheck(p.id, p.runtime, auth.ok ? ma.conferido
+                : auth.transitorio ? ma.inconclusivaCheck(detalhe(auth))
+                    : auth.pago ? ma.pagoCheck(detalhe(auth)) : ma.semLoginCheck(detalhe(auth)))}; ${operacional}`);
         }
         console.log('');
         imprimir();
@@ -1056,13 +819,13 @@ function comandoAccounts(args) {
             relatorio = (0, esgotamentos_1.relatorioDeEsgotamentos)({ desde: texto(args.opcoes.desde) ?? '7d' });
         }
         catch (e) {
-            console.error(`${e.message} (use --desde 7d, 24h, 30m ou uma data ISO)`);
+            console.error(ma.periodoInvalido(e.message));
             return 2;
         }
         console.log(args.opcoes.json === true ? JSON.stringify(relatorio, null, 2) : (0, esgotamentos_1.textoDosEsgotamentos)(relatorio));
         return 0;
     }
-    console.error(`subcomando desconhecido: accounts ${sub} (use list, add, remove, check ou esgotamentos)`);
+    console.error(ma.desconhecido(sub));
     return 2;
 }
 function comandoSetup(args) {
@@ -1070,6 +833,7 @@ function comandoSetup(args) {
     const raiz = carregado.raiz;
     const modoBruto = args.posicionais[1];
     const por = texto(args.opcoes.por) ?? 'owner';
+    const ms = (0, locale_1.msg)().setup.cli;
     if (modoBruto === 'versionar') {
         // I-52 (RM-047): o setup que vale agora vai para orkastery.setup.json, para entrar por PR.
         const r = (0, setup_1.versionarSetup)(raiz, por);
@@ -1077,8 +841,93 @@ function comandoSetup(args) {
             console.log(JSON.stringify({ caminho: r.caminho, setup: r.setup }, null, 2));
             return 0;
         }
-        console.log(`Setup versionado em ${r.caminho}.`);
-        console.log('  Leve para o repositorio por PR: dali em diante ele vale em todas as maquinas, e ork setup <modo> --bloco N passa a editar este arquivo.');
+        console.log(ms.versionado(r.caminho));
+        console.log(ms.levePorPr);
+        return 0;
+    }
+    if (modoBruto === 'worktree') {
+        // RM-047 (P3): worktree.dir fora da raiz so cria checkout com a confirmacao desta maquina, fora do git.
+        const acao = args.posicionais[2];
+        const json = args.opcoes.json === true;
+        if (acao === 'confirmar') {
+            const local = (0, worktree_local_1.confirmarWorktreeLocal)(raiz, carregado.manifesto, por, args.posicionais[3]);
+            if (json) {
+                console.log(JSON.stringify(local, null, 2));
+                return 0;
+            }
+            console.log(ms.worktreeConfirmada(local.dir, local.raiz));
+            console.log(ms.worktreeGravada(worktree_local_1.ARQUIVO_WORKTREE_LOCAL));
+            return 0;
+        }
+        if (acao === 'revogar') {
+            const havia = (0, worktree_local_1.revogarWorktreeLocal)(raiz);
+            if (json) {
+                console.log(JSON.stringify({ revogada: havia }, null, 2));
+                return 0;
+            }
+            console.log(havia ? ms.worktreeRevogada : ms.worktreeNaoHavia);
+            return 0;
+        }
+        if (acao !== undefined) {
+            console.error(ms.worktreeSubcomando(acao));
+            return 2;
+        }
+        const pedida = (0, worktree_local_1.pastaDasWorktreesPedida)(raiz, carregado.manifesto);
+        const local = (0, worktree_local_1.lerWorktreeLocal)(raiz);
+        const recusa = (0, worktree_local_1.recusaDePastaDasWorktrees)(raiz, carregado.manifesto);
+        if (json) {
+            console.log(JSON.stringify({ manifesto: carregado.manifesto.worktree.dir, dir: pedida.dir, dentroDaRaiz: pedida.dentro,
+                confirmadaNestaMaquina: local.local?.dir ?? null, criacao: recusa === null ? 'permitida' : 'recusada' }, null, 2));
+            return 0;
+        }
+        console.log(ms.worktreeManifesto(carregado.manifesto.worktree.dir, pedida.dir, pedida.dentro));
+        console.log(ms.confirmacaoLocal(local.local ? local.local.dir : ms.nenhumaConfirmacao(String(local.motivo))));
+        console.log(recusa === null ? ms.criacaoPermitida : ms.criacaoRecusada(worktree_local_1.COMANDO_CONFIRMAR_WORKTREE));
+        return 0;
+    }
+    if (modoBruto === 'sandbox') {
+        // RM-047 (P1): a postura de sandbox que afrouxa so vale com a confirmacao desta maquina, fora do git.
+        const acao = args.posicionais[2];
+        const json = args.opcoes.json === true;
+        if (acao === 'confirmar') {
+            const postura = args.posicionais[3];
+            if (!postura) {
+                console.error(ms.sandboxUso);
+                return 2;
+            }
+            const p = (0, postura_local_1.confirmarPosturaLocal)(raiz, postura, por);
+            if (json) {
+                console.log(JSON.stringify(p, null, 2));
+                return 0;
+            }
+            console.log(ms.sandboxConfirmada(p.sandbox, p.raiz));
+            console.log(ms.sandboxGravada((0, postura_local_1.caminhoDaPosturaLocal)(raiz)));
+            return 0;
+        }
+        if (acao === 'revogar') {
+            const havia = (0, postura_local_1.revogarPosturaLocal)(raiz);
+            if (json) {
+                console.log(JSON.stringify({ revogada: havia }, null, 2));
+                return 0;
+            }
+            console.log(havia ? ms.sandboxRevogada : ms.sandboxNaoHavia);
+            return 0;
+        }
+        if (acao !== undefined) {
+            console.error(ms.sandboxSubcomando(acao));
+            return 2;
+        }
+        const pedida = carregado.manifesto.runtime.sandbox;
+        const local = (0, postura_local_1.lerPosturaLocal)(raiz);
+        const recusa = (0, postura_local_1.recusaDePostura)(raiz, carregado.manifesto, 'codex');
+        if (json) {
+            console.log(JSON.stringify({ manifesto: pedida, afrouxa: (0, postura_local_1.posturaAfrouxada)(carregado.manifesto) !== null,
+                confirmadaNestaMaquina: local.postura?.sandbox ?? null, despachoCodex: recusa === null ? 'permitido' : 'recusado' }, null, 2));
+            return 0;
+        }
+        console.log(ms.sandboxManifesto(pedida));
+        console.log(ms.confirmacaoLocal(local.postura ? local.postura.sandbox : ms.nenhumaConfirmacao(String(local.motivo))));
+        console.log(recusa === null ? ms.despachoPermitido : ms.despachoRecusado((0, postura_local_1.comandoDeConfirmacao)(pedida)));
         return 0;
     }
     if (!modoBruto) {
@@ -1088,7 +937,7 @@ function comandoSetup(args) {
                 console.log(JSON.stringify((0, setup_1.lerSetup)(raiz), null, 2));
                 return 0;
             }
-            console.log('Setup resetado: todos os blocos de todos os modos voltaram ao default.');
+            console.log(ms.resetado);
             console.log((0, setup_1.textoDaEntrevista)(raiz));
             return 0;
         }
@@ -1097,7 +946,7 @@ function comandoSetup(args) {
     }
     const modo = (0, modos_1.parseModo)(modoBruto);
     if (!modo) {
-        console.error(`modo de conducao desconhecido: "${modoBruto}" (aceitos: ${modos_1.ORDEM_DOS_MODOS.join(', ')})`);
+        console.error(ms.modoDesconhecido(modoBruto, modos_1.ORDEM_DOS_MODOS.join(', ')));
         return 2;
     }
     if (args.opcoes.reset === true) {
@@ -1106,7 +955,7 @@ function comandoSetup(args) {
             console.log(JSON.stringify((0, setup_1.lerSetup)(raiz).modos[modo], null, 2));
             return 0;
         }
-        console.log(`Setup do modo ${modos_1.MODOS[modo].tag} resetado para o default.`);
+        console.log(ms.modoResetado(modos_1.MODOS[modo].tag));
         console.log('');
         console.log((0, setup_1.textoDoSetup)(raiz, modo));
         return 0;
@@ -1119,26 +968,25 @@ function comandoSetup(args) {
     const fallbackBruto = args.opcoes.fallback === true ? '' : texto(args.opcoes.fallback);
     const fallback = fallbackBruto === undefined ? undefined : fallbackBruto.split(',').map(s => s.trim()).filter(s => s !== '');
     if (bloco === undefined && (runtime !== undefined || model !== undefined || effort !== undefined || fallback !== undefined)) {
-        console.error('para editar, informe o bloco: ork setup <modo> --bloco N [--runtime R] [--model M] [--effort E] [--fallback R:M,...]');
+        console.error(ms.informeBloco);
         return 2;
     }
     if (bloco !== undefined) {
         if (runtime === undefined && model === undefined && effort === undefined && fallback === undefined) {
-            console.error('nada para editar: informe --runtime, --model, --effort e/ou --fallback junto de --bloco');
+            console.error(ms.nadaParaEditar);
             return 2;
         }
         const r = (0, setup_1.editarBloco)(raiz, modo, Number(bloco), { runtime, model, effort, ...(fallback !== undefined ? { fallback } : {}) }, por);
         if (!r.ok) {
-            console.error(`edicao recusada: ${r.erro}`);
+            console.error(ms.edicaoRecusada(r.erro ?? ''));
             return 1;
         }
         if (args.opcoes.json === true) {
             console.log(JSON.stringify(r.setup.modos[modo], null, 2));
             return 0;
         }
-        console.log(`Bloco ${r.bloco} do modo ${modos_1.MODOS[modo].tag}: ` +
-            `${r.de?.runtime}/${r.de?.model}/${r.de?.effort} -> ${r.para?.runtime}/${r.para?.model}/${r.para?.effort}`);
-        console.log(`  gravado em ${r.caminho}; evento setup_configured no ledger do projeto`);
+        console.log(ms.blocoAlterado(r.bloco, modos_1.MODOS[modo].tag, `${r.de?.runtime}/${r.de?.model}/${r.de?.effort}`, `${r.para?.runtime}/${r.para?.model}/${r.para?.effort}`));
+        console.log(ms.gravado(r.caminho));
         console.log('');
         console.log((0, setup_1.textoDoSetup)(raiz, modo));
         return 0;
@@ -1149,19 +997,21 @@ function comandoSetup(args) {
 function comandoPhase(args) {
     const sub = args.posicionais[1];
     const carregado = (0, manifest_1.exigirManifesto)();
+    const m = (0, locale_1.msg)().phase;
     if (sub === 'run') {
         avisarChavesDePerfis(carregado);
         const id = args.posicionais[2];
         const faseBruta = args.posicionais[3];
         const prompt = texto(args.opcoes.prompt);
         if (!id || !faseBruta || !prompt) {
-            console.error('uso: ork phase run <thread-id> <FASE> --prompt "<texto>"');
+            console.error(m.usoRun);
             return 2;
         }
         const thread = (0, thread_1.lerThread)(carregado.raiz, id);
         const fase = (0, thread_1.exigirFase)(thread, faseBruta);
         const conducao = conducaoDoCli(args);
-        const r = (0, phase_1.rodarFase)(carregado, id, {
+        // RM-061 (F2a, D6): o despacho grava prompt, ledger, lease e pedidos em pt-BR; so a impressao segue o locale.
+        const r = (0, locale_1.comLocale)('pt-BR', () => (0, phase_1.rodarFase)(carregado, id, {
             fase,
             prompt,
             runtime: texto(args.opcoes.runtime),
@@ -1172,7 +1022,9 @@ function comandoPhase(args) {
             canal: conducao.canal,
             ...(conducao.correlacao ? { correlacao: conducao.correlacao } : {}),
             ...(conducao.esperarMs ? { esperarMs: conducao.esperarMs } : {}),
-        });
+            // A baseline que o despacho grava espera a fila pesada com aviso; a recusa sugere gravá-la antes, com mais espera.
+            filaPesada: filaPesadaDoCli(args, 'baseline', `ork verify ${id} --baseline --esperar 120`),
+        }));
         // I-36 (T12, T14): pedido repetido e segundo pedido tem resposta propria, antes dos outros gates.
         if (r.idempotente && r.conducao) {
             console.log((0, conducao_1.textoDoPedidoRepetido)(id, r.conducao));
@@ -1188,14 +1040,13 @@ function comandoPhase(args) {
                 console.log(JSON.stringify({ motivo: r.motivo, ...r.vaga }, null, 2));
                 return 3;
             }
-            console.log(`Despacho recusado: concurrency.limite. O projeto ja tem ${r.vaga.ocupam.length} sessao(oes) viva(s) ` +
-                `em outras threads e o limite e ${r.vaga.limite} (concurrency.max_parallel_threads).`);
+            console.log(m.vagaRecusada(r.vaga.ocupam.length, r.vaga.limite));
             for (const o of r.vaga.ocupam) {
                 console.log(`  ${o.thread.padEnd(20)} ${(o.fase ?? '-').padEnd(6)} ` +
-                    `${o.sessao ? `${o.runtime} ${o.sessao.slice(0, 8)}` : 'despacho em curso'}, desde ${(0, horario_1.localizarTextoRotulado)(o.desde)}`);
+                    `${o.sessao ? `${o.runtime} ${o.sessao.slice(0, 8)}` : m.despachoEmCurso}, ${m.desde((0, horario_1.localizarTextoRotulado)(o.desde))}`);
             }
-            console.log(`  correcao: ${r.vaga.correcao}`);
-            console.log(r.dryRun ? '  ensaio (--dry-run): nada foi gravado.' : `  evento slot_refused no ledger de ${id}; nenhuma sessao aberta.`);
+            console.log(m.correcao(r.vaga.correcao));
+            console.log(r.dryRun ? m.vagaEnsaio : m.vagaLedger(id));
             return 3;
         }
         // RM-037 (S-4 do CHECK 3): a baseline que o despacho nao conseguiu gravar nao e gate reprovado.
@@ -1204,78 +1055,81 @@ function comandoPhase(args) {
                 console.log(JSON.stringify({ motivo: r.motivo, detalhe: r.erro }, null, 2));
                 return 1;
             }
-            console.error(`Despacho recusado: ${r.erro}`);
-            console.error('  nenhuma sessao aberta; o ledger nao ganhou gate_blocked');
+            console.error(m.recusado(`${r.erro}`));
+            console.error(m.baselinePendente);
             return 1;
         }
+        // RM-061 (F2a): o resumo do despacho sai pelo catalogo; o rotulo tem largura 14, como antes.
+        const campo = (rotulo, valor) => `  ${rotulo.padEnd(14)} : ${valor}`, rt = m.rotulos;
         if (r.dryRun && !r.bloqueado) {
-            console.log('Simulacao (--dry-run), nada foi despachado.');
-            console.log(`  slug da sessao : ${r.slug}`);
-            console.log(`  prompt         : ${r.promptPath}`);
-            console.log(`  sha256         : ${r.promptSha256}`);
-            console.log(`  pausa ao fim   : ${r.pausaAoFim ? 'sim' : 'nao'}`);
-            console.log(`  runtime        : ${r.runtime}`);
-            console.log(`  modelo/esforco : ${r.model}/${r.effort}`);
+            console.log(m.simulacao);
+            console.log(campo(rt.slug, r.slug));
+            console.log(campo(rt.prompt, `${r.promptPath}`));
+            console.log(campo(rt.sha256, `${r.promptSha256}`));
+            console.log(campo(rt.pausaAoFim, m.simNao(!!r.pausaAoFim)));
+            console.log(campo(rt.runtime, `${r.runtime}`));
+            console.log(campo(rt.modelo, `${r.model}/${r.effort}`));
             // O prompt inteiro nao cabe na tela: o argumento longo aparece mascarado.
-            console.log(`  comando        : ${r.comando.map((c) => (c.length > 80 ? '"<prompt>"' : c)).join(' ')}`);
+            console.log(campo(rt.comando, r.comando.map((c) => (c.length > 80 ? '"<prompt>"' : c)).join(' ')));
             for (const l of (0, policies_1.linhasDeAviso)(r.violacoes ?? []))
                 console.log(l);
             return 0;
         }
         if (r.bloqueado) {
-            console.error(`Despacho BLOQUEADO pelo gate tipado: ${r.motivo}`);
+            console.error(m.bloqueado(`${r.motivo}`));
             for (const v of r.violacoes) {
                 console.error(`  [${v.severidade}] policy ${v.policy}: ${v.detalhe}`);
-                console.error(`           correcao: ${v.correcao}`);
+                console.error(m.violacaoCorrecao(v.correcao));
             }
-            console.error(`  o prompt nao foi gravado em disco; evento gate_blocked no ledger de ${id}`);
+            console.error(m.promptNaoGravado(id));
             return 1;
         }
         if (!r.sessionId) {
             // I-35: o erro vai ao ledger com o ISO; o dono le no fuso dele, com o fuso dito uma vez.
-            console.error(`Despacho falhou: ${r.erro ? (0, horario_1.localizarTextoRotulado)(r.erro) : r.erro}`);
-            console.error(`  evento registrado no ledger de ${id}`);
+            console.error(m.falhou(`${r.erro ? (0, horario_1.localizarTextoRotulado)(r.erro) : r.erro}`));
+            console.error(m.falhouLedger(id));
             return 1;
         }
-        console.log(`Fase ${fase} despachada como background agent.`);
+        console.log(m.despachada(fase));
         for (const l of (0, policies_1.linhasDeAviso)(r.violacoes ?? []))
             console.log(l);
-        console.log(`  sessionId      : ${r.sessionId}`);
-        console.log(`  slug da sessao : ${r.slug} (${(0, phase_1.descreverSlug)(r.slug)})`);
-        console.log(`  prompt         : ${r.promptPath}`);
-        console.log(`  sha256         : ${r.promptSha256}`);
-        console.log(`  runtime        : ${r.runtime}`);
-        console.log(`  modelo/esforco : ${r.model}/${r.effort} (gravado no ledger, veja \`ork phase list\`)`);
-        console.log(`  verificada no runtime: ${r.verificada ? 'sim' : 'NAO (confira `ork sessions`)'}`);
-        console.log(`  pausa ao fim do bloco: ${r.pausaAoFim ? 'sim' : 'nao (decisao autonoma no ledger)'}`);
+        console.log(campo(rt.sessionId, r.sessionId));
+        console.log(campo(rt.slug, `${r.slug} (${(0, phase_1.descreverSlug)(r.slug)})`));
+        console.log(campo(rt.prompt, `${r.promptPath}`));
+        console.log(campo(rt.sha256, `${r.promptSha256}`));
+        console.log(campo(rt.runtime, `${r.runtime}`));
+        console.log(campo(rt.modelo, m.modeloGravado(`${r.model}`, `${r.effort}`)));
+        console.log(m.verificada(!!r.verificada));
+        console.log(m.pausaNoFim(!!r.pausaAoFim));
         console.log('');
         if (r.runtime === 'claude-bg') {
-            console.log(`Acompanhe: claude attach ${r.sessionId}  |  ork phase list ${id}`);
+            console.log(m.acompanheClaude(r.sessionId, id));
         }
         else {
-            console.log(`Acompanhe: ork phase list ${id} (eventos do despacho no log da thread)`);
+            console.log(m.acompanhe(id));
         }
         return r.verificada ? 0 : 1;
     }
     if (sub === 'list') {
         const id = args.posicionais[2];
         if (!id) {
-            console.error('uso: ork phase list <thread-id>');
+            console.error(m.usoList);
             return 2;
         }
         console.log((0, phase_1.tabelaDoLedger)(carregado.raiz, id));
         return 0;
     }
-    console.error(`subcomando desconhecido: phase ${sub}`);
+    console.error((0, locale_1.msg)().cli.subcomandoDesconhecido('phase', sub));
     return 2;
 }
 function comandoLedger(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
     const sub = args.posicionais[1];
+    const m = (0, locale_1.msg)().operacao.ledger;
     if (sub === 'stats') {
         const desde = texto(args.opcoes.desde);
         if (!desde)
-            throw Error('uso: ork ledger stats --desde 7d [--ate ISO] [--thread T] [--modo M] [--runtime R] [--json]');
+            throw Error(m.usoStats);
         const r = (0, ledger_stats_1.coletarEstatisticas)(carregado.raiz, { desde, ate: texto(args.opcoes.ate), thread: texto(args.opcoes.thread), modo: texto(args.opcoes.modo), runtime: texto(args.opcoes.runtime) });
         console.log(args.opcoes.json === true ? JSON.stringify(r, null, 2) : (0, ledger_stats_1.textoDasEstatisticas)(r));
         return 0;
@@ -1284,12 +1138,12 @@ function comandoLedger(args) {
         const thread = args.posicionais[2], semIa = Number(texto(args.opcoes['sem-ia'])), iaSemOrk = Number(texto(args.opcoes['ia-sem-ork']));
         const por = texto(args.opcoes.por), metodo = texto(args.opcoes.metodo), premissas = texto(args.opcoes.premissas);
         if (!thread || !por || !metodo || !premissas)
-            throw Error('uso: ork ledger estimate <thread-id> --sem-ia H --ia-sem-ork H --por Q --metodo M --premissas P [--incerteza I]');
+            throw Error(m.usoEstimate);
         const e = (0, ledger_stats_1.registrarEstimativaPlano)(carregado.raiz, thread, { semIaHoras: semIa, iaSemOrkHoras: iaSemOrk, por, metodo, premissas, incerteza: texto(args.opcoes.incerteza) });
-        console.log(args.opcoes.json === true ? JSON.stringify(e, null, 2) : `Estimativa PLAN registrada em ${thread}: sem IA ${semIa} h; IA sem Orkastery ${iaSemOrk} h.`);
+        console.log(args.opcoes.json === true ? JSON.stringify(e, null, 2) : m.estimativa(thread, semIa, iaSemOrk));
         return 0;
     }
-    throw Error('uso: ork ledger stats|estimate ...');
+    throw Error(m.uso);
 }
 /**
  * `ork sessions hitl`: quem, entre as sessoes do runtime, espera o humano AGORA.
@@ -1303,10 +1157,11 @@ function comandoLedger(args) {
  * como falha acionavel, sem precisar interpretar texto.
  */
 function comandoSessionsHitl(args, raiz) {
+    const ms = (0, locale_1.msg)().operacao.restante.sessions;
     const bruto = texto(args.opcoes.atencao);
     const atencaoMin = bruto === undefined ? undefined : Number(bruto);
     if (atencaoMin !== undefined && (!Number.isFinite(atencaoMin) || atencaoMin < 0)) {
-        console.error(`--atencao espera minutos (inteiro >= 0), recebeu "${bruto}"`);
+        console.error(ms.atencao(bruto ?? ''));
         return 2;
     }
     const radar = (0, hitl_1.varrerSessoes)({
@@ -1328,26 +1183,27 @@ function comandoSessionsHitl(args, raiz) {
     return 0;
 }
 function comandoSessions(args) {
+    const ms = (0, locale_1.msg)().operacao.restante.sessions;
     const sub = args.posicionais[1];
     const carregado = (0, manifest_1.carregarManifesto)();
     const raiz = carregado?.raiz ?? (0, manifest_1.diretorioDoProjeto)();
     if (sub === 'watch') {
         const id = texto(args.opcoes.thread);
         if (!carregado || !id) {
-            console.error('uso: ork sessions watch --thread T [--sessao ID] [--once]');
+            console.error(ms.usoWatch);
             return 2;
         }
         const thread = (0, thread_1.lerThread)(raiz, id);
         const sessionId = texto(args.opcoes.sessao) ?? thread.sessoes.at(-1)?.sessionId;
         if (!sessionId || !thread.sessoes.some(s => s.sessionId === sessionId))
-            throw new Error('sessão não pertence à thread');
+            throw new Error(ms.sessaoDaThread);
         console.log(JSON.stringify(args.opcoes.once === true ? (0, session_watcher_1.observarSessao)(carregado, sessionId) : { pid: (0, session_watcher_1.iniciarWatcher)(raiz, sessionId) }));
         return 0;
     }
     if (sub === 'event') {
         const tipo = texto(args.opcoes.tipo), sessao = texto(args.opcoes.sessao);
         if (!carregado || !tipo || !sessao) {
-            console.error('uso: ork sessions event --tipo <tipo> --sessao <id> < payload.json (máximo 16384 bytes)');
+            console.error(ms.usoEvent);
             return 2;
         }
         try {
@@ -1355,7 +1211,7 @@ function comandoSessions(args) {
             return 0;
         }
         catch (e) {
-            console.error(`evento recusado: ${e.message}`);
+            console.error(ms.eventoRecusado(e.message));
             return 1;
         }
     }
@@ -1366,7 +1222,7 @@ function comandoSessions(args) {
     }
     if (sub === 'limpar-fantasmas') {
         if (!carregado) {
-            console.error('ork sessions limpar-fantasmas precisa de um projeto (orkastery.yaml)');
+            console.error(ms.exigeProjeto);
             return 2;
         }
         const r = (0, sessoes_2.limparFantasmas)(raiz, { dryRun: args.opcoes['dry-run'] === true });
@@ -1380,14 +1236,14 @@ function comandoSessions(args) {
         const id = args.posicionais[2], sessionId = args.posicionais[3];
         const fase = texto(args.opcoes.fase), runtime = texto(args.opcoes.runtime), pergunta = texto(args.opcoes.pergunta);
         if (!id || !sessionId || !fase || !types_1.FASES.includes(fase) || !runtime)
-            throw new Error('sessions request exige thread, UUID, --fase e --runtime; --pergunta só confere o conteúdo nativo');
+            throw new Error(ms.request);
         console.log(JSON.stringify((0, hitl_sessions_1.abrirPedidoSessao)(raiz, id, sessionId, { fase: fase, runtime, pergunta, prazo: texto(args.opcoes.prazo) })));
         return 0;
     }
     if (sub === 'answer') {
         const id = args.posicionais[2], pedido = args.posicionais[3];
         if (!id || !pedido || args.opcoes.stdin !== true)
-            throw new Error('sessions answer exige thread, pedido e envelope autenticado em --stdin');
+            throw new Error(ms.answer);
         const r = (0, hitl_gates_1.lerRespostaStdin)({ origem: texto(args.opcoes.origem), por: texto(args.opcoes.por),
             mensagem: texto(args.opcoes.mensagem), canal: texto(args.opcoes.canal), conta: texto(args.opcoes.conta) });
         console.log(JSON.stringify((0, hitl_sessions_1.responderSessao)(raiz, id, pedido, r)));
@@ -1398,7 +1254,7 @@ function comandoSessions(args) {
         // pergunta ao receptor, pelo recibo correlacionado, se ele recebeu aquele envioId.
         const id = args.posicionais[2], pedido = args.posicionais[3];
         if (!id || !pedido)
-            throw new Error('sessions reconcile exige thread e pedido');
+            throw new Error(ms.reconcile);
         const r = (0, hitl_sessions_1.reconciliarEnvioDeSessao)(raiz, id, pedido);
         console.log(JSON.stringify(r));
         return r.estado === 'entregue' ? 0 : 1;
@@ -1407,13 +1263,13 @@ function comandoSessions(args) {
         const id = args.posicionais[2], sessionId = args.posicionais[3];
         const fase = texto(args.opcoes.fase), runtime = texto(args.opcoes.runtime);
         if (!id || !sessionId || !fase || !types_1.FASES.includes(fase) || !runtime)
-            throw new Error('sessions supersede exige thread, UUID, --fase e --runtime');
+            throw new Error(ms.supersede);
         console.log(JSON.stringify((0, hitl_sessions_1.superarSessao)(raiz, id, sessionId, fase, runtime)));
         return 0;
     }
     const chave = args.posicionais[2];
     if (!chave) {
-        console.error(`uso: ork sessions ${sub} <sessao>`);
+        console.error(ms.usoSub(sub));
         return 2;
     }
     if (sub === 'adopt') {
@@ -1438,7 +1294,7 @@ function comandoSessions(args) {
         console.log(r.texto);
         return r.codigo;
     }
-    console.error(`subcomando desconhecido: sessions ${sub}`);
+    console.error(ms.desconhecido(sub));
     return 2;
 }
 /**
@@ -1453,15 +1309,15 @@ function comandoDecisao(args) {
         const campo = (nome) => {
             const v = texto(args.opcoes[nome]);
             if (!v)
-                throw new Error(`decisao registrar exige --${nome}`);
+                throw new locale_1.ErroDoCatalogo((m) => m.decisao.exigeFlag(nome));
             return v;
         };
         if (!id)
-            throw new Error('uso: ork decisao registrar <thread-id> --decidido D --porque P ...');
+            throw new locale_1.ErroDoCatalogo((m) => m.decisao.usoRegistrar);
         const bruto = campo('criterio'), separador = bruto.indexOf(':');
         const tipo = bruto.slice(0, separador), referencia = bruto.slice(separador + 1);
         if (separador < 1 || !['manifesto', 'ledger', 'medicao'].includes(tipo) || !referencia.trim()) {
-            throw new Error('decisao registrar: --criterio manifesto:CHAVE, ledger:REF ou medicao:COMANDO');
+            throw new locale_1.ErroDoCatalogo((m) => m.decisao.criterioUso);
         }
         const entrada = {
             decidido: campo('decidido'), porque: campo('porque'), comoMudar: campo('como-mudar'),
@@ -1483,8 +1339,10 @@ function comandoDecisao(args) {
         return 0;
     }
     if (sub === 'placar') {
+        // RM-061 (F3b): o placar pelo catalogo; o `--json` e a fase de cada linha sao dado e nao mudam.
+        const md = (0, locale_1.msg)().decisao;
         if (!id)
-            throw new Error('uso: ork decisao placar <thread-id> [--json]');
+            throw new locale_1.ErroDoCatalogo((m) => m.decisao.usoPlacar);
         (0, thread_1.lerThread)(carregado.raiz, id);
         const placar = (0, decisao_autonoma_1.placarDaThread)((0, ledger_1.lerLedger)((0, thread_1.dirThread)(carregado.raiz, id)));
         const taxa = (0, decisao_autonoma_1.taxaDeReversao)(placar);
@@ -1492,12 +1350,12 @@ function comandoDecisao(args) {
             console.log(JSON.stringify({ thread: id, limiar: decisao_autonoma_1.LIMIAR_DE_DECISOES_POR_FASE, taxaDeReversao: taxa, fases: placar }, null, 2));
             return 0;
         }
-        console.log((0, util_1.tabela)(['FASE', 'DECIDIDAS', 'INFORMADAS', 'PERGUNTAS', 'REVERTIDAS', 'SEM RASTRO', 'LIMIAR'], placar.map(f => [f.fase, String(f.decididas), String(f.informadas), String(f.perguntas), String(f.revertidas),
-            String(f.semRastro), f.acimaDoLimiar ? `acima de ${decisao_autonoma_1.LIMIAR_DE_DECISOES_POR_FASE}: revisar` : 'ok'])));
-        console.log(`\ntaxa de reversão das decisões informadas: ${taxa === null ? 'sem decisão informada ainda' : `${Math.round(taxa * 100)}%`}`);
+        console.log((0, util_1.tabela)([...md.colunasDoPlacar], placar.map(f => [f.fase, String(f.decididas), String(f.informadas), String(f.perguntas), String(f.revertidas),
+            String(f.semRastro), f.acimaDoLimiar ? md.acimaDoLimiar(decisao_autonoma_1.LIMIAR_DE_DECISOES_POR_FASE) : md.dentroDoLimiar])));
+        console.log(md.taxaDeReversao(taxa));
         return 0;
     }
-    throw new Error('uso: ork decisao registrar|placar <thread-id>');
+    throw new locale_1.ErroDoCatalogo((m) => m.decisao.uso);
 }
 /**
  * I-50 (RM-039): a tag que o dono manda no Telegram, pelo terminal. Sem tag, mostra a cadencia em
@@ -1505,14 +1363,15 @@ function comandoDecisao(args) {
  */
 function comandoCadenciaDoPulse(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
+    const m = (0, locale_1.msg)().operacao.pulseCadencia;
     if (args.posicionais.length > 3)
-        throw new Error('pulse cadencia: uma tag por vez');
+        throw new Error(m.umaTag);
     const bruta = args.posicionais[2];
     const agora = new Date().toISOString();
     if (bruta !== undefined) {
         const lido = (0, pulse_resposta_1.interpretarRespostaDoPulse)(bruta.trim().startsWith('#') ? bruta : `#${bruta.trim()}`);
         if (lido.forma !== 'cadencia') {
-            throw new Error(`pulse cadencia: tag desconhecida "${bruta}"; use ${Object.keys(pulse_cadencia_1.CADENCIAS).join(', ')}`);
+            throw new Error(m.desconhecida(bruta, Object.keys(pulse_cadencia_1.CADENCIAS).join(', ')));
         }
         (0, pulse_cadencia_1.gravarCadencia)(carregado.raiz, lido.tag, { por: texto(args.opcoes.por) ?? (0, node_os_1.userInfo)().username,
             canal: texto(args.opcoes.canal) ?? 'terminal', em: agora });
@@ -1525,39 +1384,42 @@ function comandoCadenciaDoPulse(args) {
     }
     console.log((0, pulse_cadencia_1.textoDaCadencia)(vigente, agora));
     console.log(vigente.gravada
-        ? `Trocada por ${vigente.gravada.por} (${vigente.gravada.canal}) em ${(0, horario_1.formatarDataHoraRotulada)(vigente.gravada.em)}.`
-        : 'Nenhuma tag gravada: vale a cadência padrão.');
+        ? m.trocada(vigente.gravada.por, vigente.gravada.canal, (0, horario_1.formatarDataHoraRotulada)(vigente.gravada.em))
+        : m.padrao);
     return 0;
 }
 function comandoClaims(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
     const sub = args.posicionais[1];
+    // RM-061 (F3b, D3): o texto pelo catalogo; o que se grava (claims.jsonl, ledger) roda no escopo pt-BR, e a alegacao,
+    // o arquivo, o comando e o motivo digitado saem como vieram. O estado da claim so se traduz na impressao.
+    const mc = (0, locale_1.msg)().claims;
     if (sub === 'add') {
         const id = args.posicionais[2];
         const arquivo = args.posicionais[3];
         const alegacao = texto(args.opcoes.claim) ?? texto(args.opcoes.alegacao);
         if (!id || !arquivo || !alegacao) {
-            console.error('uso: ork claims add <thread-id> <arquivo> --claim "<alegacao>" [--verificar "<comando>"]');
+            console.error(mc.usoAdd);
             return 2;
         }
         const comando = texto(args.opcoes.verificar) ?? texto(args.opcoes.verify);
         const faseBruta = texto(args.opcoes.fase);
         const thread = (0, thread_1.lerThread)(carregado.raiz, id);
-        const claim = (0, claims_1.adicionarClaim)(carregado.raiz, id, {
+        const claim = (0, locale_1.comLocale)('pt-BR', () => (0, claims_1.adicionarClaim)(carregado.raiz, id, {
             arquivo,
             alegacao,
             verificar: comando ? [comando] : [],
             fase: faseBruta ? (0, thread_1.exigirFase)(thread, faseBruta) : undefined,
-        });
-        console.log(`Claim ${claim.id} registrada na thread ${id}.`);
-        console.log(`  arquivo    ${claim.arquivo}`);
-        console.log(`  alegacao   ${claim.alegacao}`);
-        console.log(`  negativa   ${claim.negativa ? 'sim (exige comando de verificacao)' : 'nao'}`);
-        console.log(`  verificar  ${claim.verificar.join(' && ') || '(nenhum comando declarado)'}`);
-        console.log(`  estado     ${claim.estado}`);
+        }));
+        console.log(mc.registrada(claim.id, id));
+        console.log(mc.campoArquivo(claim.arquivo));
+        console.log(mc.campoAlegacao(claim.alegacao));
+        console.log(mc.campoNegativa(claim.negativa));
+        console.log(mc.campoVerificar(claim.verificar.join(' && ')));
+        console.log(mc.campoEstado(mc.estado(claim.estado)));
         if (claim.negativa && claim.verificar.length === 0) {
             console.log('');
-            console.log('AVISO: alegacao negativa sem comando de verificacao reprova em `ork verify`.');
+            console.log(mc.avisoNegativa);
         }
         // RM-008 (B8): a conferencia local da policy claim_sem_prova_local avisa e segue.
         const linhasDePolicy = (0, policies_1.linhasDeAviso)(claim.avisosDePolicy ?? []);
@@ -1569,24 +1431,59 @@ function comandoClaims(args) {
         // I-53 (RM-037, P6): o lint avisa aqui; a suite inteira e recusada no `ci prepare`.
         for (const a of claim.lint ?? []) {
             console.log('');
-            console.log(`AVISO: ${(0, claim_lint_1.linhaDoLintDeClaim)(claim.id, a)}${a.regra === 'suite-inteira' ? '. O `ci prepare` recusa esta claim.' : ''}`);
+            console.log(mc.avisoDoLint((0, claim_lint_1.linhaDoLintDeClaim)(claim.id, a), a.regra === 'suite-inteira'));
         }
         return 0;
     }
+    if (sub === 'conferir') {
+        // RM-059 (T0.10): so o que foi pedido, no sandbox do verify, sob a conducao da thread, sem recibo.
+        const id = args.posicionais[2];
+        const json = args.opcoes.json === true;
+        const claims = texto(args.opcoes.claims);
+        const tarefa = texto(args.opcoes.tarefa);
+        const prazo = texto(args.opcoes.prazo);
+        const semValor = ['claims', 'tarefa', 'prazo'].some((o) => args.opcoes[o] === true);
+        if (!id || semValor || (claims === undefined) === (tarefa === undefined)) {
+            console.error(mc.usoConferir);
+            return 2;
+        }
+        const conducao = conducaoDoCli(args);
+        try {
+            // O resultado e as recusas nascem em pt-BR, como o --json os leva; o texto os remonta no locale do comando.
+            const r = (0, locale_1.comLocale)('pt-BR', () => (0, claims_conferir_1.conferirClaims)(carregado, id, {
+                claims: claims !== undefined ? (0, claims_conferir_1.idsDeClaims)(claims) : undefined,
+                tarefa,
+                prazoMs: prazo !== undefined ? Number(prazo) * 1000 : undefined,
+                canal: conducao.canal,
+                correlacao: conducao.correlacao,
+            }));
+            console.log(json ? JSON.stringify(r, null, 2) : (0, claims_conferir_1.textoDaConferencia)(r));
+            return r.ok ? 0 : 1;
+        }
+        catch (e) {
+            if (!(e instanceof claims_conferir_1.ErroDeConferencia))
+                throw e;
+            if (json)
+                console.log(JSON.stringify({ formato: claims_conferir_1.FORMATO_DA_CONFERENCIA, thread: id, ok: false, erro: e.message }, null, 2));
+            else
+                console.error((0, locale_1.mensagemDoErro)(e));
+            return 2;
+        }
+    }
     if (sub === 'verificar') {
         const id = args.posicionais[2];
         const claimId = args.posicionais[3];
         const comando = texto(args.opcoes.comando) ?? texto(args.opcoes.verificar);
         if (!id || !claimId || !comando) {
-            console.error('uso: ork claims verificar <thread-id> <claim-id> --comando "<comando>"');
+            console.error(mc.usoVerificar);
             return 2;
         }
-        const claim = (0, claims_1.anexarComando)(carregado.raiz, id, claimId, comando);
-        console.log(`Claim ${claim.id} agora tem comando de verificacao.`);
-        console.log(`  verificar  ${claim.verificar.join(' && ')}`);
-        console.log(`  estado     ${claim.estado}`);
+        const claim = (0, locale_1.comLocale)('pt-BR', () => (0, claims_1.anexarComando)(carregado.raiz, id, claimId, comando));
+        console.log(mc.comandoAnexado(claim.id));
+        console.log(mc.campoVerificar(claim.verificar.join(' && ')));
+        console.log(mc.campoEstado(mc.estado(claim.estado)));
         console.log('');
-        console.log(`Prove agora: ork verify ${id}`);
+        console.log(mc.proveAgora(id));
         return 0;
     }
     if (sub === 'retirar') {
@@ -1594,14 +1491,14 @@ function comandoClaims(args) {
         const claimId = args.posicionais[3];
         const motivo = texto(args.opcoes.motivo);
         if (!id || !claimId || !motivo) {
-            console.error('uso: ork claims retirar <thread-id> <claim-id> --motivo "<motivo>"');
+            console.error(mc.usoRetirar);
             return 2;
         }
-        const claim = (0, claims_1.retirarClaim)(carregado.raiz, id, claimId, motivo);
-        console.log(`Claim ${claim.id} retirada da thread ${id}.`);
-        console.log(`  alegacao   ${claim.alegacao}`);
-        console.log(`  motivo     ${motivo}`);
-        console.log('  o historico da alegacao continua no claims.jsonl e no ledger.');
+        const claim = (0, locale_1.comLocale)('pt-BR', () => (0, claims_1.retirarClaim)(carregado.raiz, id, claimId, motivo));
+        console.log(mc.retirada(claim.id, id));
+        console.log(mc.campoAlegacao(claim.alegacao));
+        console.log(mc.campoMotivo(motivo));
+        console.log(mc.historicoContinua);
         return 0;
     }
     if (sub === 'ausente') {
@@ -1609,53 +1506,66 @@ function comandoClaims(args) {
         const paths = (texto(args.opcoes.paths) ?? '').split(',').map((p) => p.trim()).filter(Boolean);
         const motivo = texto(args.opcoes.motivo);
         if (!id || paths.length === 0 || !motivo) {
-            console.error('uso: ork claims ausente <thread-id> --paths A,B --motivo "<motivo>" [--commit SHA]');
+            console.error(mc.usoAusente);
             return 2;
         }
-        (0, prova_minima_1.registrarProvaAusente)(carregado.raiz, id, { paths, motivo, commit: texto(args.opcoes.commit) });
-        console.log(`Ausencia de prova registrada na thread ${id}: ${paths.join(', ')}.`);
-        console.log(`  motivo     ${motivo}`);
+        (0, locale_1.comLocale)('pt-BR', () => (0, prova_minima_1.registrarProvaAusente)(carregado.raiz, id, { paths, motivo, commit: texto(args.opcoes.commit) }));
+        console.log(mc.ausenciaRegistrada(id, paths.join(', ')));
+        console.log(mc.campoMotivo(motivo));
         return 0;
     }
     if (sub === 'list' || sub === undefined) {
         const id = args.posicionais[2];
         if (!id) {
-            console.error('uso: ork claims list <thread-id>');
+            console.error(mc.usoList);
             return 2;
         }
         console.log((0, claims_1.tabelaDeClaims)(carregado.raiz, id));
         return 0;
     }
-    console.error(`subcomando desconhecido: claims ${sub}`);
+    console.error((0, locale_1.msg)().cli.subcomandoDesconhecido('claims', sub));
     return 2;
 }
 function comandoVerify(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
     const id = args.posicionais[1];
+    const m = (0, locale_1.msg)().verify;
     if (!id) {
-        console.error('uso: ork verify <thread-id> [--baseline] [--so-claims] [--canal C] [--esperar [min]]');
+        console.error(m.uso);
         return 2;
     }
-    const conducao = conducaoDoCli(args);
+    // RM-072 (D1): `--check classic|agile` vence o `check.mode` do manifesto; outro valor sai com 2 e os dois aceitos.
+    const brutoDoCheck = args.opcoes.check;
+    const check = brutoDoCheck === undefined ? undefined : (0, check_modo_1.lerModo)(brutoDoCheck);
+    if (check === null) {
+        console.error(m.checkInvalido(typeof brutoDoCheck === 'string' ? brutoDoCheck : null));
+        return 2;
+    }
+    // RM-058 N2 (D10): enquanto a fila de recursos pesados nao da a vez, o CLI diz uma vez por quem espera.
+    const aoEsperar = (ocupantes) => console.error(m.filaPesadaEsperando(args.opcoes.baseline === true ? 'baseline' : 'verify', ocupantes.map((o) => m.filaPesadaOcupante(o.operacao, o.thread, (0, horario_1.formatarDataHora)(o.desde))).join('; ')));
+    const doCli = conducaoDoCli(args);
+    // O `ork verify` do CLI espera a fila em primeiro plano ate `--esperar` ou 60 min; a recusa sugere o dobro.
+    const conducao = { ...doCli, filaPesada: { aoEsperar, esperarMs: doCli.esperarMs ?? verify_1.ESPERA_DA_FILA_PESADA_MS,
+            comandoDeEsperar: `ork verify ${id}${args.opcoes.baseline === true ? ' --baseline' : ''} --esperar 120` } };
     if (args.opcoes.baseline === true) {
-        const b = (0, verify_1.gravarBaseline)(carregado, id, undefined, conducao);
-        console.log(`Baseline gravada para a thread ${id}.`);
-        console.log(`  commit ${b.commit}`);
-        for (const c of b.comandos) {
-            console.log(`  ${c.nome.padEnd(10)} ${c.ok ? 'passava' : `ja falhava (codigo ${c.code})`}  ${c.comando}`);
-        }
+        // RM-061 (F2b, G2): a baseline e o ledger sao gravados em pt-BR; so a impressao segue o locale.
+        const b = (0, locale_1.comLocale)('pt-BR', () => (0, verify_1.gravarBaseline)(carregado, id, undefined, conducao, 'cli', undefined, check));
+        console.log(m.baselineGravada(id));
+        console.log(m.baselineCommit(b.commit));
+        // RM-037 (defeito 1 de 19 e 20/10/2026): o comando sem veredito nao sai como "ja falhava".
+        for (const linha of (0, verify_1.linhasDaBaseline)(b, id))
+            console.log(linha);
         if (b.comandos.some((c) => !c.ok)) {
             // Ensaio de 03/10 (R7): "ja falhava" sem dizer onde ver a saida do comando.
-            console.log(`  saida de quem falhou: as ultimas linhas em ${(0, thread_1.caminhoThread)(carregado.raiz, id)}, campo baseline.comandos ` +
-                `(resumo e trecho); o evento baseline_recorded esta em ork phase list ${id}`);
+            console.log(m.baselineSaida((0, thread_1.caminhoThread)(carregado.raiz, id), id));
         }
         if (b.comandos.length === 0) {
             // Fatia 2 do ensaio da 0.5.0 (R5): a baseline foi gravada; o que falta e comando, nao baseline.
-            console.log('  (nenhum comando em verify: no manifesto: a baseline guarda so o commit, e o verify nao tem como separar regressao de divida)');
+            console.log(m.baselineSemComandos);
         }
         return 0;
     }
-    const r = (0, verify_1.verificar)(carregado, id, { soClaims: args.opcoes['so-claims'] === true, conducao });
+    const r = (0, locale_1.comLocale)('pt-BR', () => (0, verify_1.verificar)(carregado, id, { soClaims: args.opcoes['so-claims'] === true, conducao, check }));
     console.log((0, verify_1.textoDoVerify)(r));
     return r.ok ? 0 : 1;
 }
@@ -1663,13 +1573,116 @@ function comandoVerify(args) {
  * `ork conducao status|assumir` (I-36, T15): quem conduz a thread agora, e o handoff explicito. O
  * status tambem libera, com prova no ledger, a conducao que ficou sem dono (T16).
  */
+/**
+ * RM-059 (F6, T6.4; DD5 do plano dos mods): `ork conducao sentinela status|bater|desligar`. A presenca da
+ * Sentinela do Condutor nesta maquina e o passo do condutor em cada thread aberta; o condutor externo le o
+ * `status --json` para ceder o despacho enquanto a presenca vale. Nada aqui despacha.
+ */
+function comandoSentinela(carregado, args) {
+    const m = (0, locale_1.msg)().conducao.cli;
+    const acao = args.posicionais[2] ?? 'status';
+    const json = args.opcoes.json === true;
+    if (acao === 'status') {
+        const s = (0, conducao_sentinela_1.statusDaSentinela)(carregado);
+        console.log(json ? JSON.stringify(s, null, 2) : (0, conducao_sentinela_1.textoDoStatusDaSentinela)(s));
+        return 0;
+    }
+    if (acao !== 'bater' && acao !== 'desligar')
+        throw new Error(m.sentinelaUso);
+    const sessao = texto(args.opcoes.sessao);
+    if (!sessao)
+        throw new Error(m.sentinelaSessao(acao));
+    if (acao === 'bater') {
+        const r = (0, conducao_sentinela_1.baterSentinela)(carregado.raiz, { sessao });
+        const curta = r.presenca.sessao.slice(0, 8);
+        console.log(json ? JSON.stringify(r, null, 2) : r.ok
+            ? m.sentinelaLigada(r.ligou, r.presenca.maquina, curta)
+            : m.sentinelaOutra(curta, r.presenca.maquina));
+        return r.ok ? 0 : 3;
+    }
+    const motivo = texto(args.opcoes.motivo);
+    const r = (0, conducao_sentinela_1.desligarSentinela)(carregado.raiz, { sessao, ...(motivo ? { motivo } : {}) });
+    console.log(json ? JSON.stringify(r, null, 2) : r.desligada ? m.sentinelaOff : m.sentinelaNada);
+    return 0;
+}
+/**
+ * RM-063 (F7): `ork conducao autorizar|autorizacao`. A autorizacao duravel do dono nesta maquina
+ * (`ork.autorizacao-duravel/v1`, fora do git): o que a batida da conducao pode fazer sozinha e ate quando.
+ */
+function comandoAutorizacao(carregado, args, sub) {
+    const m = (0, locale_1.msg)().conducao.cli;
+    const json = args.opcoes.json === true;
+    const projeto = carregado.manifesto.project.name;
+    if (sub === 'autorizacao') {
+        if (args.posicionais.length > 2)
+            throw new Error(m.autorizacaoUso);
+        const leitura = (0, autorizacao_duravel_1.lerAutorizacao)(carregado.raiz, { projeto });
+        console.log(json ? JSON.stringify(leitura, null, 2) : (0, autorizacao_duravel_1.textoDaAutorizacao)(leitura));
+        return 0;
+    }
+    const ate = texto(args.opcoes.ate), pode = texto(args.opcoes.pode);
+    if (!ate || !pode || args.posicionais.length > 2) {
+        throw new Error(m.autorizarUso);
+    }
+    const r = (0, autorizacao_duravel_1.gravarAutorizacao)(carregado.raiz, { ate, pode, por: texto(args.opcoes.por), nota: texto(args.opcoes.nota), projeto,
+        fuso: (0, horario_1.fusoDoManifesto)(carregado).fuso, canal: conducaoDoCli(args).canal });
+    if (!r.ok) {
+        console.log(json ? JSON.stringify(r, null, 2) : m.autorizacaoRecusada(r.motivo, r.detalhe));
+        return 1;
+    }
+    const a = r.anterior;
+    console.log(json ? JSON.stringify({ ok: true, leitura: r.leitura, anterior: a }, null, 2) : [
+        m.autorizacaoGravada((0, autorizacao_duravel_1.linhaDaAutorizacao)(r.leitura)),
+        ...(a ? [m.substitui(a.por, (0, horario_1.formatarDataHoraRotulada)(a.ate), a.pode.join(', '))] : []),
+        m.arquivo(r.leitura.arquivo)
+    ].join('\n'));
+    return 0;
+}
 function comandoConducao(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
+    const m = (0, locale_1.msg)().conducao.cli;
     const sub = args.posicionais[1];
     const id = args.posicionais[2];
+    if (sub === 'sentinela')
+        return comandoSentinela(carregado, args);
+    if (sub === 'autorizar' || sub === 'autorizacao')
+        return comandoAutorizacao(carregado, args, sub);
+    if (sub === 'batida') {
+        // RM-063 (F7): o passo deterministico da conducao, o mesmo que a varredura do cron roda depois do resumo.
+        if (args.posicionais.length > 2)
+            throw new Error(m.batidaUso);
+        const r = (0, conducao_batida_1.baterConducao)(carregado, { canal: conducaoDoCli(args).canal });
+        const textoDaRodada = (0, conducao_batida_1.textoDaBatida)(r);
+        console.log(args.opcoes.json === true ? JSON.stringify(r, null, 2) : textoDaRodada);
+        // RM-063 (H2): o `#OrkRetomar` do canal roda esta batida em segundo plano; o que voltou a andar volta ao dono pelo
+        // transporte do pulse (com o outro host configurado, se o primeiro falhar).
+        if (args.opcoes.entregar === true) {
+            const mensagem = `🔁 Orkastery, retomada em ${(0, maquina_1.nomeDaMaquina)()}:\n${textoDaRodada}`.slice(0, 3900);
+            try {
+                const e = (0, pulse_delivery_1.entregarPeloTransporte)(carregado.raiz, mensagem, { oQue: 'a retomada' });
+                if (!e.ok)
+                    console.error(m.pulseAviso);
+            }
+            catch (e) {
+                console.error(m.pulseFalha(e.message));
+            }
+        }
+        return r.ocupada ? 3 : 0;
+    }
+    if (sub === 'atualizar') {
+        // RM-063 (F7): o merge da base remota na branch da thread, com a reconciliacao do CHANGELOG; conflito em codigo aborta.
+        if (!id || args.posicionais.length > 3)
+            throw new Error(m.atualizarUso);
+        (0, thread_1.lerThread)(carregado.raiz, id);
+        const doCli = conducaoDoCli(args);
+        const r = (0, atualizar_branch_1.atualizarBranchDaThread)(carregado, id, { enviar: args.opcoes.enviar === true, canal: doCli.canal, correlacao: doCli.correlacao,
+            ...(doCli.esperarMs ? { esperarMs: doCli.esperarMs } : {}) });
+        console.log(args.opcoes.json === true ? JSON.stringify(r, null, 2) : (0, atualizar_branch_1.textoDaAtualizacao)(r));
+        return r.acao === 'mesclada' || r.acao === 'ja-atualizada' ? 0 : r.acao === 'recusada' && r.motivo === 'conduzida' ? 3 : 1;
+    }
     if (sub === 'status') {
         if (!id)
-            throw new Error('uso: ork conducao status <thread-id> [--json]');
+            throw new Error(m.statusUso);
         (0, thread_1.lerThread)(carregado.raiz, id);
         (0, conducao_1.liberarSeOrfa)(carregado.raiz, id);
         const atual = (0, conducao_1.conducaoDaThread)(carregado.raiz, id);
@@ -1679,12 +1692,12 @@ function comandoConducao(args) {
     if (sub === 'assumir') {
         const por = texto(args.opcoes.por), motivo = texto(args.opcoes.motivo);
         if (!id || !por || !motivo)
-            throw new Error('uso: ork conducao assumir <thread-id> --por <quem> --motivo "<por que>" [--canal C]');
+            throw new Error(m.assumirUso);
         const r = (0, conducao_1.assumirConducao)(carregado.raiz, id, { por, motivo, canal: conducaoDoCli(args).canal });
-        console.log(args.opcoes.json === true ? JSON.stringify(r, null, 2) : `${r.ok ? 'Conducao assumida.' : 'Handoff recusado.'} ${r.detalhe}`);
+        console.log(args.opcoes.json === true ? JSON.stringify(r, null, 2) : m.assumida(r.ok, r.detalhe));
         return r.ok ? 0 : 3;
     }
-    throw new Error('uso: ork conducao status|assumir <thread-id>');
+    throw new Error(m.uso);
 }
 /** RM-048 (D1): o gate aberto no contrato curto, com o codigo estavel e o "desde" do ledger. */
 function textoDoGateCurto(raiz, pedido, canal) {
@@ -1697,11 +1710,12 @@ function textoDoGateCurto(raiz, pedido, canal) {
 function comandoGate(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
     const sub = args.posicionais[1];
+    const mg = (0, locale_1.msg)().operacao.restante.gate;
     if (sub === 'context') {
         const id = args.posicionais[2], pedido = args.posicionais[3];
         if (!id || !pedido || args.posicionais.length !== 4 ||
             Object.entries(args.opcoes).some(([k, v]) => k !== 'native-offer-stdin' || v !== true))
-            throw Error('uso: ork gate context <thread> <pedido> [--native-offer-stdin]');
+            throw Error(mg.usoContext);
         const view = (0, hitl_gates_1.contextoDoPedidoNativo)(carregado.raiz, id, pedido);
         const callback = args.opcoes['native-offer-stdin'] ? (0, hitl_native_offer_1.readNativeOfferStdin)() : undefined;
         console.log(JSON.stringify({ ...view, canais: (0, hitl_presentation_1.ofertaDoPedido)(view.pedido, [], callback === undefined ? undefined : { callback, raiz: carregado.raiz }),
@@ -1711,10 +1725,10 @@ function comandoGate(args) {
     if (sub === 'request') {
         const id = args.posicionais[2];
         if (!id)
-            throw new Error('gate request exige thread');
+            throw new Error(mg.requestThread);
         const formato = texto(args.opcoes.formato);
         if (formato !== undefined && formato !== 'telegram' && formato !== 'terminal')
-            throw new Error('gate request: --formato telegram|terminal');
+            throw new Error(mg.formato);
         const pedido = (0, hitl_gates_1.abrirPedidoGate)(carregado.raiz, id, texto(args.opcoes.motivo));
         // RM-048 (D1): com --formato, o que sai e o pedido no contrato curto, pronto para o canal, com
         // o codigo estavel na ultima linha. Sem ele, o JSON de sempre, para quem integra.
@@ -1724,7 +1738,7 @@ function comandoGate(args) {
     if (sub === 'answer') {
         const id = args.posicionais[2], pedido = args.posicionais[3];
         if (!id || !pedido || args.opcoes['resposta-stdin'] !== true || args.opcoes.resposta !== undefined)
-            throw new Error('gate answer exige thread, pedido e --resposta-stdin');
+            throw new Error(mg.answer);
         const r = (0, hitl_gates_1.lerRespostaStdin)({ por: texto(args.opcoes.por), mensagem: texto(args.opcoes.mensagem),
             origem: texto(args.opcoes.origem), canal: texto(args.opcoes.canal), conta: texto(args.opcoes.conta) });
         console.log(JSON.stringify((0, hitl_gates_1.responderGate)(carregado.raiz, id, pedido, r)));
@@ -1733,7 +1747,7 @@ function comandoGate(args) {
     if (sub === 'next') {
         const id = args.posicionais[2];
         if (!id) {
-            console.error('uso: ork gate next <thread-id> [--proximo FASE] [--ocupacao 0..1]');
+            console.error(mg.usoNext);
             return 2;
         }
         const thread = (0, thread_1.lerThread)(carregado.raiz, id);
@@ -1757,18 +1771,18 @@ function comandoGate(args) {
         const sobre = args.posicionais[3];
         const por = texto(args.opcoes.por) ?? texto(args.opcoes.quem);
         if (!id || !sobre || !por) {
-            console.error('gate approve aposentado: aprovação sem pedido é recusada. Use ork gate request <thread-id> e responda pelo ingresso humano autenticado.');
+            console.error(mg.approveAposentado);
             return 2;
         }
         (0, thread_1.lerThread)(carregado.raiz, id);
         const e = (0, gates_1.aprovarGateHumano)(carregado.raiz, id, sobre, por, texto(args.opcoes.obs));
-        console.log(`Autorizacao humana registrada no ledger da thread ${id}.`);
-        console.log(`  sobre          ${sobre}`);
-        console.log(`  autorizado por ${por}`);
-        console.log(`  quando         ${(0, horario_1.formatarDataHoraRotulada)(e.ts)}`);
+        console.log(mg.registrado(id));
+        console.log(mg.sobre(sobre));
+        console.log(mg.autorizado(por));
+        console.log(mg.quando((0, horario_1.formatarDataHoraRotulada)(e.ts)));
         return 0;
     }
-    console.error(`subcomando desconhecido: gate ${sub}`);
+    console.error(mg.desconhecido(sub));
     return 2;
 }
 /**
@@ -1780,44 +1794,44 @@ function comandoGate(args) {
  */
 function comandoRetry(args) {
     const sub = args.posicionais[1];
+    const mr = (0, locale_1.msg)().retry, mc = mr.complementar;
     if (sub === 'policy') {
         const alvo = texto(args.opcoes.motivo);
         if (alvo) {
             const politica = retry_1.POLITICA_DE_RETRY[alvo];
             if (!politica) {
-                console.error(`motivo tipado desconhecido: ${alvo}`);
-                console.error(`  conhecidos: ${Object.keys(retry_1.POLITICA_DE_RETRY).join(', ')}`);
+                console.error(mc.motivoDesconhecido(alvo));
+                console.error(mc.conhecidos(Object.keys(retry_1.POLITICA_DE_RETRY).join(', ')));
                 return 2;
             }
             if (args.opcoes.json === true) {
                 console.log(JSON.stringify(politica, null, 2));
                 return 0;
             }
-            console.log(`motivo tipado: ${politica.motivo}`);
-            console.log(`  significado  ${auditoria_1.DESCRICAO_DO_MOTIVO_DE_AUDITORIA[politica.motivo]}`);
-            console.log(`  acao         ${politica.acao}`);
-            console.log(`  automatica   ${politica.automatica ? 'sim' : 'nao'}`);
-            console.log(`  por que      ${politica.porque}`);
-            console.log(`  correcao     ${politica.correcao}`);
+            console.log(mc.motivo(politica.motivo));
+            console.log(mc.significado((0, locale_1.localeAtivo)() === 'en' ? mr.politica[politica.motivo].porque : auditoria_1.DESCRICAO_DO_MOTIVO_DE_AUDITORIA[politica.motivo]));
+            console.log(mc.acao(politica.acao));
+            console.log(mc.automatica(politica.automatica ? mc.sim : mc.nao));
+            console.log(mc.porque(mr.politica[politica.motivo].porque));
+            console.log(mc.correcao(mr.politica[politica.motivo].correcao));
             return 0;
         }
         if (args.opcoes.json === true) {
             console.log(JSON.stringify(Object.values(retry_1.POLITICA_DE_RETRY), null, 2));
             return 0;
         }
-        console.log('Politica de retry por motivo tipado de gate (bloco B3)');
+        console.log(mc.politicaTitulo);
         console.log('');
         console.log((0, retry_1.tabelaDaPolitica)());
         console.log('');
-        console.log('A politica e a MESMA em todos os modos: o modo afrouxa a pausa, nunca a');
-        console.log('verificacao. cost.violation nunca recebe retry automatico, e o limite de');
-        console.log('escalacao (retry.max_tentativas) pausa qualquer modo, inclusive #Auto.');
+        for (const linha of mc.politicaFecho)
+            console.log(linha);
         return 0;
     }
     if (sub === 'parse') {
         const bruto = texto(args.opcoes.stderr) ?? args.posicionais.slice(2).join(' ');
         if (!bruto) {
-            console.error('uso: ork retry parse --stderr "<texto do stderr do adapter>"');
+            console.error(mc.usoParse);
             return 2;
         }
         const sinal = (0, ratelimit_1.parseRateLimit)(bruto);
@@ -1826,17 +1840,17 @@ function comandoRetry(args) {
             return sinal ? 0 : 1;
         }
         if (!sinal) {
-            console.log('Nenhum sinal de rate limit reconhecido neste texto.');
+            console.log(mc.semSinal);
             return 1;
         }
-        console.log('Sinal de rate limit reconhecido no stderr do runtime:');
-        console.log(`  fonte da hora  ${sinal.fonte}`);
-        console.log(`  reset em       ${sinal.resetEm ? (0, horario_1.formatarDataHoraRotulada)(sinal.resetEm) : '(o runtime nao disse a hora)'}`);
-        console.log(`  trecho         ${sinal.trecho}`);
+        console.log(mc.sinal);
+        console.log(mc.fonte(sinal.fonte));
+        console.log(mc.reset(sinal.resetEm ? (0, horario_1.formatarDataHoraRotulada)(sinal.resetEm) : mc.semHora));
+        console.log(mc.trecho(sinal.trecho));
         if (sinal.resetEm === null) {
             console.log('');
-            console.log('  Sem hora no texto, a fila usa retry.janela_padrao_min do manifesto e marca');
-            console.log('  o pedido como janela ESTIMADA. O `ork` nao inventa horario de reset.');
+            for (const linha of mc.estimada)
+                console.log(linha);
         }
         return 0;
     }
@@ -1845,7 +1859,7 @@ function comandoRetry(args) {
     if (sub === 'plan' || sub === 'run') {
         const id = args.posicionais[2];
         if (!id) {
-            console.error(`uso: ork retry ${sub} <thread-id> [--motivo M] [--fase F]`);
+            console.error((0, locale_1.msg)().retry.usoPlanRun(sub));
             return 2;
         }
         const thread = (0, thread_1.lerThread)(carregado.raiz, id);
@@ -1856,7 +1870,8 @@ function comandoRetry(args) {
             autorizadoPor: texto(args.opcoes.por) ?? texto(args.opcoes.quem),
         };
         if (sub === 'plan') {
-            const plano = (0, retry_1.planejarRetry)(carregado, id, opcoes);
+            // RM-061 (F2b, G2): a razao nasce em pt-BR, como o --json e o ledger a guardam; so a impressao segue o locale.
+            const plano = (0, locale_1.comLocale)('pt-BR', () => (0, retry_1.planejarRetry)(carregado, id, opcoes));
             if (args.opcoes.json === true) {
                 console.log(JSON.stringify(plano, null, 2));
                 return 0;
@@ -1868,11 +1883,11 @@ function comandoRetry(args) {
         const conducao = conducaoDoCli(args);
         if (conducao.esperarMs && args.opcoes['dry-run'] !== true)
             (0, conducao_1.esperarConducaoLivre)(carregado.raiz, id, conducao.esperarMs);
-        const r = (0, retry_1.executarRetry)(carregado, id, {
+        const r = (0, locale_1.comLocale)('pt-BR', () => (0, retry_1.executarRetry)(carregado, id, {
             ...opcoes,
             dryRun: args.opcoes['dry-run'] === true,
             reverify: args.opcoes.reverify === true,
-        });
+        }));
         if (args.opcoes.json === true) {
             console.log(JSON.stringify(r, null, 2));
         }
@@ -1892,8 +1907,8 @@ function comandoRetry(args) {
         const espera = (0, ratelimit_1.lerFilaDeRetomada)(carregado.raiz).filter((p) => p.estado === 'aguardando');
         if (espera.length > 0) {
             console.log('');
-            console.log(`Proxima janela: ${(0, horario_1.formatarDataHora)(espera[0].liberaEm)} (${(0, ratelimit_1.faltaPara)(espera[0])}).`);
-            console.log('Retome com: ork retry resume');
+            console.log(mc.proxima((0, horario_1.formatarDataHora)(espera[0].liberaEm), (0, ratelimit_1.faltaPara)(espera[0])));
+            console.log(mc.retome);
         }
         return 0;
     }
@@ -1923,17 +1938,17 @@ function comandoRetry(args) {
         const idPedido = args.posicionais[2];
         const motivo = texto(args.opcoes.motivo);
         if (!idPedido || !motivo) {
-            console.error('uso: ork retry cancel <id> --motivo "<motivo>"');
+            console.error(mc.usoCancel);
             return 2;
         }
         const p = (0, retry_1.cancelarPedido)(carregado, idPedido, motivo);
-        console.log(`Pedido ${p.id} cancelado na fila de rate limit.`);
-        console.log(`  thread   ${p.thread}`);
-        console.log(`  fase     ${p.fase}`);
-        console.log(`  motivo   ${motivo}`);
+        console.log(mc.cancelado(p.id));
+        console.log(mc.thread(p.thread));
+        console.log(mc.fase(p.fase));
+        console.log(mc.motivoLinha(motivo));
         return 0;
     }
-    console.error(`subcomando desconhecido: retry ${sub ?? ''}`);
+    console.error(mc.desconhecido(sub ?? ''));
     return 2;
 }
 /**
@@ -1947,15 +1962,16 @@ function comandoFix(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
     const sub = args.posicionais[1];
     const id = args.posicionais[2];
+    const mf = (0, locale_1.msg)().operacao.restante.fix;
     if (sub === 'open') {
         if (!id) {
-            console.error('uso: ork fix open <thread-id> [--so-claims] [--reverify]');
+            console.error(mf.usoOpen);
             return 2;
         }
-        const conducao = conducaoDoCli(args);
-        const rodada = (0, fix_1.abrirRodada)(carregado, id, { soClaims: args.opcoes['so-claims'] === true, conducao });
+        const conducao = { ...conducaoDoCli(args), filaPesada: filaPesadaDoCli(args, 'verify', `ork fix open ${id} --esperar 30`) };
+        const rodada = (0, locale_1.comLocale)('pt-BR', () => (0, fix_1.abrirRodada)(carregado, id, { soClaims: args.opcoes['so-claims'] === true, conducao }));
         const reverify = args.opcoes.reverify === true && rodada.correcoes.length > 0
-            ? (0, fix_1.reverificar)(carregado, id, { rodada: rodada.rodada, conducao })
+            ? (0, locale_1.comLocale)('pt-BR', () => (0, fix_1.reverificar)(carregado, id, { rodada: rodada.rodada, conducao }))
             : null;
         if (args.opcoes.json === true) {
             console.log(JSON.stringify({ rodada, reverify }, null, 2));
@@ -1973,14 +1989,14 @@ function comandoFix(args) {
     }
     if (sub === 'list') {
         if (!id) {
-            console.error('uso: ork fix list <thread-id> [--rodada N]');
+            console.error(mf.usoList);
             return 2;
         }
         (0, thread_1.lerThread)(carregado.raiz, id);
         const rodadaBruta = texto(args.opcoes.rodada);
         const rodada = rodadaBruta ? Number(rodadaBruta) : (0, fix_1.ultimaRodada)(carregado.raiz, id);
         if (rodada === 0) {
-            console.log(`A thread ${id} nao tem rodada de GO-FIX. Abra com: ork fix open ${id}`);
+            console.log(mf.semRodada(id));
             return 0;
         }
         const correcoes = (0, fix_1.correcoesDaRodada)(carregado.raiz, id, rodada);
@@ -1988,29 +2004,29 @@ function comandoFix(args) {
             console.log(JSON.stringify(correcoes, null, 2));
             return 0;
         }
-        console.log(`Correcoes da rodada ${rodada} da thread ${id}`);
+        console.log(mf.lista(rodada, id));
         console.log('');
-        console.log((0, util_1.tabela)(['ID', 'TIPO', 'MOTIVO', 'ALVO', 'ESTADO', 'JULGADO POR'], correcoes.map((c) => [
+        console.log((0, util_1.tabela)([...mf.colunasLista], correcoes.map((c) => [
             c.id,
             c.tipo,
             c.origem,
             c.alvo,
             c.estado,
-            c.verificar.join(' && ') || '(verify completo)',
+            c.verificar.join(' && ') || mf.verifyCompleto,
         ])));
         return 0;
     }
     if (sub === 'reverify') {
         if (!id) {
-            console.error('uso: ork fix reverify <thread-id> [--rodada N] [--parcial]');
+            console.error(mf.usoReverify);
             return 2;
         }
         const rodadaBruta = texto(args.opcoes.rodada);
-        const r = (0, fix_1.reverificar)(carregado, id, {
-            conducao: conducaoDoCli(args),
+        const r = (0, locale_1.comLocale)('pt-BR', () => (0, fix_1.reverificar)(carregado, id, {
+            conducao: { ...conducaoDoCli(args), filaPesada: filaPesadaDoCli(args, 'verify', `ork fix reverify ${id} --esperar 30`) },
             rodada: rodadaBruta ? Number(rodadaBruta) : undefined,
             parcial: args.opcoes.parcial === true,
-        });
+        }));
         if (args.opcoes.json === true) {
             console.log(JSON.stringify(r, null, 2));
         }
@@ -2019,49 +2035,118 @@ function comandoFix(args) {
         }
         return r.veredito === 'PASSOU' ? 0 : 1;
     }
-    console.error(`subcomando desconhecido: fix ${sub ?? ''}`);
+    console.error(mf.desconhecido(sub ?? ''));
     return 2;
 }
 function comandoHandoff(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
     const sub = args.posicionais[1];
     const id = args.posicionais[2];
+    const mh = (0, locale_1.msg)().operacao.restante.handoff;
     if (sub === 'export') {
         if (!id) {
-            console.error('uso: ork handoff export <thread-id> [--proxima-fase FASE]');
+            console.error(mh.usoExport);
             return 2;
         }
         const thread = (0, thread_1.lerThread)(carregado.raiz, id);
         const faseBruta = texto(args.opcoes['proxima-fase']) ?? texto(args.opcoes.fase);
-        const r = (0, handoff_1.exportarHandoff)(carregado, id, {
+        const r = (0, locale_1.comLocale)('pt-BR', () => (0, handoff_1.exportarHandoff)(carregado, id, {
             proximaFase: faseBruta ? (0, thread_1.exigirFase)(thread, faseBruta) : undefined,
             slugDestino: texto(args.opcoes.slug),
-        });
+        }));
         console.log((0, handoff_1.textoDoHandoff)(r.handoff, r.caminho));
         console.log('');
-        console.log(`Historico: ${r.caminhoHistorico}`);
+        console.log(mh.historico(r.caminhoHistorico));
         return 0;
     }
     if (sub === 'recall') {
         const ponteiro = args.posicionais[3];
         if (!id || !ponteiro) {
-            console.error('uso: ork handoff recall <thread-id> <path#ancora>');
+            console.error(mh.usoRecall);
             return 2;
         }
-        const r = (0, handoff_1.recall)(carregado, id, ponteiro);
-        console.log(`Ponteiro resolvido: ${r.location}`);
-        console.log(`  metodo       ${r.metodo}`);
-        console.log(`  sha256       ${r.sha256}`);
-        console.log(`  linhas       ${r.intervalo ? `${r.intervalo.inicio}-${r.intervalo.fim}` : '(nao aplicavel)'}`);
+        const r = (0, locale_1.comLocale)('pt-BR', () => (0, handoff_1.recall)(carregado, id, ponteiro));
+        console.log(mh.resolvido(r.location));
+        console.log(mh.metodo(r.metodo));
+        console.log(mh.sha(r.sha256));
+        console.log(mh.linhas(r.intervalo ? `${r.intervalo.inicio}-${r.intervalo.fim}` : mh.naoAplicavel));
         console.log('');
         console.log(r.conteudo);
         return 0;
     }
-    console.error(`subcomando desconhecido: handoff ${sub}`);
+    console.error(mh.desconhecido(sub));
     return 2;
 }
+/**
+ * RM-059 (F7, T7.1; DD4 do plano dos mods): `ork ship publicar <thread>`. So publica no modo que ja autoriza push
+ * (#Auto e #Maestro); a autorizacao humana na linha nao vale aqui (D1 da ork-rm059pista), e o push do modo que pausa
+ * e do dono, no terminal dele.
+ */
+function comandoShipPublicar(carregado, args) {
+    const m = (0, locale_1.msg)().ship;
+    const p = m.publicar;
+    if (args.opcoes['autorizar-push'] !== undefined) {
+        console.error(p.semAutorizarPush);
+        return 2;
+    }
+    const alvo = args.posicionais[2];
+    if (!alvo || args.posicionais.length > 3) {
+        console.error(p.uso);
+        return 2;
+    }
+    if (args.opcoes.remoto !== undefined)
+        (0, branch_de_estado_1.exigirRemoto)(args.opcoes.remoto, 'ship');
+    // Como o ship: o que o publicar grava (ledger, detalhe e correcao do --json) nasce em pt-BR.
+    const r = (0, locale_1.comLocale)('pt-BR', () => (0, ship_publicar_1.publicarEntrega)(carregado, alvo, {
+        remoto: texto(args.opcoes.remoto), dryRun: args.opcoes['dry-run'] === true,
+    }));
+    if (args.opcoes.json === true) {
+        console.log(JSON.stringify(r, null, 2));
+        return r.acao === 'recusada' ? 1 : 0;
+    }
+    for (const linha of (0, ship_publicar_1.linhasDaPublicacao)(r))
+        console.log(linha);
+    return r.acao === 'recusada' ? 1 : 0;
+}
+/** RM-059 (F7, T7.1): `ork ship pista [<thread>]`, as etapas da entrega e o proximo passo que o nucleo declara. */
+function comandoShipPista(carregado, args) {
+    const p = (0, locale_1.msg)().ship.publicar;
+    if (args.posicionais.length > 3) {
+        console.error(p.usoPista);
+        return 2;
+    }
+    if (args.opcoes.remoto !== undefined)
+        (0, branch_de_estado_1.exigirRemoto)(args.opcoes.remoto, 'ship');
+    const r = (0, locale_1.comLocale)('pt-BR', () => (0, ship_publicar_1.pistaDeEntrega)(carregado, { remoto: texto(args.opcoes.remoto), thread: args.posicionais[2] }));
+    if (args.opcoes.json === true) {
+        console.log(JSON.stringify(r, null, 2));
+        return 0;
+    }
+    console.log(p.cabecalhoPista((0, horario_1.formatarDataHora)(r.lidoEm), r.remoto, r.base));
+    if (!r.remotoLido)
+        console.log(p.remotoNaoRespondeu(r.remoto));
+    if (!r.prsLidos)
+        console.log(p.prsNaoResponderam((0, locale_1.remontar)(r.prsNaoLidos ?? '-')));
+    if (!r.pistas.length)
+        console.log(p.semPistas);
+    for (const pista of r.pistas) {
+        console.log('');
+        console.log(p.linhaDaThread(pista.thread, pista.tag, pista.branch));
+        console.log(`    ${pista.etapas.map((e) => `${p.nomeDaEtapa(e.id)} ${p.marcaDaEtapa(e.estado)}`).join(' | ')}`);
+        for (const e of pista.etapas.filter((x) => x.estado !== 'feita' && x.estado !== 'nao-se-aplica')) {
+            console.log(`      ${p.nomeDaEtapa(e.id)}: ${(0, locale_1.remontar)(e.texto)}`);
+        }
+        console.log(p.linhaDoProximo((0, locale_1.remontar)(pista.proximo.texto), pista.proximo.comando));
+    }
+    return 0;
+}
 function comandoShip(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
+    const m = (0, locale_1.msg)().ship;
+    if (args.posicionais[1] === 'publicar')
+        return comandoShipPublicar(carregado, args);
+    if (args.posicionais[1] === 'pista')
+        return comandoShipPista(carregado, args);
     if (args.posicionais[1] === 'registrar-pr') {
         // I-57 (RM-008): a entrega feita por PR vira ship_done, provada no remoto e no CI.
         const alvo = args.posicionais[2];
@@ -2069,7 +2154,7 @@ function comandoShip(args) {
         // RM-037 (defeito 5): PR mesclado em repositorio externo declarado em ci.external_repositories.
         const repo = texto(args.opcoes.repo), numeroDoPr = texto(args.opcoes.pr);
         if ((!alvo && args.opcoes.todas !== true) || (!!repo !== !!numeroDoPr) || (repo && !alvo)) {
-            console.error('uso: ork ship registrar-pr <thread-id> [--repo <dono/nome> --pr <n>] | --todas [--remoto R] [--json] [--dry-run]');
+            console.error(m.usoRegistrarPr);
             return 2;
         }
         // RM-047: o `--remoto` da linha de comando so chega ao git como nome de remoto (ship.remoto-invalido).
@@ -2077,27 +2162,29 @@ function comandoShip(args) {
             (0, branch_de_estado_1.exigirRemoto)(args.opcoes.remoto, 'ship');
         // RM-037 (fatia 3, defeito 6): o `--dry-run` era ignorado, e o ensaio gravava o ship_done de verdade.
         const dryRun = args.opcoes['dry-run'] === true;
-        const r = alvo && repo ? [(0, entrega_pr_1.registrarEntregaExternaPorPr)(carregado, alvo, { repositorio: repo, pr: Number(numeroDoPr), dryRun })]
-            : alvo ? [(0, entrega_pr_1.registrarEntregaPorPr)(carregado, alvo, { remoto, dryRun })] : (0, entrega_pr_1.registrarEntregasPorPr)(carregado, { remoto, dryRun });
+        // RM-061 (F2b, G2): o ship_done e o motivo nascem em pt-BR; so a impressao segue o locale.
+        const r = (0, locale_1.comLocale)('pt-BR', () => alvo && repo
+            ? [(0, entrega_pr_1.registrarEntregaExternaPorPr)(carregado, alvo, { repositorio: repo, pr: Number(numeroDoPr), dryRun, remoto })]
+            : alvo ? [(0, entrega_pr_1.registrarEntregaPorPr)(carregado, alvo, { remoto, dryRun })] : (0, entrega_pr_1.registrarEntregasPorPr)(carregado, { remoto, dryRun }));
         if (args.opcoes.json === true) {
             console.log(JSON.stringify(r, null, 2));
             return r.some((x) => x.acao === 'recusada') ? 1 : 0;
         }
         if (dryRun)
-            console.log('Ensaio (--dry-run): nada foi gravado.');
+            console.log(m.ensaio);
         if (r.length === 0)
-            console.log('Nenhuma thread aberta com merge ship(<thread>) na base.');
+            console.log(m.nenhumaComMerge);
         for (const x of r)
-            console.log(`  ${x.thread.padEnd(20)} ${x.acao.padEnd(13)} ${x.motivo}`);
+            console.log(m.linhaDoRegistro(x.thread, m.acoes[x.acao] ?? x.acao, (0, locale_1.remontar)(x.motivo)));
         // RM-044 (A3): a pagina que o push da base vai reprovar em docs.paridade.merge, com o comando que corrige.
         // So aviso: nada e gravado e o codigo de saida nao muda.
         const pendentes = r.flatMap((x) => x.docsPendentes.map((d) => ({ thread: x.thread, ...d })));
         if (pendentes.length) {
             console.log('');
-            console.log(`Aviso: ${pendentes.length} pagina(s) do roadmap com estado.codigo fora de "Mesclado" depois do merge; o push da base reprova em docs.paridade.merge:`);
+            console.log(m.avisoDeDocs(pendentes.length));
             for (const d of pendentes) {
-                console.log(`  ${d.id} (${d.arquivo}): merge ${d.merge.slice(0, 7)} de ship(${d.thread}), estado.codigo "${d.codigo || 'vazio'}"`);
-                console.log(`    ${d.comando}   (num PR de docs sobre a base atualizada)`);
+                console.log(m.docPendente(d.id, d.arquivo, d.merge.slice(0, 7), d.thread, d.codigo));
+                console.log(m.docPendenteComando(d.comando));
             }
         }
         const registradas = r.filter((x) => x.acao === 'registrou').length;
@@ -2106,20 +2193,20 @@ function comandoShip(args) {
             console.log('');
             // RM-008 (03/10): o texto ensina a forma COM a thread. A forma sem thread fechava tambem as
             // entregues de outras frentes paralelas, e era ela que os condutores copiavam daqui.
-            console.log(`${registradas} entrega(s) registrada(s). Fechar pelo MASTER so a(s) desta entrega (a nota humana sobrescreve):`);
+            console.log(m.registradas(registradas));
             for (const x of r.filter((y) => y.acao === 'registrou'))
                 console.log(`  ork master ${x.thread} --aceitar-omissao`);
         }
         if (registrariam) {
             console.log('');
-            console.log(`${registrariam} entrega(s) seria(m) registrada(s). Para gravar, rode o mesmo comando sem --dry-run.`);
+            console.log(m.registrariam(registrariam));
         }
         return r.some((x) => x.acao === 'recusada') ? 1 : 0;
     }
     const id = args.posicionais[1];
     const para = texto(args.opcoes.para) ?? texto(args.opcoes.to);
     if (!id || !para) {
-        console.error('uso: ork ship <thread-id> --para <branch> [--de <branch>] [--dry-run]');
+        console.error(m.uso);
         return 2;
     }
     // RM-047: como no registrar-pr, o `--remoto` so chega ao git como nome de remoto (ship.remoto-invalido),
@@ -2127,25 +2214,47 @@ function comandoShip(args) {
     if (args.opcoes.remoto !== undefined)
         (0, branch_de_estado_1.exigirRemoto)(args.opcoes.remoto, 'ship');
     const autorizar = args.opcoes['autorizar-push'];
-    const r = (0, ship_1.ship)(carregado, id, {
+    // Security scan: `--allow-unscanned` exige quem autoriza; sem valor nao vira autorizacao em silencio.
+    const semScan = args.opcoes['allow-unscanned'];
+    if (semScan !== undefined && (typeof semScan !== 'string' || !semScan.trim())) {
+        console.error(m.allowUnscannedSemValor);
+        return 2;
+    }
+    // RM-061 (F2b, G2): o que o ship grava (ledger, verificacao, mensagem do merge) nasce em pt-BR.
+    const r = (0, locale_1.comLocale)('pt-BR', () => (0, ship_1.ship)(carregado, id, {
         para,
         de: texto(args.opcoes.de),
         remoto: texto(args.opcoes.remoto),
         mensagem: texto(args.opcoes.mensagem),
         dryRun: args.opcoes['dry-run'] === true,
         autorizarPush: typeof autorizar === 'string' ? autorizar : undefined,
+        allowUnscanned: typeof semScan === 'string' ? semScan.trim() : undefined,
         semPush: args.opcoes['sem-push'] === true,
-    });
+        // RM-058 N2 (A1 da rodada 2 do CHECK): o `--esperar` chega à fila pesada da verificação do ship, com aviso.
+        ...((f) => ({ esperarFilaPesadaMs: f.esperarMs, avisoDaFilaPesada: { aoEsperar: f.aoEsperar, comandoDeEsperar: f.comandoDeEsperar } }))(filaPesadaDoCli(args, 'verify', `ork ship ${id} --para ${para} --esperar 30`)),
+    }));
     console.log((0, ship_1.textoDoShip)(r));
     return r.ok ? 0 : 1;
 }
+/**
+ * RM-043 (sobra achada na RM-044): opcoes que o `portfolio show` herdou do `objective`,
+ * aposentado na I-43. A ajuda as listava e o `parseArgs` as aceitava, mas o `show` nunca as
+ * leu: eram ignoradas em silencio. A recusa e tipada e diz para onde ir, como a do
+ * `objective.aposentado`.
+ */
+const SOBRAS_DO_OBJECTIVE = ['constraints', 'outcomes', 'threads', 'execution-runtime', 'validation-runtimes'];
+function recusarSobraDoObjective(opcao) {
+    console.error((0, locale_1.msg)().operacao.produto.portfolio.opcaoAposentada(opcao));
+    return 2;
+}
 function comandoPortfolio(args) {
     const root = (0, manifest_1.exigirManifesto)().raiz;
     const sub = args.posicionais[1] ?? 'list';
+    const m = (0, locale_1.msg)().operacao.produto.portfolio;
     if (sub === 'inspect') {
         const id = args.posicionais[2];
         if (!id) {
-            console.error('uso: ork portfolio inspect <id> --json');
+            console.error(m.usoInspect);
             return 2;
         }
         console.log(JSON.stringify((0, portfolio_context_1.inspectPortfolio)(root, id), null, 2));
@@ -2157,33 +2266,36 @@ function comandoPortfolio(args) {
         const rawKind = args.posicionais[2];
         const kind = rawKind ? aliases[rawKind] : undefined;
         if (rawKind && !kind) {
-            console.error('tipo deve ser product, project ou initiative');
+            console.error(m.tipo);
             return 2;
         }
         const items = (0, portfolio_1.listEntities)(root, kind, texto(args.opcoes.parent));
         console.log(args.opcoes.json === true ? JSON.stringify({ schema: 'ork.portfolio-list/v1', updatedAt: (0, portfolio_1.readPortfolio)(root).updatedAt, items }, null, 2)
-            : items.length ? items.map((item) => `${item.id}\t${item.kind}\t${item.status}\t${item.title}`).join('\n') : 'Portfólio vazio.');
+            : items.length ? items.map((item) => `${item.id}\t${item.kind}\t${item.status}\t${item.title}`).join('\n') : m.vazio);
         return 0;
     }
     if (sub === 'show') {
+        const sobra = SOBRAS_DO_OBJECTIVE.find((opcao) => args.opcoes[opcao] !== undefined);
+        if (sobra)
+            return recusarSobraDoObjective(sobra);
         const id = args.posicionais[2];
         if (!id) {
-            console.error('uso: ork portfolio show <id>');
+            console.error(m.usoShow);
             return 2;
         }
         const item = (0, portfolio_1.findEntity)(root, id);
         if (!item) {
-            console.error(`entidade ${id} não encontrada`);
+            console.error(m.naoEncontrada(id));
             return 1;
         }
-        console.log(args.opcoes.json === true ? JSON.stringify(item, null, 2) : `${item.id}\n${item.title}\nEstado: ${item.status}`);
+        console.log(args.opcoes.json === true ? JSON.stringify(item, null, 2) : m.estado(item.id, item.title, item.status));
         return 0;
     }
     if (sub === 'create') {
         const kind = aliases[args.posicionais[2] ?? ''];
         const id = args.posicionais[3], title = texto(args.opcoes.title), parent = texto(args.opcoes.parent);
         if (!kind || !id || !title) {
-            console.error('uso: ork portfolio create <product|project|initiative> <id> --title T [--parent ID]');
+            console.error(m.usoCreate);
             return 2;
         }
         const common = { id, title, description: texto(args.opcoes.description), ownerId: texto(args.opcoes.owner), status: texto(args.opcoes.status), acceptanceCriteria: split(texto(args.opcoes.acceptance), ';') };
@@ -2193,7 +2305,7 @@ function comandoPortfolio(args) {
         console.log(JSON.stringify({ schema: 'ork.portfolio-created/v1', item }, null, 2));
         return 0;
     }
-    console.error(`subcomando desconhecido: portfolio ${sub}`);
+    console.error(m.desconhecido(sub));
     return 2;
 }
 function comandoCreation(args) {
@@ -2202,8 +2314,9 @@ function comandoCreation(args) {
     // Fachadas HTTP devem usar a API com principal e authorize autenticados no servidor.
     const actor = { principal: `local:uid:${(0, node_os_1.userInfo)().uid}`, authorize: () => { } };
     const sub = args.posicionais[1], id = args.posicionais[2];
+    const m = (0, locale_1.msg)().operacao.produto.creation;
     if (args.opcoes.principal !== undefined || args.opcoes.por !== undefined)
-        throw new Error('creation.identity: payload não escolhe principal');
+        throw new Error(m.identidade);
     let result;
     if (sub === 'session') {
         const portfolio = (0, portfolio_1.readPortfolio)(loaded.raiz);
@@ -2217,18 +2330,18 @@ function comandoCreation(args) {
     else if (sub === 'start') {
         const file = texto(args.opcoes['input-file']);
         if (!file) {
-            console.error('uso: ork creation start --input-file F --json');
+            console.error(m.usoStart);
             return 2;
         }
         const content = fs.readFileSync(file, 'utf8');
         if (Buffer.byteLength(content) > 100_000)
-            throw new Error('creation.input: arquivo excede limite');
+            throw new Error(m.arquivoGrande);
         result = (0, creation_operation_1.startCreation)(loaded, actor, JSON.parse(content));
     }
     else if (sub === 'list')
         result = (0, creation_operation_store_1.listCreationOperations)(loaded.raiz, actor.principal);
     else if (!id) {
-        console.error('creation exige id');
+        console.error(m.exigeId);
         return 2;
     }
     else if (sub === 'show' || sub === 'events') {
@@ -2238,13 +2351,13 @@ function comandoCreation(args) {
     else if (sub === 'resume' || sub === 'compensate') {
         const version = Number(texto(args.opcoes['expected-version']));
         if (!Number.isSafeInteger(version) || version < 1) {
-            console.error('creation exige --expected-version inteiro positivo');
+            console.error(m.versao);
             return 2;
         }
         result = sub === 'resume' ? (0, creation_operation_1.resumeCreation)(loaded, actor, id, version) : (0, creation_operation_1.compensateCreation)(loaded, actor, id, version);
     }
     else {
-        console.error('subcomando creation desconhecido');
+        console.error(m.desconhecido);
         return 2;
     }
     console.log(JSON.stringify(result, null, 2));
@@ -2270,28 +2383,33 @@ function comandoCreation(args) {
  */
 function comandoObjective(args) {
     const sub = args.posicionais[1] ?? 'list';
-    console.error(`objective.aposentado: o Objective Envelope saiu do produto na I-43 (subcomando "${sub}").\n` +
-        '  Ele descrevia um gate que nao bloqueava nada: das 137 threads do projeto, zero\n' +
-        '  tinham creationOrigin, que era a unica via pela qual o despacho o consultava.\n' +
-        '  As duas vigas que ele guardava viraram propriedade de thread comum:\n' +
-        '    ork thread new "<nome>" --modo <MODO> --exige-runtime-diferente\n' +
-        '        o CHECK precisa de runtime que o GO nao usou\n' +
-        '    ork thread new "<nome>" --modo <MODO> --done "<criterio> :: <comando>"\n' +
-        '        criterio de pronto EXECUTAVEL, que vira claim e roda no ork verify\n' +
-        '  Os envelopes ja gravados continuam em .orkastery/objectives, intocados.');
+    console.error((0, locale_1.msg)().operacao.produto.objective(sub));
     return 2;
 }
 function comandoCi(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
     const sub = args.posicionais[1] ?? 'status';
+    const m = (0, locale_1.msg)().operacao.produto.ci;
     if (sub === 'prepare') {
         const thread = args.posicionais[2];
         if (!thread) {
-            console.error('uso: ork ci prepare <thread-id>');
+            console.error(m.usoPrepare);
             return 2;
         }
-        const arquivo = (0, ci_1.prepararBundleCi)(carregado, thread, { aoAvisar: (linha) => console.log(`AVISO: ${linha}`) });
-        console.log(`Bundle de CI: ${arquivo}`);
+        // RM-061 (F3d, GO-FIX 1): o lint vai ao ledger e o bundle ao disco no escopo pt-BR, como antes do `ci` entrar na
+        // lista (D2); o aviso sai remontado no locale do comando, e a recusa, pela entrada do CLI. As linhas da barreira de
+        // dado privado (RM-062) saem junto com os avisos, na ordem em que nascem.
+        const linhas = [];
+        let arquivo;
+        try {
+            arquivo = (0, locale_1.comLocale)('pt-BR', () => (0, ci_1.prepararBundleCi)(carregado, thread, { aoAvisar: (linha) => linhas.push({ aviso: true, linha }),
+                aoInformar: (linha) => linhas.push({ aviso: false, linha }) }));
+        }
+        finally {
+            for (const { aviso, linha } of linhas)
+                console.log(aviso ? m.aviso((0, locale_1.remontar)(linha)) : (0, locale_1.remontar)(linha));
+        }
+        console.log(m.bundle(arquivo));
         return 0;
     }
     if (sub === 'run') {
@@ -2310,34 +2428,86 @@ function comandoCi(args) {
         }
         const thread = args.posicionais[2];
         if (!thread) {
-            console.error('uso: ork ci run <thread-id> [--json] | ork ci run --bundle <arquivo> | ork ci run --branch <branch>');
+            console.error(m.usoRun);
             return 2;
         }
         const result = (0, ci_1.executarCi)(carregado, thread);
-        console.log(args.opcoes.json === true ? JSON.stringify(result, null, 2) : `${result.status.ok ? 'CI APROVADO' : 'CI REPROVADO'}: ${result.status.detail}`);
+        console.log(args.opcoes.json === true ? JSON.stringify(result, null, 2) : m.resultado(result.status.ok, result.status.detail));
         return result.status.ok ? 0 : 1;
     }
     if (sub === 'status') {
         const sha = texto(args.opcoes.sha) ?? args.posicionais[2] ?? (0, util_1.exec)('git', ['rev-parse', 'HEAD'], carregado.raiz).stdout.trim();
         if (!/^[0-9a-f]{40}$/.test(sha)) {
             // Ensaio de 03/10 (R4): `--sha HEAD` ou um sha curto respondiam so a linha de uso, sem dizer por que.
-            console.error('erro: ci status: --sha exige o sha completo, de 40 caracteres hexadecimais minusculos ' +
-                '(git rev-parse HEAD); o check e consultado no commit exato, nunca por ref nem prefixo');
-            console.error('uso: ork ci status --sha <sha de 40 caracteres> [--remoto origin]');
+            console.error(m.sha);
+            console.error(m.usoStatus);
             return 2;
         }
         // RM-047: recusa o `--remoto` que nao e nome de remoto mesmo com o gate de CI desligado.
         const remoto = (0, branch_de_estado_1.exigirRemoto)(args.opcoes.remoto === undefined ? 'origin' : args.opcoes.remoto, 'ci');
         const result = (0, ci_1.consultarCi)(carregado, sha, remoto);
-        console.log(args.opcoes.json === true ? JSON.stringify(result, null, 2) : `${result.ok ? 'CI VERDE' : 'CI NÃO LIBEROU'}: ${result.detail}`);
+        console.log(args.opcoes.json === true ? JSON.stringify(result, null, 2) : m.status(result.ok, result.detail));
         return result.ok ? 0 : 1;
     }
-    console.error(`subcomando desconhecido: ci ${sub}`);
+    console.error(m.desconhecido(sub));
     return 2;
 }
+/**
+ * RM-062 (F1): `ork privado varrer [--base REF] [--json]`, a varredura de dado privado do repositorio do diretorio
+ * atual. Sem `--base`, os nomes e as linhas dos arquivos versionados (o passo do CI); com ela, o diff contra a
+ * merge-base com `REF` e os nao rastreados. Sai 1 com achado sob a policy `dado_privado` em `block` ou sem a policy
+ * (quem roda o comando pediu a varredura); em `warn` e `off`, 0 com o aviso. Sai 2 quando a varredura nao roda.
+ */
+function comandoPrivado(args) {
+    const uso = 'uso: ork privado varrer [--base REF] [--json]';
+    const opcoes = Object.keys(args.opcoes);
+    if (args.posicionais[1] !== 'varrer' || args.posicionais.length > 2 || opcoes.some((k) => k !== 'base' && k !== 'json') ||
+        ('json' in args.opcoes && args.opcoes.json !== true) || ('base' in args.opcoes && typeof args.opcoes.base !== 'string')) {
+        console.error(uso);
+        return 2;
+    }
+    const topo = (0, util_1.exec)('git', ['rev-parse', '--show-toplevel'], process.cwd());
+    if (!topo.ok) {
+        console.error('erro: privado varrer: o diretorio atual nao esta num repositorio git');
+        return 2;
+    }
+    const raiz = topo.stdout.trim();
+    const carregado = (0, manifest_1.carregarManifesto)(raiz);
+    const severidade = carregado ? (0, policies_1.severidadeDeclarada)(carregado.manifesto, 'dado_privado') : null;
+    let estado = null;
+    try {
+        estado = (0, estado_thread_1.raizDoEstado)(raiz);
+    }
+    catch {
+        estado = null;
+    }
+    const contexto = (0, dado_privado_1.contextoDaVarredura)(raiz, estado);
+    const ref = texto(args.opcoes.base);
+    const base = contexto.ok && ref ? (0, dado_privado_1.mergeBase)(raiz, ref) : null;
+    const v = !contexto.ok ? null : ref ? (base ? (0, dado_privado_1.varrerDiff)(contexto.valor, base) : null) : (0, dado_privado_1.varrerArvore)(contexto.valor);
+    const erro = !contexto.ok ? contexto.erro : !v ? `--base ${ref} nao tem merge-base com HEAD` : v.erro;
+    const achados = v?.achados.length ?? 0;
+    const reprova = !erro && achados > 0 && (severidade === null || severidade === 'block');
+    if (args.opcoes.json === true) {
+        console.log(JSON.stringify({ ...(v ?? {}), erro, severidade, ok: !erro && !reprova }, null, 2));
+    }
+    else {
+        if (v)
+            for (const linha of (0, dado_privado_1.relatorioDoDadoPrivado)(v))
+                console.log(linha);
+        const policy = severidade === null ? 'policy dado_privado nao declarada: o comando explicito reprova'
+            : `policy dado_privado em ${severidade}`;
+        console.log(erro ? `Veredito: NAO RODOU (${erro})`
+            : !achados ? 'Veredito: nenhum dado privado nas linhas e nos nomes varridos.'
+                : reprova ? `Veredito: REPROVADO (${achados} achado(s) de dado privado; ${policy})`
+                    : `Veredito: AVISO (${achados} achado(s) de dado privado; ${policy}, que nao reprova)`);
+    }
+    return erro ? 2 : reprova ? 1 : 0;
+}
 function comandoLease(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
     const sub = args.posicionais[1];
+    const ml = (0, locale_1.msg)().operacao.restante.lease;
     if (sub === undefined || sub === 'list') {
         console.log((0, leases_1.tabelaDeLeases)(carregado.raiz));
         return 0;
@@ -2345,38 +2515,38 @@ function comandoLease(args) {
     if (sub === 'acquire' || sub === 'take') {
         const nome = args.posicionais[2];
         const thread = texto(args.opcoes.thread);
-        const motivo = texto(args.opcoes.motivo) ?? 'sem motivo declarado';
+        const motivo = texto(args.opcoes.motivo) ?? (0, locale_1.msg)('pt-BR').operacao.restante.lease.semMotivo;
         if (!nome || !thread) {
-            console.error('uso: ork lease acquire <nome> --thread <thread-id> [--motivo "<motivo>"]');
+            console.error(ml.usoAcquire);
             return 2;
         }
         (0, thread_1.lerThread)(carregado.raiz, thread);
-        const r = (0, leases_1.adquirirRegiao)(carregado.raiz, nome, { thread, motivo });
+        const r = (0, locale_1.comLocale)('pt-BR', () => (0, leases_1.adquirirRegiao)(carregado.raiz, nome, { thread, motivo }));
         if (r.ok) {
-            console.log(`Lease ${r.nome} [${r.tipo}] adquirido pela thread ${thread}.`);
-            console.log(`  expira em ${(0, horario_1.formatarDataHoraRotulada)(r.lease?.expiraEm)}`);
+            console.log(ml.adquirido(r.nome, r.tipo, thread));
+            console.log(ml.expira((0, horario_1.formatarDataHoraRotulada)(r.lease?.expiraEm)));
             if (r.tomadoDeVencido)
-                console.log('  (o lease anterior estava VENCIDO e foi tomado)');
+                console.log(ml.tomado);
             return 0;
         }
-        console.error(`Lease ${r.nome} NAO adquirido.`);
-        console.error(`  motivo tipado: ${r.motivo}`);
-        console.error(`  detalhe: ${(0, horario_1.localizarTextoRotulado)(r.detalhe)}`);
-        console.error(`  posicao na fila: ${r.posicaoNaFila}`);
-        console.error(`  correcao: ${r.correcao}`);
+        console.error(ml.naoAdquirido(r.nome));
+        console.error(ml.motivoTipado(r.motivo));
+        console.error(ml.detalhe((0, horario_1.localizarTextoRotulado)(r.detalhe)));
+        console.error(ml.posicao(r.posicaoNaFila));
+        console.error(ml.correcao(r.correcao));
         return 1;
     }
     if (sub === 'release') {
         const nome = args.posicionais[2];
         if (!nome) {
-            console.error('uso: ork lease release <nome> [--thread <thread-id>] [--forcar]');
+            console.error(ml.usoRelease);
             return 2;
         }
-        const r = (0, leases_1.liberar)(carregado.raiz, nome, texto(args.opcoes.thread) ?? '', args.opcoes.forcar === true);
+        const r = (0, locale_1.comLocale)('pt-BR', () => (0, leases_1.liberar)(carregado.raiz, nome, texto(args.opcoes.thread) ?? '', args.opcoes.forcar === true));
         console.log(r.detalhe);
         return r.ok ? 0 : 1;
     }
-    console.error(`subcomando desconhecido: lease ${sub}`);
+    console.error(ml.desconhecido(sub));
     return 2;
 }
 /**
@@ -2400,6 +2570,7 @@ function comandoBoard(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
     const sub = args.posicionais[1];
     const todos = args.opcoes.all === true || args.opcoes.todos === true;
+    const mb = (0, locale_1.msg)().operacao.restante.board;
     if (sub === 'plan' || sub === 'plano') {
         const plano = (0, board_1.planejar)(carregado);
         const consulta = consultaDoBoard(carregado, { plano: true, todos: false });
@@ -2410,7 +2581,7 @@ function comandoBoard(args) {
         return 0;
     }
     if (sub === 'reap') {
-        const devolvidas = (0, board_1.devolverVagas)(carregado, { por: texto(args.opcoes.por) });
+        const devolvidas = (0, locale_1.comLocale)('pt-BR', () => (0, board_1.devolverVagas)(carregado, { por: texto(args.opcoes.por) }));
         if (args.opcoes.json === true)
             console.log(JSON.stringify(devolvidas, null, 2));
         else
@@ -2418,8 +2589,8 @@ function comandoBoard(args) {
         return 0;
     }
     if (sub !== undefined && sub !== 'list') {
-        console.error(`subcomando desconhecido: board ${sub}`);
-        console.error('uso: ork board [list|plan|reap] [--all] [--por <quem>] [--json]');
+        console.error(mb.desconhecido(sub));
+        console.error(mb.uso);
         return 2;
     }
     const consulta = consultaDoBoard(carregado, { plano: false, todos });
@@ -2435,7 +2606,7 @@ function comandoBoard(args) {
         console.log('');
         // RM-052: sem o remoto, nada foi lido; dizer "nenhuma publicou" seria a frase do incidente de 29/09.
         if (consulta.projeto.remoto === null) {
-            console.log(`Outras maquinas: o projeto ${carregado.manifesto.project.name} nao tem o remoto ${carregado.manifesto.fabrica.remoto}; nada foi lido de ork/fabrica-estado.`);
+            console.log(mb.semRemoto(carregado.manifesto.project.name, carregado.manifesto.fabrica.remoto));
         }
         else {
             const painel = (0, fabrica_estado_1.lerFabrica)(carregado.raiz, { remoto: carregado.manifesto.fabrica.remoto,
@@ -2455,6 +2626,10 @@ const CONTRATO_DO_BOARD = 'ork.board/v1';
 function comandoFabrica(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
     const sub = args.posicionais[1];
+    const mf = (0, locale_1.msg)().operacao.restante.fabrica;
+    // RM-063 (F1): a batida e do crontab desta maquina; nao le nem escreve o remoto.
+    if (sub === 'batida')
+        return comandoDaBatida(carregado, args);
     // RM-047: o remoto vem do manifesto de quem fez o repositorio; fora do formato, recusa antes do git.
     // O `publicar` recusa dentro do try (publicarMaquina), para o silencioso deixar a recusa no log.
     const remoto = texto(args.opcoes.remoto) ?? carregado.manifesto.fabrica.remoto;
@@ -2472,12 +2647,13 @@ function comandoFabrica(args) {
                 console.log(JSON.stringify(r, null, 2));
             else
                 console.log(r.acao === 'publicou'
-                    ? `Fabrica: ${r.maquina} publicou ${r.threads} thread(s) em ork/fabrica-estado (${r.commit?.slice(0, 7)}, ${r.tentativas} tentativa(s)).`
-                    : r.acao === 'ocupado'
-                        ? `Fabrica: outra publicacao desta maquina esta em andamento; tente de novo em instantes.`
-                        : `Fabrica: retrato de ${r.maquina} igual ao ultimo publicado; nada a enviar (use --forcar para publicar mesmo assim).`);
+                    ? mf.publicou(r.maquina, r.threads, r.commit?.slice(0, 7), r.tentativas)
+                    : r.acao === 'ocupado' ? mf.ocupada : mf.igual(r.maquina));
             if (!(0, maquina_1.fabricaCompartilhada)(carregado.manifesto) && !silencioso) {
-                console.log('  esta maquina nao entrou na fabrica compartilhada: so publica quando voce pede (ork fabrica entrar liga).');
+                console.log(mf.soQuandoPede);
+                // RM-047 (P5): o manifesto que pede a fabrica nao liga a publicacao desta maquina.
+                if (carregado.manifesto.fabrica.compartilhada)
+                    console.log(mf.manifestoPede);
             }
             return 0;
         }
@@ -2498,26 +2674,25 @@ function comandoFabrica(args) {
         const avisoDoRegistro = (0, projeto_alvo_1.registrarProjetoEmSilencio)(carregado.raiz, 'fabrica entrar');
         if (avisoDoRegistro)
             console.error(avisoDoRegistro);
-        console.log(`Fabrica: esta maquina entrou como ${config.nome}; publica ao criar thread, despachar fase, entregar e fechar,`);
-        console.log(`  e a cada batida do pulse. Primeiro retrato: ${r.threads} thread(s) em ork/fabrica-estado (${r.commit?.slice(0, 7)}).`);
+        console.log(mf.entrou(config.nome));
+        console.log(mf.primeiro(r.threads, r.commit?.slice(0, 7)));
         if (process.env.ORK_MAQUINA && process.env.ORK_MAQUINA.trim() !== config.nome) {
-            console.log(`  AVISO: ORK_MAQUINA=${process.env.ORK_MAQUINA} neste shell vence o arquivo; alinhe os dois.`);
+            console.log(mf.maquinaAmbiente(process.env.ORK_MAQUINA));
         }
         return 0;
     }
     if (sub === 'sair') {
         const config = (0, maquina_1.gravarConfigDaMaquina)({ fabricaCompartilhada: false });
         const r = (0, fabrica_estado_1.removerMaquina)(carregado, { remoto });
-        console.log(`Fabrica: ${(0, maquina_1.nomeDaMaquina)()} saiu; nada mais e publicado daqui.` +
-            (r ? ` Retrato removido de ork/fabrica-estado (${r.slice(0, 7)}).` : ' Nao havia retrato desta maquina na branch.'));
+        console.log(mf.saiu((0, maquina_1.nomeDaMaquina)(), r ? r.slice(0, 7) : null));
         if ((0, maquina_1.fabricaCompartilhada)(carregado.manifesto))
-            console.log('  AVISO: o manifesto do projeto (ou ORK_FABRICA_COMPARTILHADA) ainda liga a fabrica aqui.');
+            console.log(mf.ambienteLiga);
         void config;
         return 0;
     }
     if (sub !== undefined && sub !== 'list') {
-        console.error(`subcomando desconhecido: fabrica ${sub}`);
-        console.error('uso: ork fabrica [--json] [--sem-remoto] | fabrica publicar [--forcar] [--json] | fabrica entrar [--maquina NOME] | fabrica sair');
+        console.error(mf.desconhecido(sub));
+        console.error(mf.uso);
         return 2;
     }
     // RM-052: a fabrica le a branch de UM projeto, no remoto dele; o cabecalho diz qual e o que ficou de fora.
@@ -2536,10 +2711,36 @@ function comandoFabrica(args) {
     }
     console.log([...(0, projeto_alvo_1.linhasDaConsulta)(consulta), ''].join('\n'));
     console.log(url === null
-        ? `Fabrica: o projeto ${carregado.manifesto.project.name} nao tem o remoto ${remoto}; nada foi lido de ork/fabrica-estado.`
+        ? mf.semRemoto(carregado.manifesto.project.name, remoto)
         : (0, fabrica_estado_1.textoDaFabrica)(painel, (0, maquina_1.nomeDaMaquina)()));
+    // RM-047 (P5): o manifesto pede a fabrica, mas quem liga a publicacao e a maquina.
+    const pedida = (0, maquina_1.avisoDaFabricaPedida)(carregado.manifesto);
+    if (pedida)
+        console.log(`\n${pedida}`);
     return 0;
 }
+/**
+ * RM-063 (F1): `ork fabrica batida` instala, mostra e remove a batida da varredura do pulse no crontab desta
+ * maquina. `status` sai 0 com a batida instalada e 1 sem ela (ou sem crontab legivel); `instalar` e
+ * `remover` gravam o evento no ledger da maquina quando o crontab muda.
+ */
+function comandoDaBatida(carregado, args) {
+    const acao = args.posicionais[2] ?? 'status';
+    const json = args.opcoes.json === true;
+    if (acao === 'status') {
+        const estado = (0, fabrica_batida_1.estadoDaBatida)(carregado.raiz, { projeto: carregado.manifesto.project.name });
+        console.log(json ? JSON.stringify(estado, null, 2) : (0, fabrica_batida_1.textoDoEstadoDaBatida)(estado));
+        return estado.leitura.ok && estado.instalada ? 0 : 1;
+    }
+    if ((acao === 'instalar' || acao === 'remover') && args.posicionais.length === 3) {
+        const por = texto(args.opcoes.por);
+        const r = acao === 'instalar' ? (0, fabrica_batida_1.instalarBatida)(carregado.raiz, { por }) : (0, fabrica_batida_1.removerBatida)(carregado.raiz, { por });
+        console.log(json ? JSON.stringify(r, null, 2) : (0, fabrica_batida_1.textoDoResultadoDaBatida)(r));
+        return 0;
+    }
+    console.error((0, locale_1.msg)().operacao.restante.fabrica.batida.uso);
+    return 2;
+}
 /**
  * RM-053: `ork network` e a Orkastery Network, as maquinas de uma pessoa em rede. Roda de qualquer
  * diretorio, com ou sem projeto: a rede e da pessoa, nao de um repositorio. O projeto do diretorio
@@ -2547,84 +2748,77 @@ function comandoFabrica(args) {
  */
 function comandoNetwork(args) {
     const sub = args.posicionais[1];
-    // RM-054: `network roadmap` tem o proprio --projeto e o proprio uso.
+    // RM-054: `network roadmap` tem o proprio --projeto e o proprio uso (e segue em pt-BR, G6 da RM-061 F3b).
     if (sub === 'roadmap')
         return comandoNetworkRoadmap(args);
     const diretorio = process.cwd();
-    const uso = 'uso: ork network [status] [--json] [--sem-remoto] | network entrar [--maquina NOME] [--forja github|gitlab] ' +
-        '[--repositorio [DONO/]NOME] [--forcar] | network publicar [--forcar] [--json] | network sair | ' +
-        'network roadmap [--projeto P] [--json] [--sem-remoto]';
+    // RM-061 (F3b, D3): o texto pelo catalogo; o que se grava (adesao, retrato, casa) roda no escopo pt-BR, e o nome da
+    // maquina, a casa, a forja e o commit saem como vieram.
+    const mn = (0, locale_1.msg)().network;
     const forja = texto(args.opcoes.forja), repositorio = texto(args.opcoes.repositorio);
     if ((args.opcoes.forja !== undefined && !(0, rede_forja_1.ehNomeDeForja)(forja)) || args.opcoes.repositorio === true ||
         (repositorio !== undefined && !/^(?:[A-Za-z0-9][A-Za-z0-9._-]{0,99}\/)?[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/.test(repositorio))) {
-        console.error(uso);
+        console.error(mn.uso);
         return 2;
     }
     if (sub === 'entrar') {
-        const r = (0, rede_1.entrarNaRede)({ maquina: texto(args.opcoes.maquina), forja: (0, rede_forja_1.ehNomeDeForja)(forja) ? forja : undefined, repositorio, diretorio,
-            tomarNome: args.opcoes.forcar === true });
-        console.log(`Rede: ${r.publicacao.maquina} entrou na Orkastery Network de ${r.casa.dono} (${r.casa.forja}: ${(0, rede_1.refDaCasa)(r.casa)}, ` +
-            `privado${r.criado ? ', criado agora' : ''}).`);
-        console.log(`  Primeiro retrato publicado (${r.publicacao.commit?.slice(0, 7)}). Depois, esta maquina publica sozinha na batida do pulse`);
+        const r = (0, locale_1.comLocale)('pt-BR', () => (0, rede_1.entrarNaRede)({ maquina: texto(args.opcoes.maquina), forja: (0, rede_forja_1.ehNomeDeForja)(forja) ? forja : undefined,
+            repositorio, diretorio, tomarNome: args.opcoes.forcar === true }));
+        console.log(mn.entrou(r.publicacao.maquina, r.casa.dono, r.casa.forja, (0, rede_1.refDaCasa)(r.casa), r.criado));
+        console.log(mn.primeiroRetrato(String(r.publicacao.commit?.slice(0, 7))));
         if (r.publicacao.tomouNome)
-            console.log(`  Tomou o nome "${r.publicacao.maquina}" de outra instalacao; o commit registra.`);
-        console.log('  e ao criar thread, despachar fase, entregar e fechar. De qualquer maquina desta pessoa: ork network status');
-        for (const d of r.publicacao.descartados) {
-            console.log(`  AVISO: um projeto ficou fora do retrato: padrao "${d.padrao}" em ${d.campo} (valor omitido de proposito).`);
-        }
+            console.log(mn.tomouNome(r.publicacao.maquina));
+        console.log(mn.eAoCriar);
+        for (const d of r.publicacao.descartados)
+            console.log(mn.avisoDescartado(d.padrao, d.campo));
         if (process.env.ORK_MAQUINA && process.env.ORK_MAQUINA.trim() !== r.publicacao.maquina) {
-            console.log(`  AVISO: ORK_MAQUINA=${process.env.ORK_MAQUINA} neste shell vence o nome gravado; alinhe os dois.`);
+            console.log(mn.avisoOrkMaquina(process.env.ORK_MAQUINA));
         }
         return 0;
     }
     if (sub === 'sair') {
-        const r = (0, rede_1.sairDaRede)({ forja: (0, rede_forja_1.ehNomeDeForja)(forja) ? forja : undefined, repositorio });
-        console.log(`Rede: ${r.maquina} saiu; nada mais e publicado daqui.` + (r.commit
-            ? ` Retrato removido de ${r.casa} (${r.commit.slice(0, 7)}).`
-            : r.alheio
-                ? ` O retrato "${r.maquina}" em ${r.casa} e de outra instalacao com o mesmo nome; nada foi removido.` +
-                    (r.mesmoHostname ? ' Ele tem o hostname desta maquina: se ~/.orkastery foi apagada, retome o nome com ork network entrar --forcar.' : '')
-                : ` Nao havia retrato desta maquina${r.casa ? ` em ${r.casa}` : ' numa casa alcancavel'}.`));
-        if ((0, maquina_1.lerConfigDaMaquina)()?.fabricaCompartilhada) {
-            console.log('  A fabrica compartilhada dos projetos continua publicando daqui (ork/fabrica-estado); ork fabrica sair em cada um para parar.');
-        }
+        const r = (0, locale_1.comLocale)('pt-BR', () => (0, rede_1.sairDaRede)({ forja: (0, rede_forja_1.ehNomeDeForja)(forja) ? forja : undefined, repositorio }));
+        console.log(mn.saiu(r.maquina, r.commit ? mn.retratoRemovido(r.casa, r.commit.slice(0, 7))
+            : r.alheio ? mn.retratoDeOutraInstalacao(r.maquina, r.casa, r.mesmoHostname === true)
+                : mn.semRetrato(r.casa)));
+        if ((0, maquina_1.lerConfigDaMaquina)()?.fabricaCompartilhada)
+            console.log(mn.fabricaContinua);
         return 0;
     }
     if (sub === 'publicar') {
         if (args.opcoes.silencioso === true) {
             // O filho do evento de thread: quem disparou ja tomou a vez (teto de 14 min) e nao espera.
+            // RM-061 (F3b): o rede.log guarda o que aconteceu em pt-BR, com qualquer lingua no ambiente.
             try {
-                (0, rede_adesao_1.registrarNaRede)({ ...(0, rede_1.publicarRede)({ diretorio }), origem: 'evento' });
+                (0, locale_1.comLocale)('pt-BR', () => (0, rede_adesao_1.registrarNaRede)({ ...(0, rede_1.publicarRede)({ diretorio }), origem: 'evento' }));
                 return 0;
             }
             catch (e) {
-                (0, rede_adesao_1.registrarNaRede)({ acao: 'falhou', origem: 'evento', erro: e.message });
+                (0, locale_1.comLocale)('pt-BR', () => (0, rede_adesao_1.registrarNaRede)({ acao: 'falhou', origem: 'evento', erro: e.message }));
                 return 1;
             }
         }
-        const r = (0, rede_1.publicarRede)({ diretorio, forcar: args.opcoes.forcar === true, forja: (0, rede_forja_1.ehNomeDeForja)(forja) ? forja : undefined, repositorio });
+        const r = (0, locale_1.comLocale)('pt-BR', () => (0, rede_1.publicarRede)({ diretorio, forcar: args.opcoes.forcar === true,
+            forja: (0, rede_forja_1.ehNomeDeForja)(forja) ? forja : undefined, repositorio }));
         if (args.opcoes.json === true)
             console.log(JSON.stringify(r, null, 2));
         else
-            console.log(r.acao === 'publicou'
-                ? `Rede: ${r.maquina} publicou o retrato em ${r.casa} (${r.commit?.slice(0, 7)}, ${r.tentativas} tentativa(s)).`
-                : r.acao === 'ocupado'
-                    ? 'Rede: outra publicacao desta maquina esta em andamento; tente de novo em instantes.'
-                    : `Rede: retrato de ${r.maquina} igual ao ultimo publicado em ${r.casa}; nada a enviar (use --forcar para publicar mesmo assim).`);
+            console.log(r.acao === 'publicou' ? mn.publicou(r.maquina, r.casa, r.commit?.slice(0, 7), r.tentativas)
+                : r.acao === 'ocupado' ? mn.ocupado : mn.igual(r.maquina, r.casa));
         if (args.opcoes.json !== true) {
             for (const d of r.descartados)
-                console.log(`  AVISO: um projeto ficou fora do retrato: padrao "${d.padrao}" em ${d.campo} (valor omitido de proposito).`);
+                console.log(mn.avisoDescartado(d.padrao, d.campo));
         }
         return 0;
     }
     if (sub !== undefined && sub !== 'status') {
-        console.error(`subcomando desconhecido: network ${sub}`);
-        console.error(uso);
+        console.error((0, locale_1.msg)().cli.subcomandoDesconhecido('network', sub));
+        console.error(mn.uso);
         return 2;
     }
     // RM-054 (fatia 3): o host sem cwd de projeto (RM-052, D3) nao faz do diretorio do gateway um projeto lido.
     const doHost = (process.env[projeto_alvo_1.ENV_PROJETO_EXPLICITO] ?? '').trim() === '1';
-    const status = (0, rede_status_1.lerRede)({ semRemoto: args.opcoes['sem-remoto'] === true, diretorio: doHost ? null : diretorio });
+    const status = (0, locale_1.comLocale)('pt-BR', () => (0, rede_status_1.lerRede)({ semRemoto: args.opcoes['sem-remoto'] === true, diretorio: doHost ? null : diretorio }));
     console.log(args.opcoes.json === true ? (0, rede_status_1.jsonDaRede)(status) : (0, rede_status_1.textoDaRede)(status));
     return 0;
 }
@@ -2635,54 +2829,55 @@ function comandoNetwork(args) {
  */
 function comandoProjetos(args, projeto) {
     const sub = args.posicionais[1] ?? 'list';
+    const m = (0, locale_1.msg)().projetos.cli;
     if (sub === 'list' || sub === 'listar') {
         const projetos = (0, projeto_alvo_1.listarProjetos)();
         if (args.opcoes.json === true) {
             console.log(JSON.stringify({ contrato: projeto_alvo_1.CONTRATO_PROJETOS, arquivo: (0, projeto_alvo_1.caminhoDoRegistro)(), projetos }, null, 2));
             return 0;
         }
-        console.log(`Projetos conhecidos desta maquina (${(0, projeto_alvo_1.raizParaExibir)((0, projeto_alvo_1.caminhoDoRegistro)())})`);
+        console.log(m.titulo((0, projeto_alvo_1.raizParaExibir)((0, projeto_alvo_1.caminhoDoRegistro)())));
         console.log('');
         if (projetos.length === 0) {
-            console.log('  Nenhum ainda. ork init, ork thread new e ork fabrica entrar registram; ou: ork projetos registrar <caminho>');
+            console.log(m.nenhum);
             return 0;
         }
-        console.log((0, util_1.tabela)(['NOME', 'ABBREV', 'RAIZ', 'REMOTO', 'NO DISCO', 'ATUALIZADO'], projetos.map((p) => [
-            p.nome, p.abbrev || '-', (0, projeto_alvo_1.raizParaExibir)(p.raiz), p.remoto ?? 'sem remoto', p.presente ? 'sim' : 'ausente',
+        console.log((0, util_1.tabela)([...m.cabecalho], projetos.map((p) => [
+            p.nome, p.abbrev || '-', (0, projeto_alvo_1.raizParaExibir)(p.raiz), p.remoto ?? m.semRemoto, p.presente ? m.sim : m.ausente,
             (0, horario_1.formatarDataHora)(p.atualizadoEm)
         ])));
         console.log('');
-        console.log('Use --projeto <nome> em qualquer comando (ORK_PROJETO vale para o shell inteiro). ' + (0, horario_1.legendaDoFuso)());
+        console.log(`${m.selecao} ${(0, horario_1.legendaDoFuso)()}`);
         return 0;
     }
     if (sub === 'registrar') {
         const caminho = args.posicionais[2];
         if (caminho !== undefined && projeto !== undefined)
-            throw new Error('uso: ork projetos registrar [caminho] (um caminho ou --projeto, não os dois)');
+            throw new Error(m.usoRegistrar);
         const alvo = caminho === undefined ? (0, projeto_alvo_1.resolverProjetoAlvo)({ opcao: projeto ?? null }) : null;
         const p = (0, projeto_alvo_1.registrarProjeto)(caminho ?? alvo?.raiz ?? process.cwd(), 'projetos registrar');
         if (args.opcoes.json === true) {
             console.log(JSON.stringify(p, null, 2));
             return 0;
         }
-        console.log(`Projeto ${p.nome} (${p.abbrev || '-'}) registrado: ${(0, projeto_alvo_1.raizParaExibir)(p.raiz)} · ${p.remoto ?? 'sem remoto'}`);
+        console.log(m.registrado(p.nome, p.abbrev || '-', (0, projeto_alvo_1.raizParaExibir)(p.raiz), p.remoto ?? m.semRemoto));
         return 0;
     }
     if (sub === 'esquecer') {
         const alvo = args.posicionais[2] ?? projeto;
         if (!alvo)
-            throw new Error('uso: ork projetos esquecer <nome|caminho>');
+            throw new Error(m.usoEsquecer);
         const sairam = (0, projeto_alvo_1.esquecerProjeto)(alvo);
         if (args.opcoes.json === true) {
             console.log(JSON.stringify(sairam, null, 2));
             return 0;
         }
         for (const p of sairam)
-            console.log(`Projeto ${p.nome} esquecido: ${(0, projeto_alvo_1.raizParaExibir)(p.raiz)} (nada no disco foi apagado)`);
+            console.log(m.esquecido(p.nome, (0, projeto_alvo_1.raizParaExibir)(p.raiz)));
         return 0;
     }
-    console.error(`subcomando desconhecido: projetos ${sub}`);
-    console.error('uso: ork projetos [--json] | projetos registrar [caminho] | projetos esquecer <nome|caminho>');
+    console.error(m.desconhecido(sub));
+    console.error(m.uso);
     return 2;
 }
 /**
@@ -2696,15 +2891,16 @@ function comandoProjetos(args, projeto) {
 function comandoOrquestracao(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
     const sub = args.posicionais[1];
+    const m = (0, locale_1.msg)().operacao.restante.monitor;
     if (sub !== undefined && sub !== 'status') {
-        console.error(`subcomando desconhecido: orquestracao ${sub}`);
-        console.error('uso: ork orquestracao status [--all] [--json] [--atencao N] [--so-paradas]');
+        console.error(m.desconhecido(sub));
+        console.error(m.uso);
         return 2;
     }
     const bruto = texto(args.opcoes.atencao);
     const atencaoMin = bruto === undefined ? undefined : Number(bruto);
     if (atencaoMin !== undefined && (!Number.isFinite(atencaoMin) || atencaoMin < 0)) {
-        console.error(`--atencao espera minutos (inteiro >= 0), recebeu "${bruto}"`);
+        console.error(m.atencao(bruto ?? ''));
         return 2;
     }
     const monitor = (0, orquestracao_1.montarMonitor)(carregado, {
@@ -2722,74 +2918,88 @@ function comandoOrquestracao(args) {
     }
     return 0;
 }
+/**
+ * RM-037 (defeito 2 de 19 e 20/10/2026): o preparo de `worktree.dependencias` na worktree nova, dito ao lado dela. A
+ * falha vai ao stderr com o comando exato e o diretorio, e a thread continua criada.
+ */
+function relatarDependencias(p, dir) {
+    if (!p)
+        return;
+    const m = (0, locale_1.msg)().worktree;
+    if (p.ok)
+        console.log(m.dependenciasProntas(p.comando, Math.round(p.duracaoMs / 1000)));
+    else
+        console.error(m.dependenciasFalharam(p.comando, p.code, p.causa === 'timeout', dir, (0, dependencias_da_worktree_1.ultimaLinhaDoPreparo)(p)));
+}
 function comandoWorktree(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
     const sub = args.posicionais[1];
     const id = args.posicionais[2];
+    // RM-061 (F3b, D3): a moldura pelo catalogo; o que os quatro subcomandos gravam (ledger, thread.json, a soltura dos
+    // leases) roda no escopo pt-BR, e o detalhe e a correcao do resultado sao remontados no locale do comando.
+    const m = (0, locale_1.msg)().worktree;
     if (!sub || !id) {
-        console.error('uso: ork worktree <ensure|sync|audit|release> <thread-id>');
+        console.error(m.uso);
         return 2;
     }
+    const bloqueio = (titulo, r) => {
+        console.error(titulo);
+        console.error(m.motivoTipado(r.motivo));
+        console.error(m.detalhe((0, locale_1.remontar)(r.detalhe)));
+        console.error(m.correcao((0, locale_1.remontar)(r.correcao)));
+    };
     if (sub === 'ensure') {
-        const r = (0, worktree_1.garantirWorktree)(carregado, id);
+        const r = (0, locale_1.comLocale)('pt-BR', () => (0, worktree_1.garantirWorktree)(carregado, id));
         if (!r.ok) {
-            console.error(`Worktree da thread ${id} NAO garantida.`);
-            console.error(`  motivo tipado: ${r.motivo}`);
-            console.error(`  detalhe: ${r.detalhe}`);
-            console.error(`  correcao: ${r.correcao}`);
+            bloqueio(m.naoGarantida(id), r);
             return 1;
         }
-        console.log(r.criada ? `Worktree criada para a thread ${id}.` : `Worktree ja existia para a thread ${id}.`);
-        console.log(`  dir     ${r.dir}`);
-        console.log(`  branch  ${r.branch}`);
-        console.log(`  base    ${r.base} (resolvida pelo ork, nao pelo executor)`);
-        console.log(`  ${r.detalhe}`);
+        console.log(r.criada ? m.criada(id) : m.jaExistia(id));
+        console.log(m.linhaDir(r.dir));
+        console.log(m.linhaBranch(r.branch));
+        console.log(m.linhaBase(r.base));
+        console.log(`  ${(0, locale_1.remontar)(r.detalhe)}`);
+        relatarDependencias(r.dependencias, r.dir);
         return 0;
     }
     if (sub === 'sync') {
-        const r = (0, worktree_1.sincronizarWorktree)(carregado, id, { dryRun: args.opcoes['dry-run'] === true });
+        const r = (0, locale_1.comLocale)('pt-BR', () => (0, worktree_1.sincronizarWorktree)(carregado, id, { dryRun: args.opcoes['dry-run'] === true }));
         if (!r.ok) {
-            console.error(`Sync da worktree da thread ${id} BLOQUEADO.`);
-            console.error(`  motivo tipado: ${r.motivo}`);
-            console.error(`  detalhe: ${r.detalhe}`);
-            console.error(`  correcao: ${r.correcao}`);
+            bloqueio(m.syncBloqueado(id), r);
             return 1;
         }
-        console.log(r.dryRun ? `Sync (--dry-run) da thread ${id}: nada foi executado.` : `Sync da thread ${id}.`);
-        console.log(`  base       ${r.base} @ ${r.shaBase.slice(0, 8)}`);
-        console.log(`  branch     ${r.branch} @ ${r.shaAntes.slice(0, 8)} -> ${r.shaDepois.slice(0, 8)}`);
-        console.log(`  rebase     ${r.rebaseFeito ? 'feito' : r.jaAtualizada ? 'desnecessario' : 'seria feito'}`);
-        console.log(`  ${r.detalhe}`);
+        console.log(r.dryRun ? m.syncEnsaio(id) : m.syncFeito(id));
+        console.log(m.syncBase(r.base, r.shaBase.slice(0, 8)));
+        console.log(m.syncBranch(r.branch, r.shaAntes.slice(0, 8), r.shaDepois.slice(0, 8)));
+        console.log(m.syncRebase(r.rebaseFeito ? 'feito' : r.jaAtualizada ? 'desnecessario' : 'seria feito'));
+        console.log(`  ${(0, locale_1.remontar)(r.detalhe)}`);
         if (r.passos.length > 0) {
             console.log('');
-            console.log('  Comandos reais, na ordem:');
+            console.log(m.comandosReais);
             for (const passo of r.passos)
-                console.log(`    ${passo}`);
+                console.log(`    ${(0, locale_1.remontar)(passo)}`);
         }
         return 0;
     }
     if (sub === 'audit') {
-        const r = (0, worktree_1.auditarWorktree)(carregado, id);
+        const r = (0, locale_1.comLocale)('pt-BR', () => (0, worktree_1.auditarWorktree)(carregado, id));
         console.log((0, worktree_1.textoDoAudit)(id, r));
         return r.ok ? 0 : 1;
     }
     if (sub === 'release') {
-        const r = (0, worktree_1.liberarWorktree)(carregado, id, { forcar: args.opcoes.forcar === true });
+        const r = (0, locale_1.comLocale)('pt-BR', () => (0, worktree_1.liberarWorktree)(carregado, id, { forcar: args.opcoes.forcar === true }));
         if (!r.ok) {
-            console.error(`Release da worktree da thread ${id} BLOQUEADO.`);
-            console.error(`  motivo tipado: ${r.motivo}`);
-            console.error(`  detalhe: ${r.detalhe}`);
-            console.error(`  correcao: ${r.correcao}`);
+            bloqueio(m.releaseBloqueado(id), r);
             return 1;
         }
-        console.log(`Worktree da thread ${id} liberada.`);
-        console.log(`  dir      ${r.dir}`);
-        console.log(`  removida ${r.removida ? 'sim' : 'nao (o diretorio ja nao existia)'}`);
-        console.log(`  leases   ${r.leasesLiberados.join(', ') || '(nenhum lease de escrita para soltar)'}`);
-        console.log(`  ${r.detalhe}`);
+        console.log(m.liberada(id));
+        console.log(m.releaseDir(r.dir));
+        console.log(m.releaseRemovida(r.removida));
+        console.log(m.releaseLeases(r.leasesLiberados.join(', ')));
+        console.log(`  ${(0, locale_1.remontar)(r.detalhe)}`);
         return 0;
     }
-    console.error(`subcomando desconhecido: worktree ${sub}`);
+    console.error((0, locale_1.msg)().cli.subcomandoDesconhecido('worktree', sub));
     return 2;
 }
 function comandoMaster(args) {
@@ -2805,8 +3015,9 @@ function comandoMaster(args) {
         const id = args.posicionais[2];
         const formato = texto(args.opcoes.formato) ?? 'telegram';
         if (!id || !['telegram', 'terminal', 'json'].includes(formato))
-            throw new Error('uso: ork master pedir <thread> [--formato telegram|terminal|json]');
-        const pedido = (0, master_nota_1.pedirNota)(carregado.raiz, id, { codigosEmUso: (0, pulse_resposta_1.codigosEmUso)(carregado.raiz) });
+            throw new Error((0, locale_1.msg)().master.usoPedir);
+        // RM-061 (F2b, G2): o pedido de nota e gravado no escopo pt-BR; o erro da entrega volta no locale do comando.
+        const pedido = (0, locale_1.comLocale)('pt-BR', () => (0, master_nota_1.pedirNota)(carregado.raiz, id, { codigosEmUso: (0, pulse_resposta_1.codigosEmUso)(carregado.raiz) }));
         console.log(formato === 'json' ? JSON.stringify(pedido, null, 2) : (0, master_nota_1.textoDoPedidoDeNota)(carregado.raiz, pedido, formato));
         return 0;
     }
@@ -2861,12 +3072,7 @@ function comandoMaster(args) {
     // mudou, e para onde ir. Desaparecer sem dizer nada seria o mesmo pecado da #TAG
     // aposentada virando default.
     if (args.opcoes.batch === true || primeiro === 'batch') {
-        console.error('master.fila-aposentada: a fila de ratificacao de score saiu na I-43. ' +
-            'Entregue e aceito, a menos que voce diga o contrario.\n' +
-            '  ork master                     as entregas, com o indice ja derivado do ledger\n' +
-            '  ork master <id> --aceitar-omissao   aceita so esta entrega, com indice e insumos no ledger\n' +
-            '  ork master --aceitar-omissao        aceita todas as entregues (--dry-run mostra quais)\n' +
-            '  ork master <id> --score <0-5> --justificativa "<por que>" --por <humano>   para reclamar');
+        console.error((0, locale_1.msg)().master.complementar.batchAposentado);
         return 2;
     }
     if (args.opcoes['aceitar-omissao'] !== undefined) {
@@ -2881,19 +3087,20 @@ function comandoMaster(args) {
     }
     const propor = primeiro === 'propor';
     const id = propor ? args.posicionais[2] : primeiro;
+    const mm = (0, locale_1.msg)().master.complementar;
     if (!id)
-        throw new Error('informe a thread para propor MASTER');
+        throw new Error(mm.informeThread);
     const brutoScore = texto(args.opcoes.score);
     const justificativa = texto(args.opcoes.justificativa) ?? texto(args.opcoes.porque);
     if (brutoScore === undefined) {
-        console.error('uso: ork master <thread-id> --score 0-5 --justificativa "<texto>" --por <seu-nome>');
-        console.error('  o score do MASTER e humano, de 0 a 5, e a justificativa e obrigatoria.');
+        console.error(mm.usoScore);
+        console.error(mm.scoreHumano);
         return 2;
     }
     if (!justificativa) {
-        console.error(`Score RECUSADO para a thread ${id}: falta --justificativa "<texto>".`);
-        console.error('  Score sem justificativa nao vira aprendizado; o `ork` nao o registra.');
-        console.error(`  ork master ${id} --score ${brutoScore} --justificativa "<por que este score>"`);
+        console.error(mm.justificativa(id));
+        console.error(mm.justificativaRazao);
+        console.error(mm.justificativaComando(id, brutoScore));
         return 2;
     }
     const brutasClasses = texto(args.opcoes.classe) ?? texto(args.opcoes.classes);
@@ -2901,8 +3108,8 @@ function comandoMaster(args) {
     for (const bruta of (brutasClasses ?? '').split(',').map((c) => c.trim()).filter(Boolean)) {
         const classe = (0, master_2.parseClasse)(bruta);
         if (!classe) {
-            console.error(`classe de falha invalida: "${bruta}".`);
-            console.error(`  classes fixas: ${master_2.ORDEM_DAS_CLASSES.join(', ')}`);
+            console.error(mm.classeInvalida(bruta));
+            console.error(mm.classesFixas(master_2.ORDEM_DAS_CLASSES.join(', ')));
             return 2;
         }
         classes.push(classe);
@@ -2930,12 +3137,12 @@ function comandoMaster(args) {
     // vai ao ledger do projeto uma vez por janela; virar policy continua sendo do dono.
     for (const p of (0, licoes_1.registrarPropostasNovas)(carregado.raiz)) {
         console.log('');
-        console.log(`Proposta de policy: ${p.chave} em ${p.threads.length} threads nos ultimos ${p.janelaDias} dias.`);
+        console.log(mm.proposta(p.chave, p.threads.length, p.janelaDias));
         console.log(`  ${p.sugestao}`);
-        console.log('  So proposta: vira policy quando voce a declara em policies: no orkastery.yaml (ork licoes).');
+        console.log(mm.soProposta);
     }
     console.log('');
-    console.log(`Proximo passo: ork board --all   |   entregas e indice: ork master`);
+    console.log(mm.proximo);
     return 0;
 }
 /**
@@ -2952,7 +3159,7 @@ function comandoAceitarOmissao(args, raiz, posicional) {
     const candidatos = [posicional, texto(args.opcoes.thread), typeof bruto === 'string' ? bruto : undefined]
         .filter((v) => typeof v === 'string' && v.trim() !== '').map((v) => v.trim());
     if (args.opcoes.thread === true || new Set(candidatos).size > 1) {
-        console.error('uso: ork master <thread-id> --aceitar-omissao [--dry-run] [--json]   (ou --thread <thread-id>, uma thread so)');
+        console.error((0, locale_1.msg)().master.usoOmissao);
         return 2;
     }
     const alvo = candidatos[0];
@@ -2974,32 +3181,35 @@ function comandoAceitarOmissao(args, raiz, posicional) {
             console.log(JSON.stringify({ dryRun: true, fecharia }, null, 2));
             return 0;
         }
-        console.log('Ensaio (--dry-run): nada foi gravado.');
+        const m = (0, locale_1.msg)().master;
+        console.log(m.ensaio);
         if (fecharia.length === 0) {
-            console.log('Nenhuma entrega esperando decisao.');
+            console.log(m.nadaEsperando);
             return 0;
         }
-        console.log(`Fecharia por omissao: ${fecharia.length}.`);
+        console.log(m.fecharia(fecharia.length));
         for (const f of fecharia)
-            console.log(`  ${f.thread.padEnd(20)} indice ${f.indice.valor}/${f.indice.base}`);
+            console.log(m.linhaDoIndice(f.thread, f.indice.valor, f.indice.base));
         avisoDeOmissaoSemAlvo(alvo, fecharia.length, true);
         return 0;
     }
-    const aceitos = (0, master_2.aceitarPendentesPorOmissao)(raiz, { thread: alvo });
+    // RM-061 (F2b, G2): o MASTER log, o POSTMORTEM e o registro da omissao nascem em pt-BR.
+    const aceitos = (0, locale_1.comLocale)('pt-BR', () => (0, master_2.aceitarPendentesPorOmissao)(raiz, { thread: alvo }));
     avisoDeOmissaoSemAlvo(alvo, aceitos.length, false);
     if (json) {
         console.log(JSON.stringify(aceitos, null, 2));
         return 0;
     }
+    const m = (0, locale_1.msg)().master;
     if (aceitos.length === 0) {
-        console.log('Nenhuma entrega esperando decisao.');
+        console.log(m.nadaEsperando);
         return 0;
     }
-    console.log(`Aceitas por omissao: ${aceitos.length}. O indice e os insumos foram ao ledger.`);
+    console.log(m.aceitas(aceitos.length));
     for (const a of aceitos)
-        console.log(`  ${a.thread.padEnd(20)} indice ${a.indice.valor}/${a.indice.base}`);
+        console.log(m.linhaDoIndice(a.thread, a.indice.valor, a.indice.base));
     console.log('');
-    console.log('Discordou? A nota humana sobrescreve, e o registro da omissao permanece.');
+    console.log(m.discordou);
     return 0;
 }
 /**
@@ -3015,10 +3225,8 @@ function avisoDeOmissaoSemAlvo(alvo, quantas, ensaio) {
         return;
     const propria = (process.env[runtime_ambiente_1.ENV_THREAD_DO_DESPACHO] ?? '').trim();
     console.error('');
-    console.error(`aviso: master.omissao-sem-thread: processo de agente (${marca}) ${ensaio ? 'fecharia' : 'fechou'} ${quantas} threads, ` +
-        'inclusive as de outras frentes paralelas.');
-    console.error(`  Para fechar so a sua: ork master ${propria || '<thread-id>'} --aceitar-omissao` +
-        (ensaio ? '' : '  (a nota humana sobrescreve o aceite de quem nao era seu)'));
+    console.error((0, locale_1.msg)().master.avisoSemThread(marca, ensaio, quantas));
+    console.error((0, locale_1.msg)().master.avisoSoASua(propria || '<thread-id>', ensaio));
 }
 /** I-55 (RM-008): `ork licoes` mostra o que volta no proximo GOAL e PLAN, e as propostas de policy. */
 function comandoLicoes(args) {
@@ -3049,17 +3257,36 @@ function comandoRoadmap(args) {
     if (sub === 'reservas') {
         // RM-037 (rm037noite, defeito 3): a reserva de thread ja fechada aparece como orfa e sai com registro.
         if (args.opcoes['soltar-orfas'] === true) {
-            const soltas = (0, roadmap_reservas_1.soltarReservasOrfas)(carregado.raiz, { remoto });
+            // RM-061 (F3b, D3): a soltura grava no escopo pt-BR (ledger, branch de reservas); o detalhe e remontado no texto.
+            const soltas = (0, locale_1.comLocale)('pt-BR', () => (0, roadmap_reservas_1.soltarReservasOrfas)(carregado.raiz, { remoto }));
+            const mr = (0, locale_1.msg)().reservas;
             if (args.opcoes.json === true)
                 console.log(JSON.stringify(soltas, null, 2));
             else
-                console.log(soltas.length === 0 ? 'Nenhuma reserva órfã desta máquina.'
-                    : soltas.map((s) => `${s.item}: ${s.detalhe} (thread fechada ${s.thread})`).join('\n'));
+                console.log(soltas.length === 0 ? mr.nenhumaOrfa
+                    : soltas.map((s) => mr.soltura(s.item, (0, locale_1.remontar)(s.detalhe), s.thread)).join('\n'));
             return 0;
         }
-        const painel = (0, roadmap_reservas_1.listarReservas)(carregado.raiz, { remoto });
+        // RM-052 (fatia 2, D4): as reservas moram no remoto do projeto. Sem ele, nada e lido; com ele mudo e
+        // sem copia, tambem nao. A resposta diz qual projeto leu e o que ficou de fora, nunca "nenhum item".
+        // RM-047: nome fora do formato de remoto recusa antes do git, como sempre.
+        const nomeDoRemoto = (0, branch_de_estado_1.exigirRemoto)(remoto ?? roadmap_reservas_1.REMOTO_PADRAO, 'roadmap');
+        const url = (0, projeto_alvo_1.remotoDoProjeto)(carregado.raiz, nomeDoRemoto);
+        const painel = url === null ? { reservas: [], feats: [], atualizado: false, ponta: null }
+            : (0, roadmap_reservas_1.listarReservas)(carregado.raiz, { remoto });
+        const leitura = (0, roadmap_reservas_1.leituraDasReservas)(painel, url !== null);
         const orfas = (0, roadmap_reservas_1.reservasOrfas)(carregado.raiz, painel.reservas);
-        console.log(args.opcoes.json === true ? JSON.stringify({ ...painel, orfas }, null, 2) : (0, roadmap_reservas_1.textoDasReservas)(painel, orfas));
+        const lido = leitura === 'lido-agora' || leitura === 'copia-local';
+        const consulta = (0, projeto_alvo_1.consultaDoProjeto)(carregado, {
+            remoto: url,
+            lido: lido ? [`reservas do roadmap (${roadmap_reservas_1.BRANCH_DE_RESERVAS} em ${nomeDoRemoto}, ${leitura === 'lido-agora' ? 'lido agora' : 'última cópia local'})`] : [],
+            naoLido: [projeto_alvo_1.FORA_DA_CONSULTA.roadmap,
+                ...(leitura === 'sem-remoto' ? [`reservas do roadmap: o projeto não tem o remoto ${nomeDoRemoto}, nada foi lido de ${roadmap_reservas_1.BRANCH_DE_RESERVAS}`]
+                    : leitura === 'sem-copia' ? [`reservas do roadmap: o remoto ${nomeDoRemoto} não respondeu e não há cópia local de ${roadmap_reservas_1.BRANCH_DE_RESERVAS}`]
+                        : [])],
+        });
+        console.log(args.opcoes.json === true ? JSON.stringify({ ...painel, orfas, leitura, consulta }, null, 2)
+            : [...(0, projeto_alvo_1.linhasDaConsulta)(consulta), '', (0, roadmap_reservas_1.textoDasReservas)(painel, orfas, { remoto: nomeDoRemoto, projeto: carregado.manifesto.project.name, temRemoto: url !== null })].join('\n'));
         return 0;
     }
     if (sub === 'status') {
@@ -3067,27 +3294,31 @@ function comandoRoadmap(args) {
         // RM-052: com o projeto consultado e o que ficou de fora (as outras maquinas nao sao lidas aqui).
         const consulta = (0, projeto_alvo_1.consultaDoProjeto)(carregado, { lido: ['roadmap (docs/roadmap)', projeto_alvo_1.FORA_DA_CONSULTA.threadsDaMaquina],
             naoLido: [projeto_alvo_1.FORA_DA_CONSULTA.reservas, 'threads de outras máquinas (ork network roadmap)'] });
-        const status = (0, roadmap_status_1.montarStatusDoRoadmap)(carregado.raiz, { projeto: carregado.manifesto.project.name, consulta });
+        // RM-061 (F2b, G2): o status e montado em pt-BR, como o --json; so o texto segue o locale. Os canais (Hermes,
+        // OpenClaw) transportam o texto: com owner.language ou LANG en no host, o dono o recebe em ingles.
+        // RM-063 (F2): o fecho le a mesma fila do `ork pulse`, sem forja e sem registrar.
+        const status = (0, locale_1.comLocale)('pt-BR', () => (0, roadmap_status_1.montarStatusDoRoadmap)(carregado.raiz, { projeto: carregado.manifesto.project.name, consulta,
+            fila: (quando) => (0, pulse_1.filaDoDono)(carregado, { quando }) }));
         console.log(args.opcoes.json === true ? JSON.stringify(status, null, 2) : (0, roadmap_status_1.textoDoStatusDoRoadmap)(status));
         return 0;
     }
     // RM-037 (rm037noite, defeito 6): o numero da FEAT nova sai da mesma branch de reservas.
     if (sub === 'feat') {
-        const r = (0, roadmap_reservas_1.reservarFeat)(carregado.raiz, { remoto, por: texto(args.opcoes.por), maquina: texto(args.opcoes.maquina),
-            thread: texto(args.opcoes.thread) ?? null, nota: texto(args.opcoes.nota) ?? null });
+        const r = (0, locale_1.comLocale)('pt-BR', () => (0, roadmap_reservas_1.reservarFeat)(carregado.raiz, { remoto, por: texto(args.opcoes.por), maquina: texto(args.opcoes.maquina),
+            thread: texto(args.opcoes.thread) ?? null, nota: texto(args.opcoes.nota) ?? null }));
+        const mr = (0, locale_1.msg)().reservas;
         if (args.opcoes.json === true)
             console.log(JSON.stringify(r, null, 2));
         else {
-            console.log(`${r.feat}: reservado para esta maquina${r.reserva.thread ? `, thread ${r.reserva.thread}` : ''}.`);
-            console.log(`  crie docs/produto/${r.feat}-<assunto>.md; o numero nao volta, mesmo que a feature nao saia`);
-            console.log(`  branch ork/roadmap-reservas em ${r.commit.slice(0, 7)}`);
+            console.log(mr.feat(r.feat, r.reserva.thread ?? null));
+            console.log(mr.crieAPagina(r.feat));
+            console.log(mr.branch(r.commit.slice(0, 7)));
         }
         return 0;
     }
     const item = args.posicionais[2];
     if ((sub !== 'pegar' && sub !== 'soltar') || !item) {
-        console.error('uso: ork roadmap status [--json] | reservas [--soltar-orfas] | pegar <RM-NNN> [--thread T] [--nota N] | ' +
-            'soltar <RM-NNN> [--forcar --motivo M] | feat [--thread T] [--nota N]');
+        console.error((0, locale_1.msg)().reservas.uso);
         return 2;
     }
     const opcoes = {
@@ -3099,18 +3330,17 @@ function comandoRoadmap(args) {
         forcar: args.opcoes.forcar === true,
         motivo: texto(args.opcoes.motivo),
     };
-    const r = sub === 'pegar' ? (0, roadmap_reservas_1.pegarItem)(carregado.raiz, item, opcoes) : (0, roadmap_reservas_1.soltarItem)(carregado.raiz, item, opcoes);
+    const r = (0, locale_1.comLocale)('pt-BR', () => sub === 'pegar' ? (0, roadmap_reservas_1.pegarItem)(carregado.raiz, item, opcoes) : (0, roadmap_reservas_1.soltarItem)(carregado.raiz, item, opcoes));
     if (args.opcoes.json === true) {
         console.log(JSON.stringify(r, null, 2));
         return 0;
     }
-    const verbo = { pegou: 'reservado para esta maquina', renovou: 'reserva renovada', tomou: 'reserva TOMADA de outra maquina',
-        soltou: 'devolvido', nada: 'ja estava livre' }[r.acao];
-    console.log(`${r.item}: ${verbo}.`);
+    const mr = (0, locale_1.msg)().reservas;
+    console.log(mr.itemAcao(r.item, mr.acao(r.acao)));
     if (r.reserva && r.acao !== 'soltou')
-        console.log(`  com ${r.reserva.por} em ${r.reserva.maquina}${r.reserva.thread ? `, thread ${r.reserva.thread}` : ''}`);
+        console.log(mr.com(r.reserva.por, r.reserva.maquina, r.reserva.thread ?? null));
     if (r.commit)
-        console.log(`  branch ork/roadmap-reservas em ${r.commit.slice(0, 7)}`);
+        console.log(mr.branch(r.commit.slice(0, 7)));
     return 0;
 }
 /**
@@ -3120,7 +3350,7 @@ function comandoRoadmap(args) {
 function comandoNetworkRoadmap(args) {
     const pedido = texto(args.opcoes.projeto);
     if (args.posicionais[1] !== 'roadmap' || args.posicionais.length > 2 || (args.opcoes.projeto !== undefined && !pedido)) {
-        console.error('uso: ork network roadmap [--projeto <caminho|github:dono/repo|gitlab:grupo/repo|nome>] [--json] [--sem-remoto]');
+        console.error((0, locale_1.msg)().network.roadmap.uso);
         return 2;
     }
     try {
@@ -3138,14 +3368,41 @@ function comandoNetworkRoadmap(args) {
         return network_roadmap_1.SAIDA_DO_PEDIDO;
     }
 }
+/**
+ * RM-026 K7 (fatia 2, D11 e D13): o conhecimento escrito, so leitura. O JSON e o das tools `ork_conhecimento_*`,
+ * em pt-BR nas duas linguas; so o texto segue o locale. Sai 1 quando a consulta nao responde e 2 com uso errado
+ * (D13 revista no CHECK: o gate de CI separa o erro de digitacao da lacuna).
+ */
+function comandoConhecimento(args) {
+    const [, sub = 'listar', id, ...resto] = args.posicionais;
+    const colecao = args.opcoes.colecao;
+    const valido = conhecimento_consulta_1.CONSULTAS_DO_CONHECIMENTO.includes(sub) && !resto.length &&
+        (args.opcoes.json === undefined || args.opcoes.json === true) &&
+        Object.keys(args.opcoes).every((k) => k === 'json' || (k === 'colecao' && sub === 'listar')) &&
+        (colecao === undefined || (typeof colecao === 'string' && conhecimento_1.NOME_DE_COLECAO.test(colecao))) &&
+        (sub === 'mostrar' ? typeof id === 'string' && conhecimento_1.ID_DE_DOCUMENTO.test(id) : id === undefined);
+    if (!valido) {
+        console.error((0, locale_1.msg)().cli.erro((0, locale_1.msg)().conhecimento.uso));
+        return 2;
+    }
+    const pedido = sub === 'mostrar' ? { consulta: 'mostrar', id }
+        : sub === 'listar' ? { consulta: 'listar', ...(typeof colecao === 'string' ? { colecao } : {}) }
+            : { consulta: sub };
+    const carregado = (0, manifest_1.exigirManifesto)();
+    const r = (0, conhecimento_consulta_1.consultarConhecimento)(carregado, pedido);
+    console.log(args.opcoes.json === true ? (0, saida_segura_1.jsonSemInvisivel)(r) : (0, conhecimento_consulta_1.textoDoConhecimento)(r));
+    return (0, conhecimento_consulta_1.consultaRespondeu)(r) ? 0 : 1;
+}
 function comandoDocs(args) {
     const sub = args.posicionais[1] ?? 'verificar';
     const carregado = (0, manifest_1.carregarManifesto)();
     const raiz = carregado?.raiz ?? (0, manifest_1.diretorioDoProjeto)();
     const baseBranch = carregado?.manifesto.worktree?.base_branch ?? 'main';
+    const md = (0, locale_1.msg)().docs;
     if (sub === 'verificar') {
         // RM-037 (fatia 3, GO-FIX 2): o CI passa --pr no pull_request; no push da main as duas regras novas reprovam.
-        const { docs, achados } = (0, docs_1.verificarDocs)(raiz, { baseBranch, ajudaDoCli: AJUDA, pr: args.opcoes.pr === true });
+        // RM-061 (F3b, G4): verifica no escopo pt-BR, como o `--json` leva os achados; o texto os remonta no locale do comando.
+        const { docs, achados } = (0, locale_1.comLocale)('pt-BR', () => (0, docs_1.verificarDocs)(raiz, { baseBranch, ajudaDoCli: AJUDA, pr: args.opcoes.pr === true }));
         if (args.opcoes.json === true) {
             console.log(JSON.stringify({ paginas: docs.length, erros: achados.filter((a) => a.gravidade === 'erro').length,
                 achados }, null, 2));
@@ -3162,64 +3419,73 @@ function comandoDocs(args) {
         // Sugestao 4 do CHECK 1 (e 8 do CHECK 2, `--so=`): `--so` sem item e erro de uso, nunca o escopo
         // padrao em silencio.
         if (args.opcoes.so === true || (typeof args.opcoes.so === 'string' && !args.opcoes.so.trim())) {
-            console.error('uso: ork docs sincronizar --so RM-NNN[,RM-MMM] (faltou o item depois de --so)');
+            console.error(md.usoSoSemItem);
             return 2;
         }
         const so = texto(args.opcoes.so);
         let itens;
-        let escopo = 'todo item do roadmap';
+        let escopo = md.escopoTodos;
         if (so) {
             itens = so.split(',').map((i) => i.trim().toUpperCase()).filter(Boolean);
             const fora = itens.filter((i) => !/^RM-\d{3}$/.test(i));
             if (fora.length || itens.length === 0) {
-                console.error(`uso: ork docs sincronizar --so RM-NNN[,RM-MMM] (recebido: ${so})`);
+                console.error(md.usoSoInvalido(so));
                 return 2;
             }
-            escopo = `so ${itens.join(', ')} (--so)`;
+            escopo = md.escopoSo(itens.join(', '));
         }
         else if (args.opcoes.todos !== true) {
             const padrao = (0, docs_1.escopoPadraoDoSync)(raiz);
             if (padrao.itens) {
                 itens = padrao.itens;
-                escopo = `so ${itens.join(', ')}, o item da thread ${padrao.thread} desta worktree (--todos para todo item)`;
+                escopo = md.escopoDaThread(itens.join(', '), String(padrao.thread));
             }
         }
-        const r = (0, docs_1.sincronizarDocs)(raiz, { baseBranch, escrever, itens });
+        const r = (0, locale_1.comLocale)('pt-BR', () => (0, docs_1.sincronizarDocs)(raiz, { baseBranch, escrever, itens }));
         console.log(args.opcoes.json === true ? JSON.stringify({ ...r, escopo: itens ?? null }, null, 2)
-            : `Escopo: ${escopo}.\n${(0, docs_1.textoDaSincronizacao)(r, escrever)}`);
+            : `${md.escopo(escopo)}\n${(0, docs_1.textoDaSincronizacao)(r, escrever)}`);
         return 0;
     }
     if (sub === 'init') {
-        const criados = (0, docs_1.iniciarDocs)(raiz);
+        // RM-061 (F3a, D1 e D5): os sete arquivos nascem na lingua do dono, resolvida pelo manifesto (tambem com `--json`,
+        // que tira so o texto impresso do locale); o texto segue o locale do comando coberto.
+        const criados = (0, docs_1.iniciarDocs)(raiz, (0, locale_1.resolverLocale)(carregado?.manifesto.owner?.language).locale);
+        const m = (0, locale_1.msg)().gerados.docsInit;
         console.log(criados.length === 0
-            ? 'Documentacao como codigo ja estava no projeto: nada criado.'
-            : ['Criado:', ...criados.map((c) => `  ${c}`), '',
-                'Proximo passo: copie docs/produto/_modelo-feature.md e docs/roadmap/_modelo-item.md, e rode ork docs verificar'].join('\n'));
+            ? m.jaEstava
+            : [m.criado, ...criados.map((c) => `  ${c}`), '', m.proximoPasso].join('\n'));
         return 0;
     }
-    console.error(`uso: ork docs verificar [--json] [--pr] | sincronizar [--escrever] [--so RM-NNN] [--todos] | init`);
+    console.error(md.uso);
     return 2;
 }
 function comandoPrompt(args) {
     const sub = args.posicionais[1] ?? 'list';
     const carregado = (0, manifest_1.carregarManifesto)();
     const raiz = carregado?.raiz;
+    const mp = (0, locale_1.msg)().prompts.cli;
+    // RM-061 F3c: o template e a lingua do prompt sao os do despacho (a lingua declarada do dono, `owner.language`;
+    // sem ela, pt-BR), para o render mostrar o que o `phase run` grava; so o texto do CLI em volta segue o locale ativo.
+    // Os templates do projeto sempre aparecem; dos embutidos, o da lingua do prompt.
+    const linguaDoPrompt = (0, locale_1.linguaDeclaradaDoDono)(carregado?.manifesto.owner?.language);
+    const templatesDaLingua = () => (0, prompts_1.carregarTemplates)(raiz).filter((t) => t.origem !== 'embutido' || (linguaDoPrompt === 'en' ? t.id.endsWith('.en') : !t.id.endsWith('.en')));
     if (sub === 'list') {
-        console.log((0, prompts_1.tabelaDeTemplates)((0, prompts_1.carregarTemplates)(raiz)));
+        console.log((0, prompts_1.tabelaDeTemplates)(templatesDaLingua()));
         return 0;
     }
     if (sub === 'lint') {
         const id = texto(args.opcoes.template);
-        const templates = id ? [(0, prompts_1.exigirTemplate)(id, raiz)] : (0, prompts_1.carregarTemplates)(raiz);
-        const problemas = templates.flatMap((t) => (0, prompts_1.lintTemplate)(t));
-        console.log(`Lint dos templates de prompt${raiz ? ` (projeto ${raiz})` : ' (somente embutidos)'}`);
+        const templates = id ? [(0, prompts_1.exigirTemplate)(id, raiz)] : templatesDaLingua();
+        const problemas = [...templates.flatMap((t) => (0, prompts_1.lintTemplate)(t)),
+            ...(id ? [] : (0, prompts_1.avisosDeLingua)(templates, linguaDoPrompt))];
+        console.log(mp.lintTitulo(raiz ?? null));
         console.log('');
         console.log((0, prompts_1.textoDoLint)(problemas, templates.length));
         return problemas.some((p) => p.gravidade === 'erro') ? 2 : 0;
     }
     if (sub === 'render') {
         const fase = exigirFaseCanonica(texto(args.opcoes.fase) ?? args.posicionais[3]);
-        const pedido = texto(args.opcoes.pedido) ?? '<pedido do builder>';
+        const pedido = texto(args.opcoes.pedido) ?? mp.pedidoExemplo;
         const idTemplate = texto(args.opcoes.template);
         // Modo exemplo: renderiza sem thread nenhuma, para revisar o texto de um modo antes de
         // abrir trabalho. Nada e gravado, e o `ork` diz em voz alta que a thread e ficticia.
@@ -3234,10 +3500,10 @@ function comandoPrompt(args) {
                 return 2;
             }
             const exemplo = (0, prompts_1.threadDeExemplo)(modo, fase, carregado?.manifesto.project);
-            const template = idTemplate ? (0, prompts_1.exigirTemplate)(idTemplate, raiz) : (0, prompts_1.templateDaFase)(fase, raiz);
-            const prompt = (0, prompts_1.renderizar)(template, (0, phase_1.valoresDoPrompt)(exemplo, fase, pedido));
-            console.log(`# template ${template.id} v${template.versao} (origem: ${template.origem})`);
-            console.log(`# thread de EXEMPLO (nada foi gravado), modo ${modos_1.MODOS[modo].tag}, sha256 ${(0, phase_1.hashDoPrompt)(prompt)}`);
+            const template = idTemplate ? (0, prompts_1.exigirTemplate)(idTemplate, raiz) : (0, prompts_1.templateDaFase)(fase, raiz, linguaDoPrompt);
+            const prompt = (0, prompts_1.renderizar)(template, (0, phase_1.valoresDoPrompt)(exemplo, fase, pedido, '', (0, prompts_1.idiomaDoTemplate)(template)));
+            console.log(mp.cabecalhoTemplate(template.id, template.versao, template.origem));
+            console.log(mp.cabecalhoExemplo(modos_1.MODOS[modo].tag, (0, phase_1.hashDoPrompt)(prompt)));
             console.log('');
             console.log(prompt);
             return 0;
@@ -3245,29 +3511,35 @@ function comandoPrompt(args) {
         const obrigatorio = (0, manifest_1.exigirManifesto)();
         const threadId = args.posicionais[2];
         if (!threadId) {
-            console.error('uso: ork prompt render <thread-id> <FASE> --pedido "<texto>"');
-            console.error('     ork prompt render --exemplo --fase GOAL --modo auto --pedido "<texto>"');
+            console.error(mp.usoRenderThread);
+            console.error(mp.usoRenderExemplo);
             return 2;
         }
         const thread = (0, thread_1.lerThread)(obrigatorio.raiz, threadId);
-        const template = idTemplate ? (0, prompts_1.exigirTemplate)(idTemplate, obrigatorio.raiz) : (0, prompts_1.templateDaFase)(fase, obrigatorio.raiz);
+        // RM-059 (T6.0): sem --pedido, o pedido guardado na criacao, conferido pelo sha256; thread sem pedido
+        // guardado segue com o texto de exemplo, como antes.
+        const guardado = texto(args.opcoes.pedido) === undefined ? (0, thread_1.pedidoDaThread)(obrigatorio.raiz, thread) : null;
+        const pedidoDaFase = guardado?.texto ?? pedido;
+        const template = idTemplate ? (0, prompts_1.exigirTemplate)(idTemplate, obrigatorio.raiz) : (0, prompts_1.templateDaFase)(fase, obrigatorio.raiz, linguaDoPrompt);
         const prompt = idTemplate
-            ? (0, prompts_1.renderizar)(template, (0, phase_1.valoresDoPrompt)(thread, fase, pedido))
-            : (0, phase_1.montarPrompt)(thread, fase, pedido, obrigatorio.raiz);
-        console.log(`# template ${template.id} v${template.versao} (origem: ${template.origem})`);
-        console.log(`# thread ${thread.id}, fase ${fase}, sha256 ${(0, phase_1.hashDoPrompt)(prompt)}`);
+            ? (0, prompts_1.renderizar)(template, (0, phase_1.valoresDoPrompt)(thread, fase, pedidoDaFase, '', (0, prompts_1.idiomaDoTemplate)(template)))
+            : (0, phase_1.montarPrompt)(thread, fase, pedidoDaFase, obrigatorio.raiz, '', linguaDoPrompt);
+        console.log(mp.cabecalhoTemplate(template.id, template.versao, template.origem));
+        console.log(mp.cabecalhoThread(thread.id, fase, (0, phase_1.hashDoPrompt)(prompt)));
+        if (guardado)
+            console.log(mp.pedidoGuardado((0, util_1.shaCurto)(guardado.sha256)));
         console.log('');
         console.log(prompt);
         return 0;
     }
-    console.error(`subcomando desconhecido: prompt ${sub}`);
+    console.error(mp.subcomandoDesconhecido(sub));
     return 2;
 }
 /** Fase canonica a partir do texto do usuario, com erro tipado quando nao existe. */
 function exigirFaseCanonica(bruto) {
     const alvo = (bruto ?? '').toUpperCase();
     if (!types_1.FASES.includes(alvo)) {
-        throw new Error(`fase "${bruto ?? ''}" fora do ciclo canonico (${types_1.FASES.join(' ')})`);
+        throw new Error((0, locale_1.msg)().prompts.cli.faseForaDoCiclo(bruto ?? '', types_1.FASES.join(' ')));
     }
     return alvo;
 }
@@ -3289,6 +3561,7 @@ function orkEmExecucao() {
 }
 function comandoAdapter(args) {
     const sub = args.posicionais[1] ?? 'list';
+    const ma = (0, locale_1.msg)().adapter;
     if (sub === 'list') {
         console.log((0, hosts_1.tabelaDeHosts)());
         return 0;
@@ -3296,13 +3569,12 @@ function comandoAdapter(args) {
     if (sub === 'show') {
         const host = (0, hosts_1.parseHost)(args.posicionais[2]);
         if (!host) {
-            console.error(`host desconhecido: "${args.posicionais[2] ?? ''}". Use: ${hosts_1.ORDEM_DOS_HOSTS.join(' | ')}`);
+            console.error(ma.hostDesconhecido(args.posicionais[2] ?? '', hosts_1.ORDEM_DOS_HOSTS.join(' | ')));
             return 2;
         }
-        const def = hosts_1.HOSTS[host];
-        console.log(`Adaptador ${host}`);
-        console.log(`  ${def.descricao}`);
-        console.log(`  destino padrao: <projeto>/${def.destinoPadrao}${def.subdir ? '/' + def.subdir : ''}`);
+        console.log(ma.adaptador(host));
+        console.log(`  ${ma.hosts[host].descricao}`);
+        console.log(`  ${ma.destinoPadrao((0, hosts_1.destinoPadraoDe)(host))}`);
         console.log('');
         console.log((0, hosts_1.textoDosPitfalls)(host));
         return 0;
@@ -3310,11 +3582,12 @@ function comandoAdapter(args) {
     if (sub === 'install') {
         const host = (0, hosts_1.parseHost)(args.posicionais[2]);
         if (!host) {
-            console.error(`host desconhecido: "${args.posicionais[2] ?? ''}". Use: ${hosts_1.ORDEM_DOS_HOSTS.join(' | ')}`);
+            console.error(ma.hostDesconhecido(args.posicionais[2] ?? '', hosts_1.ORDEM_DOS_HOSTS.join(' | ')));
             return 2;
         }
         const carregado = (0, manifest_1.carregarManifesto)();
-        const r = (0, hosts_1.instalarAdaptador)(host, {
+        // RM-061 (F3b, G4): instala no escopo pt-BR; os avisos nascem pelo catalogo e o texto os remonta no locale do comando.
+        const r = (0, locale_1.comLocale)('pt-BR', () => (0, hosts_1.instalarAdaptador)(host, {
             projeto: carregado?.raiz ?? (0, manifest_1.diretorioDoProjeto)(),
             dir: texto(args.opcoes.dir),
             dryRun: args.opcoes['dry-run'] === true,
@@ -3327,11 +3600,13 @@ function comandoAdapter(args) {
             // unico caminho de saida. `;` separa varios, como o resto do CLI ja faz.
             aceitarCatalogo: (texto(args.opcoes['aceitar-catalogo']) ?? '').split(';').map(x => x.trim()).filter(Boolean),
             manterCopia: (texto(args.opcoes['manter-copia']) ?? '').split(';').map(x => x.trim()).filter(Boolean),
-        });
+            // RM-061 (F3a, D1 e D9): o bloco da experiência nasce na língua do dono; na F3b, o texto impresso segue o locale.
+            locale: (0, locale_1.resolverLocale)(carregado?.manifesto.owner?.language).locale,
+        }));
         console.log((0, hosts_1.textoDaInstalacao)(r));
         return r.ok ? 0 : 2;
     }
-    console.error(`subcomando desconhecido: adapter ${sub}`);
+    console.error(ma.subcomandoDesconhecido(sub));
     return 2;
 }
 /**
@@ -3341,7 +3616,8 @@ function comandoAdapter(args) {
  * de zero em qualquer falha, para o CI do kit poder barrar merge sem eval.
  */
 function comandoEval(args) {
-    const catalogo = (0, catalogo_1.exigirCatalogo)((0, manifest_1.carregarManifesto)()?.raiz ?? (0, manifest_1.diretorioDoProjeto)());
+    // RM-047 (P4): o eval so executa o catalogo do proprio pacote, nunca o achado a partir do cwd.
+    const catalogo = (0, catalogo_1.exigirCatalogoDoPacote)((0, manifest_1.carregarManifesto)()?.raiz ?? (0, manifest_1.diretorioDoProjeto)());
     const lista = (v) => {
         const t = texto(v);
         return t ? t.split(',').map((x) => x.trim()).filter(Boolean) : undefined;
@@ -3369,6 +3645,7 @@ function comandoEval(args) {
  * diferente de zero quando reprova, para o agendador do host perceber sem ler texto.
  */
 function comandoAudit(args) {
+    const m = (0, locale_1.msg)().audit;
     if (args.posicionais[1] === 'process') {
         const r = (0, process_audit_1.auditarProcesso)((0, manifest_1.exigirManifesto)(), args.opcoes.registrar === true);
         console.log(JSON.stringify(r, null, 2));
@@ -3382,26 +3659,26 @@ function comandoAudit(args) {
         const bruto = texto(args.opcoes.estagio) ?? texto(args.opcoes.stage);
         const estagio = bruto ? (0, auditoria_1.parseEstagio)(bruto) : carregado?.manifesto.project.stage;
         if (bruto && !estagio) {
-            console.error(`estagio invalido: "${bruto}". Use: nascente | crescendo | maduro`);
+            console.error(m.erro.estagio(bruto));
             return 2;
         }
         const pack = texto(args.opcoes.pack) ?? args.posicionais[2];
         if (pack) {
             const alvo = (0, auditoria_1.parsePack)(pack);
             if (!alvo) {
-                console.error(`pack desconhecido: "${pack}". Use um de: ${auditoria_1.ORDEM_DOS_PACKS.join(', ')}`);
+                console.error(m.erro.pack(pack, auditoria_1.ORDEM_DOS_PACKS.join(', ')));
                 return 2;
             }
             console.log((0, auditoria_1.textoDoPack)(alvo, estagio ?? undefined));
             return 0;
         }
-        console.log(`Packs de auditoria periodica${estagio ? ` (estagio declarado do projeto: ${estagio})` : ''}`);
+        console.log(m.packs.titulo(estagio ?? undefined));
         console.log('');
         console.log((0, auditoria_1.tabelaDePacks)(estagio ?? undefined));
         if (estagio) {
             console.log('');
-            console.log(`Ativos aqui e agora: ${(0, auditoria_1.packsAtivos)(estagio).join(', ')}`);
-            console.log(`Postura: ${(0, auditoria_1.posturaDoPack)(estagio)}`);
+            console.log(m.packs.ativo((0, auditoria_1.packsAtivos)(estagio).join(', ')));
+            console.log(m.packs.postura((0, auditoria_1.posturaDoPack)(estagio)));
         }
         return 0;
     }
@@ -3409,25 +3686,24 @@ function comandoAudit(args) {
         const raiz = (0, manifest_1.carregarManifesto)()?.raiz;
         const templates = (0, auditoria_1.carregarTemplatesDeAuditoria)(raiz);
         const problemas = templates.flatMap((t) => (0, auditoria_1.lintTemplateDeAuditoria)(t));
-        console.log(`Lint dos templates de auditoria${raiz ? ` (projeto ${raiz})` : ' (somente embutidos)'}`);
+        console.log(m.cli.lintTitulo(raiz));
         console.log('');
         for (const p of problemas) {
-            console.log(`  [${p.gravidade}] ${p.template} :: ${p.regra}`);
-            console.log(`           ${p.detalhe}`);
+            console.log(m.cli.lintItem(p.gravidade, p.template, p.regra));
+            console.log(m.cli.lintDetalhe(p.detalhe));
         }
         if (problemas.length === 0)
-            console.log(`  nenhum problema em ${templates.length} template(s)`);
+            console.log(m.cli.lintOk(templates.length));
         console.log('');
-        console.log(`templates: ${templates.length} | erros: ${problemas.filter((p) => p.gravidade === 'erro').length} | ` +
-            `avisos: ${problemas.filter((p) => p.gravidade === 'aviso').length}`);
+        console.log(m.cli.lintResumo(templates.length, problemas.filter((p) => p.gravidade === 'erro').length, problemas.filter((p) => p.gravidade === 'aviso').length));
         return problemas.some((p) => p.gravidade === 'erro') ? 2 : 0;
     }
     const carregado = (0, manifest_1.exigirManifesto)();
     if (sub === 'run') {
         const pack = (0, auditoria_1.parsePack)(args.posicionais[2]);
         if (!pack) {
-            console.error('uso: ork audit run <pack> [--profile P] [--since Nd]');
-            console.error(`  packs: ${auditoria_1.ORDEM_DOS_PACKS.join(', ')}`);
+            console.error(m.uso('run'));
+            console.error(m.cli.packs(auditoria_1.ORDEM_DOS_PACKS.join(', ')));
             return 2;
         }
         const autorizar = args.opcoes.agora;
@@ -3442,15 +3718,15 @@ function comandoAudit(args) {
             forcar: args.opcoes.forcar === true || args.opcoes.force === true,
         });
         if (r.status === 'bloqueada') {
-            console.error(`Rodada de auditoria ${r.id} BLOQUEADA.`);
+            console.error(m.cli.bloqueada(r.id));
             console.error(`  ${auditoria_1.DESCRICAO_DO_MOTIVO_DE_AUDITORIA[r.motivo ?? 'runtime.unavailable']}`);
-            console.error(`  motivo tipado: ${r.motivo}`);
-            console.error(`  detalhe: ${r.detalhe}`);
-            console.error(`  estado da rodada: .orkastery/audits/${r.id}/run.json`);
+            console.error(m.cli.motivo(String(r.motivo)));
+            console.error(m.cli.detalhe(r.detalhe));
+            console.error(m.cli.estado(r.id));
             return 1;
         }
         if (r.status === 'ensaio') {
-            console.log(`Simulacao (--dry-run) da rodada ${r.id}: nada foi despachado.`);
+            console.log(m.cli.ensaio(r.id));
             console.log(`  pack        ${r.pack} (postura ${r.postura} no estagio ${r.estagio})`);
             console.log(`  escopo      ${r.escopo.detalhe}`);
             console.log(`  graphify    ${r.escopo.graphify}`);
@@ -3459,11 +3735,11 @@ function comandoAudit(args) {
             console.log(`  comando     claude --bg "<prompt>" --name ${r.slug} --model ${r.custo.model} --effort ${r.custo.effort}`);
             if (r.superficie) {
                 console.log(`  superficie  ${r.superficie.detalhe}`);
-                console.log(`              nada registrado no board (--dry-run). Para gravar: ork audit surface --registrar ${r.id}`);
+                console.log(m.cli.superficieDry(r.id));
             }
             return 0;
         }
-        console.log(`Rodada de auditoria ${r.id} despachada pelo runtime adapter ${r.runtime}.`);
+        console.log(m.cli.despachada(r.id, r.runtime));
         console.log(`  pack        ${r.pack} (${auditoria_1.PACKS[r.pack].titulo})`);
         console.log(`  produto     ${r.produto} (perfil ${r.perfil}), estagio ${r.estagio}, postura ${r.postura}`);
         console.log(`  escopo      ${r.escopo.detalhe}`);
@@ -3472,29 +3748,29 @@ function comandoAudit(args) {
         console.log(`  janela      ${r.custo.janela.detalhe}`);
         console.log(`  sessionId   ${r.sessionId}`);
         console.log(`  prompt      ${r.promptPath} (sha256 ${r.promptSha256})`);
-        console.log(`  verificada no runtime: ${r.verificada ? 'sim' : 'NAO (confira `ork sessions`)'}`);
+        console.log(m.cli.verificada(r.verificada));
         if (r.superficie) {
             console.log(`  superficie  ${r.superficie.detalhe}`);
-            console.log(`              ${r.superficie.registrados} achado(s) de superficie ja no board de divida` +
-                (r.superficie.aConfirmar > 0
-                    ? `, ${r.superficie.aConfirmar} com confianca baixa (pedem confirmacao humana)`
-                    : ''));
+            console.log(m.cli.superficieBoard(r.superficie.registrados, r.superficie.aConfirmar));
         }
         console.log('');
-        console.log('A rodada termina em PROPOSTA para o roadmap, nunca em correcao aplicada.');
-        console.log(`Depois dos achados: ork audit verify ${r.id} && ork audit report ${r.id}`);
+        console.log(m.cli.proposta);
+        console.log(m.cli.depois(r.id));
         return r.verificada ? 0 : 1;
     }
     if (sub === 'list') {
         console.log((0, auditrun_1.tabelaDeRodadas)(carregado.raiz));
         console.log('');
-        console.log(`Board de divida: ${(0, auditrun_1.resumoDoBoard)(carregado.raiz)}`);
+        console.log(m.cli.board((0, auditrun_1.resumoDoBoard)(carregado.raiz)));
         return 0;
     }
     if (sub === 'show') {
+        const sobra = SOBRAS_DO_OBJECTIVE.find((opcao) => args.opcoes[opcao] !== undefined);
+        if (sobra)
+            return recusarSobraDoObjective(sobra);
         const id = args.posicionais[2];
         if (!id) {
-            console.error('uso: ork audit show <rodada> [--ledger]');
+            console.error(m.uso('show'));
             return 2;
         }
         if (args.opcoes.ledger === true) {
@@ -3507,8 +3783,8 @@ function comandoAudit(args) {
     if (sub === 'prompt') {
         const pack = (0, auditoria_1.parsePack)(args.posicionais[2]);
         if (!pack) {
-            console.error('uso: ork audit prompt <pack> [--since Nd]');
-            console.error(`  packs: ${auditoria_1.ORDEM_DOS_PACKS.join(', ')}`);
+            console.error(m.uso('prompt'));
+            console.error(m.cli.packs(auditoria_1.ORDEM_DOS_PACKS.join(', ')));
             return 2;
         }
         const { raiz, manifesto } = carregado;
@@ -3541,16 +3817,16 @@ function comandoAudit(args) {
         const id = args.posicionais[2];
         const arquivo = texto(args.opcoes.arquivo) ?? texto(args.opcoes.file);
         if (!id || !arquivo) {
-            console.error('uso: ork audit ingest <rodada> --arquivo <achados.json>');
+            console.error(m.uso('ingest'));
             return 2;
         }
         const r = (0, auditrun_1.ingerirAchados)(carregado, id, arquivo);
-        console.log(`Ingestao da rodada ${r.rodada}: ${r.registrados.length} achado(s) no board de divida.`);
+        console.log(m.cli.ingestao(r.rodada, r.registrados.length));
         // Bloco B6: cada proposta enderecada ao roadmap tambem vai para a colecao `roadmap`.
         if (r.registrados.length > 0) {
             const naMemoria = (0, memoria_1.publicarPropostas)(carregado, r.registrados);
             if (naMemoria.regime === 'orkmind') {
-                console.log(`Memoria (orkmind): propostas na colecao roadmap, ${naMemoria.detalhe}.`);
+                console.log(m.cli.memoriaMuitas(naMemoria.detalhe));
             }
         }
         for (const a of r.registrados) {
@@ -3558,18 +3834,17 @@ function comandoAudit(args) {
         }
         if (r.duplicados.length > 0) {
             console.log('');
-            console.log('Ja registrados nesta rodada, ignorados (a ingestao e idempotente): ' +
-                r.duplicados.map((a) => a.id).join(', '));
+            console.log(m.cli.duplicados(r.duplicados.map((a) => a.id).join(', ')));
         }
         if (r.recusados.length > 0) {
             console.log('');
-            console.error(`RECUSADOS (${r.recusados.length}):`);
+            console.error(m.cli.recusados(r.recusados.length));
             for (const rec of r.recusados) {
-                console.error(`  achado #${rec.indice + 1}: ${rec.erro}`);
+                console.error(m.cli.recusado(rec.indice + 1, rec.erro));
             }
         }
         console.log('');
-        console.log(`Prove os achados antes de qualquer thread: ork audit verify ${r.rodada}`);
+        console.log(m.cli.prove(r.rodada));
         return r.recusados.length > 0 ? 1 : 0;
     }
     if (sub === 'finding' || sub === 'achado') {
@@ -3594,11 +3869,11 @@ function comandoAudit(args) {
                 irreversivel: texto(args.opcoes.irreversivel) ?? 'nenhum',
                 estimativa: texto(args.opcoes.estimativa),
             });
-            console.log(`Achado ${achado.id} registrado no board de divida da rodada ${id}.`);
+            console.log(m.cli.achadoRegistrado(achado.id, id));
             console.log((0, divida_1.textoDoAchado)(achado));
             const naMemoria = (0, memoria_1.publicarPropostas)(carregado, [achado]);
             if (naMemoria.regime === 'orkmind') {
-                console.log(`Memoria (orkmind): proposta na colecao roadmap, ${naMemoria.detalhe}.`);
+                console.log(m.cli.memoriaUma(naMemoria.detalhe));
             }
             return 0;
         }
@@ -3610,66 +3885,66 @@ function comandoAudit(args) {
                 return 2;
             }
             if (estado === 'virou-thread') {
-                console.error('o estado `virou-thread` e carimbado pelo proprio `ork thread new --from-finding`.');
+                console.error(m.cli.estadoReservado);
                 return 2;
             }
             const achado = (0, divida_1.exigirAchado)(carregado.raiz, id);
             const atualizado = (0, divida_1.carimbarAchado)(carregado.raiz, achado, { estado });
-            console.log(`Achado ${atualizado.id} agora esta ${atualizado.estado}.`);
+            console.log(m.cli.achadoEstado(atualizado.id, atualizado.estado));
             console.log((0, divida_1.textoDoAchado)(atualizado));
             return 0;
         }
-        console.error(`subcomando desconhecido: audit finding ${acao ?? ''}`);
+        console.error(m.cli.findingDesconhecido(acao ?? ''));
         return 2;
     }
     if (sub === 'verify') {
         const id = args.posicionais[2];
         if (!id) {
-            console.error('uso: ork audit verify <rodada>');
+            console.error(m.uso('verify'));
             return 2;
         }
         const v = (0, auditrun_1.verificarRodada)(carregado, id);
-        console.log(`Claims dos achados da rodada ${v.rodada}, reexecutadas no HEAD real.`);
-        console.log(`  HEAD real   ${v.commit}`);
-        console.log(`  diretorio   ${v.cwd}`);
+        console.log(m.cli.verifyTitulo(v.rodada));
+        console.log(m.cli.verifyHead(v.commit));
+        console.log(m.cli.verifyDir(v.cwd));
         console.log('');
         if (v.resultados.length === 0) {
-            console.log('  (nenhum achado aberto nesta rodada)');
+            console.log(m.cli.verifyVazio);
         }
         for (const r of v.resultados) {
-            console.log(`  ${r.claim.id}  verificado: ${r.verificado ? 'sim' : 'NAO'}  ${r.claim.alegacao}`);
-            console.log(`      arquivo: ${r.claim.arquivo}`);
-            console.log(`      ${r.claim.verificar.length > 0 ? `comando(s): ${r.claim.verificar.join(' && ')}` : 'sem comando de verificacao'}`);
+            console.log(m.cli.verifyClaim(r.claim.id, r.verificado, r.claim.alegacao));
+            console.log(m.cli.arquivo(r.claim.arquivo));
+            console.log(r.claim.verificar.length > 0 ? m.cli.comandos(r.claim.verificar.join(' && ')) : m.cli.semComando);
             if (!r.verificado)
-                console.log(`      motivo tipado: ${r.motivo} (${r.detalhe})`);
+                console.log(m.cli.motivoDetalhe(String(r.motivo), r.detalhe));
         }
         console.log('');
         console.log(v.ok
-            ? 'Veredito: ACHADOS SUSTENTADOS (o auditor provou o que alegou).'
-            : `Veredito: REPROVADO. Motivos tipados: ${v.motivos.join(', ')}`);
+            ? m.cli.vereditoOk
+            : m.cli.vereditoRuim(v.motivos.join(', ')));
         if (v.motivos.includes('claims.unverifiable')) {
-            console.log('  aviso: achado sem comando de verificacao avisa e nao bloqueia (regra do gate do B1).');
+            console.log(m.cli.unverifiable);
         }
         return v.ok ? 0 : 1;
     }
     if (sub === 'report' || sub === 'relatorio') {
         const id = args.posicionais[2];
         if (!id) {
-            console.error('uso: ork audit report <rodada> [--publicar]');
+            console.error(m.uso('report'));
             return 2;
         }
         const r = (0, auditrun_1.relatorioDaRodada)(carregado, id, { publicar: args.opcoes.publicar === true });
         console.log(r.texto);
-        console.log(`(relatorio gravado em ${r.caminho})`);
+        console.log(m.cli.relatorio(r.caminho));
         if (r.publicado)
-            console.log(`(publicado em ${r.publicado})`);
+            console.log(m.cli.publicado(r.publicado));
         return 0;
     }
     if (sub === 'divida' || sub === 'board') {
         const bruto = texto(args.opcoes.pack);
         const pack = bruto ? (0, auditoria_1.parsePack)(bruto) : undefined;
         if (bruto && !pack) {
-            console.error(`pack desconhecido: "${bruto}". Use um de: ${auditoria_1.ORDEM_DOS_PACKS.join(', ')}`);
+            console.error(m.erro.pack(bruto, auditoria_1.ORDEM_DOS_PACKS.join(', ')));
             return 2;
         }
         console.log((0, divida_1.tabelaDaDivida)(carregado.raiz, {
@@ -3685,14 +3960,14 @@ function comandoAudit(args) {
     if (sub === 'surface' || sub === 'superficie') {
         const bruta = texto(args.opcoes.regra);
         if (bruta && !superficie_1.REGRAS_DE_SUPERFICIE.includes(bruta.toUpperCase())) {
-            console.error(`regra desconhecida: "${bruta}". Use uma de: ${superficie_1.REGRAS_DE_SUPERFICIE.join(', ')}`);
+            console.error(m.erro.regra(bruta, superficie_1.REGRAS_DE_SUPERFICIE.join(', ')));
             return 2;
         }
         const regra = bruta ? bruta.toUpperCase() : undefined;
         const limiteBruto = texto(args.opcoes.limite);
         const limite = limiteBruto ? Number(limiteBruto) : undefined;
         if (limite !== undefined && (!Number.isFinite(limite) || limite < 1)) {
-            console.error(`--limite invalido: "${limiteBruto}". Use um inteiro >= 1.`);
+            console.error(m.erro.limite(limiteBruto ?? ''));
             return 2;
         }
         const rodadaAlvo = texto(args.opcoes.registrar);
@@ -3700,17 +3975,17 @@ function comandoAudit(args) {
             const r = (0, auditrun_1.varrerSuperficieDaRodada)(carregado, rodadaAlvo, { registrar: true, limitePorRegra: limite });
             console.log((0, superficie_1.textoDaVarredura)(r.resultado));
             console.log('');
-            console.log(`Rodada ${r.rodada}: ${r.registrados.length} achado(s) registrado(s) no board de divida.`);
+            console.log(m.cli.rodadaRegistrada(r.rodada, r.registrados.length));
             for (const a of r.registrados)
                 console.log(`  ${a.id}  ${a.regra}  ${a.arquivo}:${a.linha}  ${a.titulo}`);
             if (r.duplicados.length > 0) {
-                console.log(`  ja registrados nesta rodada: ${r.duplicados.map((a) => a.id).join(', ')}`);
+                console.log(m.cli.jaRegistrados(r.duplicados.map((a) => a.id).join(', ')));
             }
             for (const rec of r.recusados) {
-                console.error(`  RECUSADO ${rec.achado.regra} ${rec.achado.arquivo}:${rec.achado.linha}: ${rec.erro}`);
+                console.error(m.cli.recusadoSuperficie(rec.achado.regra, rec.achado.arquivo, rec.achado.linha, rec.erro));
             }
             console.log('');
-            console.log(`Prove os achados antes de qualquer thread: ork audit verify ${r.rodada}`);
+            console.log(m.cli.prove(r.rodada));
             if (r.recusados.length > 0)
                 return 1;
             return r.registrados.length > 0 ? 1 : 0;
@@ -3729,7 +4004,7 @@ function comandoAudit(args) {
         // Codigo != 0 com achado: o agendador do host percebe a superficie aberta sem ler texto.
         return resultado.achados.length > 0 ? 1 : 0;
     }
-    console.error(`subcomando desconhecido: audit ${sub}`);
+    console.error(m.uso(sub));
     return 2;
 }
 /** Roteia o comando. Devolve o codigo de saida do processo. */
@@ -3740,8 +4015,9 @@ function comandoAudit(args) {
  * que sempre teve. E o que garante que ligar o B6 nao muda o que o builder ja conhece.
  */
 function relatarPublicacao(r) {
+    const m = (0, locale_1.msg)().thread;
     if (r.publicacao?.estado === 'pendente') {
-        console.log(`Memoria: publicacao pendente (${r.publicacao.motivo}); ativacao explicita necessaria.`);
+        console.log(m.publicacaoPendente(`${r.publicacao.motivo}`));
         return;
     }
     if (r.regime !== 'orkmind')
@@ -3754,9 +4030,9 @@ function relatarPublicacao(r) {
         r.roadmap?.ok ? '1 roadmap' : '',
     ].filter((t) => t !== '');
     console.log('');
-    console.log(`Memoria (orkmind, tenant ${r.estado.tenant}): ${gravados.join(', ') || 'nada a gravar'}.`);
+    console.log(m.memoriaGravada(`${r.estado.tenant}`, gravados.join(', ') || m.nadaAGravar));
     if (r.falhas > 0)
-        console.log(`  ${r.falhas} gravacao(oes) nao concluida(s); veja ork memory status.`);
+        console.log(m.gravacoesFalhas(r.falhas));
 }
 /** Janela de origem e corte de apresentação são inteiros positivos explícitos. */
 function limiteDeLeitura(valor) {
@@ -3772,19 +4048,19 @@ function comandoRecall(args) {
     const carregado = (0, project_state_1.memoryState)((0, manifest_1.exigirManifesto)()).loaded;
     const id = args.posicionais[1];
     if (!id) {
-        console.error('uso: ork recall <thread-id> [--fase FASE] [--id ptr-N] [--todos] [--forcar]');
+        console.error((0, locale_1.msg)().operacao.restante.recall.uso);
         return 2;
     }
     const thread = (0, thread_1.lerThread)(carregado.raiz, id);
     const faseBruta = texto(args.opcoes.fase) ?? texto(args.opcoes.momento);
     const momento = faseBruta ? (0, thread_1.exigirFase)(thread, faseBruta) : undefined;
     const memoria = (0, memoria_1.abrirMemoria)(carregado, { leituraRestrita: { thread: id, limite: limiteDeLeitura(args.opcoes.janela) } });
-    const r = (0, recall_1.recallDaThread)(carregado, memoria, id, {
+    const r = (0, locale_1.comLocale)('pt-BR', () => (0, recall_1.recallDaThread)(carregado, memoria, id, {
         momento,
         id: texto(args.opcoes.id),
         todos: args.opcoes.todos === true,
         forcar: args.opcoes.forcar === true,
-    });
+    }));
     if (args.opcoes.json === true) {
         console.log(JSON.stringify(r, null, 2));
     }
@@ -3799,15 +4075,16 @@ function comandoMemory(args) {
     const candidate = (0, manifest_1.exigirManifesto)();
     const carregado = (0, project_state_1.memoryState)(candidate).loaded;
     const sub = args.posicionais[1] ?? 'status';
+    const mm = (0, locale_1.msg)().operacao.restante.memory.cli;
     const escopo = texto(args.opcoes.escopo)?.split(',').map(s => s.trim());
     if (sub === 'inventory' || (sub === 'migrate' && args.opcoes['dry-run'] === true)) {
         const r = (0, memory_migration_1.inventariarHandoffs)(carregado, escopo);
         if (args.opcoes.json === true)
             console.log(JSON.stringify(r, null, 2));
         else {
-            console.log(`Inventario do tenant ${r.tenant}: ${r.incluidos} incluidos, ${r.excluidos} excluidos.`);
+            console.log(mm.inventario(r.tenant, r.incluidos, r.excluidos));
             for (const f of r.fontes)
-                console.log(`  ${f.incluir ? 'incluir' : 'excluir'} ${f.arquivo}: ${f.motivo}`);
+                console.log(mm.fonte(f.incluir, f.arquivo, f.motivo));
         }
         return r.fontes.some(f => f.bloqueante) ? 1 : 0;
     }
@@ -3824,7 +4101,7 @@ function comandoMemory(args) {
         if (args.opcoes.json === true)
             console.log(JSON.stringify(r, null, 2));
         else {
-            console.log(`Migracao do tenant ${r.inventario.tenant}: ${r.resultados.filter(i => i.ok).length} confirmados, ${r.falhas} falhas, ${r.inventario.excluidos} excluidos.`);
+            console.log(mm.migracao(r.inventario.tenant, r.resultados.filter(i => i.ok).length, r.falhas, r.inventario.excluidos));
             for (const item of r.resultados)
                 console.log(`  ${item.arquivo}: ${item.ok ? item.gravacao?.id : item.erro}`);
         }
@@ -3865,13 +4142,13 @@ function comandoMemory(args) {
                 const motivo = error instanceof Error
                     ? /^(?:write\.activation|scope|memory)\.[a-z.-]+/.exec(error.message)?.[0] ?? 'write.activation.invalid'
                     : 'write.activation.invalid';
-                const detalhe = 'sync nao executado; colisao legada nao foi reavaliada';
+                const detalhe = (0, locale_1.comLocale)('pt-BR', () => (0, locale_1.textoDoCatalogo)(m => m.operacao.restante.memory.cli.syncDetalhe));
                 if (args.opcoes.json === true)
                     console.log(JSON.stringify({
                         regime: memoria.regime, estado: memoria.estado, thread: threadId ?? null, perfil,
                         publicacao: { estado: 'pendente', motivo }, falhas: 1, gravadas: [], erro: motivo, detalhe,
                     }, null, 2));
-                console.error(`${motivo}: ${detalhe}`);
+                console.error(`${motivo}: ${(0, locale_1.remontar)(detalhe)}`);
                 return 1;
             }
         }
@@ -3895,7 +4172,7 @@ function comandoMemory(args) {
         const janela = limiteDeLeitura(args.opcoes.janela);
         const tagsBrutas = texto(args.opcoes.tags);
         if (!tagsBrutas) {
-            console.error('uso: ork memory search --tags \'{"project":["orkastery"],"skill":["orkastery-decision"]}\'');
+            console.error(mm.tagsUso);
             return 2;
         }
         let tags;
@@ -3903,7 +4180,7 @@ function comandoMemory(args) {
             tags = JSON.parse(tagsBrutas);
         }
         catch (e) {
-            console.error(`--tags nao e JSON valido: ${e.message}`);
+            console.error(mm.tagsInvalidas(e.message));
             return 2;
         }
         const colecao = texto(args.opcoes.colecao) ?? texto(args.opcoes.collection);
@@ -3920,16 +4197,16 @@ function comandoMemory(args) {
             limite,
         });
         if (threadId && memoria.regime === 'files')
-            console.error(`memory.query.files: ${memoria.estado.motivo}; resultado nao comprova ausencia na memoria semantica`);
+            console.error(mm.files(`${memoria.estado.motivo}`));
         if (args.opcoes.json === true) {
             console.log(JSON.stringify(entradas, null, 2));
             return 0;
         }
-        console.log(`Busca deterministica por tag (regime ${memoria.regime})`);
+        console.log(mm.buscaTag(memoria.regime));
         console.log('');
         if (memoria.regime === 'files') {
             console.log(`  ${memoria.estado.detalhe}`);
-            console.log(`  correcao: ${memoria.estado.correcao}`);
+            console.log(mm.correcao(memoria.estado.correcao));
             return 0;
         }
         for (const e of entradas) {
@@ -3937,13 +4214,13 @@ function comandoMemory(args) {
             console.log(`      ${e.content.split('\n')[0].slice(0, 100)}`);
         }
         console.log('');
-        console.log(`  ${entradas.length} entrada(s)`);
+        console.log(mm.entradas(entradas.length));
         return 0;
     }
     if (sub === 'index') {
         const modelo = texto(args.opcoes.modelo) ?? 'primario';
         if (!['primario', 'fallback', 'todos'].includes(modelo)) {
-            console.error('uso: ork memory index [--modelo primario|fallback|todos] [--dry-run] [--json]');
+            console.error(mm.indexUso);
             return 2;
         }
         const memoria = (0, memoria_1.abrirMemoria)(carregado);
@@ -3952,7 +4229,7 @@ function comandoMemory(args) {
             if (args.opcoes.json === true)
                 console.log(JSON.stringify(falha, null, 2));
             else
-                console.error(`memory.index: regime ${memoria.regime} (${memoria.estado.motivo}); ${memoria.estado.correcao}`);
+                console.error(mm.indexFalha(memoria.regime, `${memoria.estado.motivo}`, memoria.estado.correcao));
             return 1;
         }
         const config = (0, manifest_1.configDeEmbedding)(carregado.manifesto);
@@ -3965,11 +4242,11 @@ function comandoMemory(args) {
         }
         catch (erro) {
             const motivo = (0, indice_vetorial_1.codigoDaFalha)(erro);
-            const detalhe = 'o universo da busca nao foi lido inteiro; nada foi embedado';
+            const detalhe = mm.universoDetalhe;
             if (args.opcoes.json === true)
                 console.log(JSON.stringify({ motivo, detalhe }, null, 2));
             else
-                console.error(`memory.index: ${motivo}; ${detalhe}`);
+                console.error(mm.universoFalhou(motivo, detalhe));
             return 1;
         }
         const alvos = modelo === 'todos' ? ['primario', 'fallback'] : [modelo];
@@ -3988,7 +4265,7 @@ function comandoMemory(args) {
         }
         return resultados.some(r => !r.dryRun && r.motivo) ? 1 : 0;
     }
-    console.error(`subcomando desconhecido: memory ${sub}`);
+    console.error(mm.desconhecido(sub));
     return 2;
 }
 /** Aviso informativo: não consulta rede, não reserva e não bloqueia criação. */
@@ -3996,17 +4273,18 @@ function avisoRoadmapSemAssociacao(nome, roadmap) {
     const item = /\bRM-\d{3}\b/i.exec(nome)?.[0].toUpperCase();
     if (!item || roadmap)
         return null;
-    return `Aviso: ${item} no nome não associa a thread ao roadmap. No terminal, consulte ork roadmap reservas e ork fabrica; para associar e reservar, use --roadmap ${item} em ork thread new. Nenhuma reserva foi criada por este aviso.`;
+    return (0, locale_1.msg)().thread.roadmapNoNome(item);
 }
 /**
  * `ork memory search --texto` (I-38 D7): busca por significado, separada da busca por tag.
  * Nao combina com --tags nem com a leitura restrita por thread nesta versao (erro tipado).
  */
 function buscaPorTexto(args, carregado) {
+    const mm = (0, locale_1.msg)().operacao.restante.memory.cli;
     const frase = texto(args.opcoes.texto);
     if (args.opcoes.tags !== undefined || args.opcoes.thread !== undefined || args.opcoes.restrito !== undefined ||
         args.opcoes.janela !== undefined) {
-        console.error('memory.search.texto-exclusivo: --texto nao combina com --tags, --thread, --restrito nem --janela');
+        console.error(mm.textoExclusivo);
         return 2;
     }
     const modo = (texto(args.opcoes.modo) ?? 'hibrido');
@@ -4016,7 +4294,7 @@ function buscaPorTexto(args, carregado) {
     if (!(0, orkmind_1.textoDeBuscaValido)(frase) || !busca_semantica_1.MODOS_DE_BUSCA.includes(modo) ||
         (colecao !== undefined && !orkmind_1.COLECOES_DO_ORK.includes(colecao)) ||
         !Number.isInteger(limite) || limite < 1 || limite > busca_semantica_1.LIMITE_MAXIMO_DA_BUSCA) {
-        console.error(`uso: ork memory search --texto "<frase>" [--modo ${busca_semantica_1.MODOS_DE_BUSCA.join('|')}] [--colecao ${orkmind_1.COLECOES_DO_ORK.join('|')}] [--limite 1..${busca_semantica_1.LIMITE_MAXIMO_DA_BUSCA}] [--json]`);
+        console.error(mm.textoUso(busca_semantica_1.MODOS_DE_BUSCA.join('|'), orkmind_1.COLECOES_DO_ORK.join('|'), busca_semantica_1.LIMITE_MAXIMO_DA_BUSCA));
         return 2;
     }
     const memoria = (0, memoria_1.abrirMemoria)(carregado);
@@ -4039,7 +4317,7 @@ function buscaPorTexto(args, carregado) {
     }
     else if (!universo) {
         // RM-038: sem o universo inteiro nao ha busca; o motivo tipado sai, nunca um resultado parcial.
-        r = { ...vazio, motivo: falhaDoUniverso, detalhe: 'o universo da busca nao foi lido inteiro; nada foi buscado' };
+        r = { ...vazio, motivo: falhaDoUniverso, detalhe: mm.buscaUniversoDetalhe };
     }
     else {
         const driver = (0, orkmind_1.configDoManifesto)(carregado.manifesto);
@@ -4087,25 +4365,60 @@ function extrairOpcaoDeProjeto(argv) {
     return { argv: resto, projeto };
 }
 /** Comandos que nao leem projeto: o alvo nao e resolvido (nem recusado) para eles. */
-const COMANDOS_SEM_PROJETO = new Set(['demo', 'ciclos', 'mcp', 'init', 'projetos']);
+// RM-062 (F1): `privado varrer` le o repositorio do diretorio atual (o checkout do CI, o clone de um site), nao o alvo.
+const COMANDOS_SEM_PROJETO = new Set(['demo', 'ciclos', 'mcp', 'init', 'projetos', 'privado']);
+/**
+ * Fatia 2 (D3): os comandos que leem projeto e nao terminam com a linha `Projeto consultado`. Hoje so
+ * o `sessions event`, o sensor dos hooks do Claude Code: maquina falando com maquina, e o sensor compara
+ * o stderr da recusa. O `maestro` declara no snapshot e nao passa por aqui.
+ */
+const SEM_DECLARACAO_DO_PROJETO = new Set(['sessions event']);
 /**
  * Comandos cujo `--projeto` e DELES (RM-054: `ork network roadmap --projeto github:dono/repo`, que
  * le varios projetos). A opcao volta intacta ao argv do subcomando e o alvo global nao e resolvido:
  * nem `--projeto`, nem `ORK_PROJETO`, nem o modo host escolhem um projeto por eles.
  */
 exports.COMANDOS_COM_PROJETO_PROPRIO = new Set(['network']);
-/** Resolve e fixa o projeto-alvo do processo (D2, D3). `null`: vale o cwd de sempre. */
-function fixarAlvoDoProcesso(projeto) {
+/**
+ * Resolve e fixa o projeto-alvo do processo (D2, D3). `null`: vale o cwd de sempre. Fatia 2 (D3): com
+ * `declarar`, o comando termina dizendo qual projeto leu, quando o leitor nao tem como saber.
+ */
+function fixarAlvoDoProcesso(projeto, declarar = true) {
     const alvo = (0, projeto_alvo_1.resolverProjetoAlvo)({ opcao: projeto ?? null });
     (0, projeto_alvo_1.fixarProjetoAlvo)(alvo);
+    if (declarar)
+        (0, projeto_alvo_1.pedirDeclaracaoDoProjeto)(alvo);
     return alvo;
 }
+/**
+ * RM-052 (fatia 2, D3): o comando que leu um projeto que o leitor nao tem como adivinhar (no host, ou
+ * fora do diretorio dele) escreve no fim a linha `Projeto consultado: ...` no stderr, salvo se ja montou
+ * o proprio cabecalho. Quando ele falha, a linha sai antes da mensagem de erro, que a entrada imprime.
+ */
 function main(argvBruto) {
     // I-35: todo horário para pessoa sai no fuso do dono deste projeto (lido só se for preciso, e já
     // depois de o projeto-alvo abaixo estar fixado: a fonte é preguiçosa).
     (0, horario_1.registrarFonteDoFuso)(() => (0, horario_1.fusoDoManifesto)((0, manifest_1.carregarManifesto)()));
     // RM-052: sem alvo herdado de uma chamada anterior no mesmo processo (os testes chamam `main` em serie).
     (0, projeto_alvo_1.fixarProjetoAlvo)(null);
+    // Prova de conceito do CLI por locale: cada chamada comeca em pt-BR; so os comandos cobertos trocam.
+    (0, locale_1.ativarLocale)(undefined);
+    // RM-061 (F2b, D1): e sem o registro dos textos remontaveis, que so os comandos cobertos ligam.
+    (0, locale_1.ligarRemontagem)(false);
+    (0, projeto_alvo_1.iniciarDeclaracaoDoProjeto)();
+    try {
+        return executarComando(argvBruto);
+    }
+    finally {
+        // RM-061 (F2b): o registro dos textos remontaveis nao sobrevive a chamada (o locale sim: a entrada do CLI
+        // ainda imprime o erro no locale do comando).
+        (0, locale_1.ligarRemontagem)(false);
+        const linha = (0, projeto_alvo_1.declaracaoQueFaltou)();
+        if (linha)
+            console.error(linha);
+    }
+}
+function executarComando(argvBruto) {
     const extraida = extrairOpcaoDeProjeto(argvBruto);
     const proprio = exports.COMANDOS_COM_PROJETO_PROPRIO.has(parseArgs(extraida.argv).posicionais[0] ?? '');
     const argv = proprio && extraida.projeto !== undefined
@@ -4132,8 +4445,9 @@ function main(argvBruto) {
     if (argv[0] === 'maestro') {
         if (argv.length === 2 && argv[1] === '--help')
             return (0, maestro_cli_1.runMaestroCli)(argv.slice(1));
-        // RM-052: o alvo explicito vira SELECAO entre as raizes permitidas; sem ele, o cwd de sempre.
-        const alvo = fixarAlvoDoProcesso(projeto);
+        // RM-052: o alvo explicito vira SELECAO entre as raizes permitidas; sem ele, o cwd de sempre. O
+        // snapshot ja declara o projeto consultado (project.root, notConsulted): sem a linha da fatia 2.
+        const alvo = fixarAlvoDoProcesso(projeto, false);
         return alvo ? (0, maestro_cli_1.runMaestroCli)(argv.slice(1), alvo.raiz, { allowedRoots: [alvo.raiz], selected: alvo.raiz })
             : (0, maestro_cli_1.runMaestroCli)(argv.slice(1));
     }
@@ -4145,11 +4459,13 @@ function main(argvBruto) {
         return 0;
     }
     if (!comando || args.opcoes.help === true || comando === 'help') {
-        console.log(AJUDA);
+        (0, locale_1.ativarLocale)(localeDaAjuda(projeto));
+        console.log((0, locale_1.msg)().ajuda.texto(dadosDaAjuda()));
         return 0;
     }
-    if (!COMANDOS_SEM_PROJETO.has(comando) && !proprio)
-        fixarAlvoDoProcesso(projeto);
+    if (!COMANDOS_SEM_PROJETO.has(comando) && !proprio) {
+        fixarAlvoDoProcesso(projeto, !SEM_DECLARACAO_DO_PROJETO.has(`${comando} ${args.posicionais[1] ?? ''}`.trim()));
+    }
     else if (projeto !== undefined && comando !== 'projetos') {
         throw new Error(comando === 'init'
             ? 'uso: ork init cria o projeto no diretório atual; entre nele e rode ork init, sem --projeto'
@@ -4167,33 +4483,46 @@ function main(argvBruto) {
             for (const nome of runtime_ambiente_1.ENVS_DE_PROVIDER_PAGO)
                 delete process.env[nome];
     }
+    // CLI por locale (RM-061, EN1 e EN7): a escolha do onboarding (owner.language) ou o LC_ALL/LC_MESSAGES/LANG
+    // decidem a lingua do TEXTO dos comandos cobertos (`cobreLocale`); `--json` e contrato, e os recortes ainda
+    // fora do catalogo (`doctor --modo` e os subcomandos fora da lista) ficam em pt-BR.
+    if ((0, locale_1.cobreLocale)(args.posicionais, args.opcoes)) {
+        (0, locale_1.ativarLocale)((0, locale_1.resolverLocale)(ambienteManifesto?.manifesto.owner?.language).locale);
+        (0, locale_1.ligarRemontagem)(true);
+    }
     switch (comando) {
         case 'mcp': {
             const projeto = texto(args.opcoes.project), host = texto(args.opcoes.host), threadId = texto(args.opcoes.thread);
             // I-36 (D4): a identidade do despacho so chega com a thread vinculada da sessao filha.
             const dispatchId = texto(args.opcoes.dispatch);
-            const transporteShip = texto(args.opcoes['ship-transport']) ?? 'github-ssh';
+            const transporteDado = texto(args.opcoes['ship-transport']);
+            const transporteShip = transporteDado ?? 'github-ssh';
+            const impressaoSsh = texto(args.opcoes['ssh-fingerprint']);
             const permissoesFilho = texto(args.opcoes['child-permissions']) ?? 'interactive';
             const permissoesDono = texto(args.opcoes['owner-permissions']);
             const acao = args.posicionais[1];
             if (args.posicionais.length !== 2 || !['serve', 'install'].includes(acao) || !projeto ||
                 (host !== 'codex' && host !== 'claude-code') ||
-                Object.keys(args.opcoes).some(k => !['project', 'host', 'ship-transport', 'child-permissions', ...(acao === 'install' ? ['dry-run', 'owner-permissions'] : ['thread', 'dispatch'])].includes(k)) ||
+                Object.keys(args.opcoes).some(k => !['project', 'host', 'ship-transport', 'child-permissions', ...(acao === 'install' ? ['dry-run', 'owner-permissions', 'ssh-fingerprint'] : ['thread', 'dispatch'])].includes(k)) ||
                 (args.opcoes.dispatch !== undefined && (!threadId || !dispatchId || !/^[a-f0-9-]{36}$/.test(dispatchId))) ||
                 argv.filter(a => a === '--ship-transport' || a.startsWith('--ship-transport=')).length > 1 ||
                 argv.filter(a => a === '--child-permissions' || a.startsWith('--child-permissions=')).length > 1 ||
+                argv.filter(a => a === '--ssh-fingerprint' || a.startsWith('--ssh-fingerprint=')).length > 1 ||
+                (args.opcoes['ssh-fingerprint'] !== undefined && (transporteShip !== 'forja-ssh' || typeof args.opcoes['ssh-fingerprint'] !== 'string' || !/^SHA256:[A-Za-z0-9+/]{43}$/.test(impressaoSsh ?? ''))) ||
                 (args.opcoes['owner-permissions'] !== undefined && (host !== 'codex' || typeof args.opcoes['owner-permissions'] !== 'string' || !['interactive', 'orchestrate'].includes(permissoesDono ?? ''))) ||
                 argv.filter(a => a === '--owner-permissions' || a.startsWith('--owner-permissions=')).length > 1 ||
                 !['interactive', 'worktree'].includes(permissoesFilho) ||
                 (args.opcoes['child-permissions'] !== undefined && typeof args.opcoes['child-permissions'] !== 'string') ||
-                !['github-ssh', 'bare-local'].includes(transporteShip) ||
+                !(0, mcp_transportes_1.ehTransporteShipMcp)(transporteShip) ||
                 (args.opcoes['ship-transport'] !== undefined && typeof args.opcoes['ship-transport'] !== 'string') ||
                 (args.opcoes.thread !== undefined && (!threadId || !/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/.test(threadId))) ||
                 (args.opcoes['dry-run'] !== undefined && args.opcoes['dry-run'] !== true))
-                throw new Error('uso: ork mcp serve|install --project <raiz absoluta> --host codex|claude-code [--ship-transport github-ssh|bare-local] [--child-permissions interactive|worktree] [--owner-permissions interactive|orchestrate somente install Codex] [--dry-run somente install]');
+                throw new Error((0, locale_1.msg)().operacao.restante.mcp.uso);
             if (acao === 'install') {
-                void Promise.resolve().then(() => __importStar(require('./mcp-install'))).then(({ instalarMcp, textoInstalacaoMcp }) => console.log(textoInstalacaoMcp(instalarMcp({ projeto, host, dryRun: args.opcoes['dry-run'] === true, transporteShip: transporteShip, permissoesFilho: permissoesFilho, permissoesDono: permissoesDono }))))
-                    .catch(e => { console.error(`mcp: ${e.message}`); process.exitCode = 1; });
+                void Promise.resolve().then(() => __importStar(require('./mcp-install'))).then(({ instalarMcp, textoInstalacaoMcp }) => console.log(textoInstalacaoMcp(instalarMcp({ projeto, host, dryRun: args.opcoes['dry-run'] === true,
+                    transporteShip: transporteDado === undefined ? undefined : transporteShip, impressaoSsh,
+                    permissoesFilho: permissoesFilho, permissoesDono: permissoesDono }))))
+                    .catch(e => { console.error((0, locale_1.msg)().operacao.restante.mcp.erro(e.message)); process.exitCode = 1; });
                 return 0;
             }
             void Promise.resolve().then(() => __importStar(require('./mcp-server'))).then(({ servirMcp }) => servirMcp({ projeto, host, threadId, dispatchId, nomesProviderHerdados: nomesHerdados, transporteShip: transporteShip, permissoesFilho: permissoesFilho })).catch(e => { console.error(`mcp: ${e.message}`); process.exitCode = 1; });
@@ -4210,40 +4539,60 @@ function main(argvBruto) {
                 return r.prontoPrimeiroBloco ? 0 : 1;
             }
             // RM-031: o check dos analisadores do grafo entra por aqui, a porta da familia do grafo (fronteira do KG1).
-            const r = (0, doctor_1.doctor)((0, manifest_1.diretorioDoProjeto)(), nomesHerdados, () => (0, intelligence_graph_cli_1.checarAnalisadoresDoGrafo)(versao_1.VERSAO_DO_ORK));
+            // RM-061 (F2a): a redacao do check vem do catalogo, no locale do comando (a familia do grafo nao o importa).
+            const analisadores = () => (0, intelligence_graph_cli_1.checarAnalisadoresDoGrafo)(versao_1.VERSAO_DO_ORK, undefined, undefined, (0, locale_1.msg)().doctor.grafo);
+            // `--forja=false` ou `--forja <valor>` nao vira `nao-medida` calado: a flag e booleana.
+            if (args.opcoes.forja !== undefined && args.opcoes.forja !== true) {
+                console.error((0, locale_1.msg)().forja.doctor.flagComValor);
+                return 2;
+            }
+            // RM-063 (fatia 3, H1): `--json` e o contrato `ork.doctor/v1` que a batida do host le, com a idade da batida.
+            if (args.opcoes.json === true) {
+                // A batida dos hosts le o --json com frequencia: a secao forja (rede e CLI) so com --forja.
+                const j = (0, doctor_1.doctorJson)((0, manifest_1.diretorioDoProjeto)(), nomesHerdados, analisadores, undefined, args.opcoes.forja === true ? doctor_forja_1.checarForja : undefined);
+                console.log(JSON.stringify(j.json, null, 2));
+                return j.codigo;
+            }
+            const r = (0, doctor_1.doctor)((0, manifest_1.diretorioDoProjeto)(), nomesHerdados, analisadores, doctor_forja_1.checarForja);
             console.log(r.texto);
             return r.codigo;
         }
         case 'init': {
             (0, init_1.exigirRepositorioParaInit)(process.cwd());
+            // RM-061 (F3a, D1 e D2): os arquivos nascem na lingua do dono no momento da geracao, resolvida pelo manifesto lido
+            // antes do `--force` regrava-lo (o YAML e o AGENTS.md saem na mesma lingua) e independente do texto impresso, que
+            // nao segue o locale com `--json` (GO-FIX do CHECK, W3).
+            const localeDosArquivos = (0, locale_1.resolverLocale)(ambienteManifesto?.manifesto.owner?.language).locale;
             const r = (0, init_1.init)(process.cwd(), {
                 force: args.opcoes.force === true,
                 nome: texto(args.opcoes.name) ?? texto(args.opcoes.nome),
                 abbrev: texto(args.opcoes.abbrev),
+                locale: localeDosArquivos,
             });
             const carregado = (0, manifest_1.exigirManifesto)(r.deteccao.raiz);
-            const agents = (0, agents_md_1.atualizarAgentsMd)(r.deteccao.raiz, carregado.manifesto);
+            const agents = (0, agents_md_1.atualizarAgentsMd)(r.deteccao.raiz, carregado.manifesto, localeDosArquivos);
             // RM-052 (D7): o projeto entra no registro desta maquina; falha vira aviso, nunca derruba o init.
             const avisoDoRegistro = (0, projeto_alvo_1.registrarProjetoEmSilencio)(r.deteccao.raiz, 'init');
             if (avisoDoRegistro)
                 console.error(avisoDoRegistro);
+            const m = (0, locale_1.msg)().init, estadoAgents = m.estadosAgents[agents.estado] ?? agents.estado;
             if (!r.criado) {
-                console.log(`Manifesto ja existe: ${r.caminho}`);
-                console.log('Nada foi sobrescrito. Use --force para regerar.');
-                console.log(`AGENTS.md ${agents.estado}: ${agents.caminho}`);
+                console.log(m.jaExiste(r.caminho));
+                console.log(m.nadaSobrescrito);
+                console.log(m.agentsMd(estadoAgents, agents.caminho));
                 return 0;
             }
-            console.log(`Manifesto criado: ${r.caminho}`);
-            console.log(`  projeto     ${r.deteccao.nome} (abbrev "${r.deteccao.abbrev}")`);
-            console.log(`  branch base ${r.deteccao.baseBranch}`);
-            console.log(`  gerenciador ${r.deteccao.gerenciador}`);
-            console.log(`  verify      ${Object.entries(r.deteccao.verify).map(([k, v]) => `${k}="${v}"`).join(', ') || '(nenhum script detectado)'}`);
-            console.log(`  AGENTS.md   ${agents.estado}: ${agents.caminho}`);
+            console.log(m.criado(r.caminho));
+            console.log(m.projeto(r.deteccao.nome, r.deteccao.abbrev));
+            console.log(m.branchBase(r.deteccao.baseBranch));
+            console.log(m.gerenciador(r.deteccao.gerenciador));
+            console.log(m.verify(Object.entries(r.deteccao.verify).map(([k, v]) => `${k}="${v}"`).join(', ') || m.semScript));
+            console.log(m.agentsMdLinha(estadoAgents, agents.caminho));
             // Fatia 2 do ensaio da 0.5.0 (P3): o estado fica fora do git por um `.gitignore` proprio.
             if (r.estadoIgnorado)
-                console.log(`  estado      ${manifest_1.DIR_ESTADO}/ fora do git (${manifest_1.DIR_ESTADO}/.gitignore com *; o seu .gitignore fica como está)`);
+                console.log(m.estado(manifest_1.DIR_ESTADO));
             console.log('');
-            console.log(init_2.PROXIMO_PASSO_INIT);
+            console.log(m.proximoPasso);
             return 0;
         }
         case 'modos': {
@@ -4267,6 +4616,23 @@ function main(argvBruto) {
                 const carregado = (0, manifest_1.carregarManifesto)();
                 // I-43: `#Look` no pedido nao pode cair no default em silencio. O adaptador
                 // recebe a recusa tipada e saida != 0, e quem escreveu a #TAG fica sabendo.
+                // RM-058 N6 (D1): `#Noctum` é o modo do arco e só vale com envelope vigente; sem ele, recusa tipada, nunca o padrão.
+                if ((0, noctum_modo_1.tagNoctumNoPedido)(pedido)) {
+                    let arcos;
+                    try {
+                        arcos = (0, noctum_modo_1.aceitarModoNoctum)(carregado?.raiz ?? null);
+                    }
+                    catch (e) {
+                        if (e instanceof noctum_envelope_1.RecusaDoArco) {
+                            console.error(e.message);
+                            return 2;
+                        }
+                        throw e;
+                    }
+                    console.log(args.opcoes.json === true ? JSON.stringify({ modo: 'noctum', tag: '#Noctum', daTag: true, origem: 'tag no pedido',
+                        arcos, modoDasThreads: 'auto' }) : 'noctum');
+                    return 0;
+                }
                 const aposentado = (0, modos_1.extrairTagAposentadaDoPedido)(pedido);
                 if (aposentado) {
                     console.error((0, modos_1.recusaDeModoAposentado)(aposentado));
@@ -4311,16 +4677,17 @@ function main(argvBruto) {
             }
             if ((args.posicionais[1] ?? 'show') !== 'show' || args.posicionais.length > 2 ||
                 Object.keys(args.opcoes).some(k => k !== 'json') || ('json' in args.opcoes && args.opcoes.json !== true)) {
-                throw Error('uso: ork experiencia show [--json]');
+                throw Error((0, locale_1.msg)().onboarding.experienciaUso);
             }
             const manifesto = (0, manifest_1.exigirManifesto)(), p = (0, experiencia_1.resolverExperiencia)(manifesto.manifesto.owner);
             // Preferência inválida vale o padrão e faz o adapter install pular o pacote: a consulta avisa.
             const avisos = manifesto.avisos.filter(a => a.startsWith('experiencia.config.invalid'));
+            const m = (0, locale_1.msg)().onboarding;
             console.log(args.opcoes.json ? JSON.stringify({ ...p, avisos }, null, 2) :
-                `Experiência ${p.experience ? 'ativa' : 'desativada'}: ${p.language}, ${p.timezone}, profundidade ${p.depth}.\nSkill: ${p.skill}\n` +
+                `${m.experiencia(p.experience, p.language, p.timezone, p.depth)}\nSkill: ${p.skill}\n` +
                     // Fatia 2 do ensaio da 0.5.0 (R2): as origens em texto, e nao o JSON cru.
-                    `Origens: ${Object.entries(p.origem).map(([chave, origem]) => `${chave} ${origem}`).join(', ')}` +
-                    avisos.map(a => `\nAviso: ${a}; o adapter install pula o pacote até ork onboarding set maestro corrigir.`).join(''));
+                    m.experienciaOrigens(Object.entries(p.origem).map(([chave, origem]) => `${chave} ${m.origemDaPreferencia(origem)}`).join(', ')) +
+                    avisos.map(a => `\n${m.experienciaAviso(m.avisoDaPreferencia(a))}`).join(''));
             return 0;
         }
         case 'thread':
@@ -4337,28 +4704,41 @@ function main(argvBruto) {
             return comandoLedger(args);
         case 'sessions':
             return comandoSessions(args);
+        case 'noctum':
+            // RM-058 N6: a porta do CLI para o arco #Noctum (propor, responder, status, tique e relatorio).
+            return (0, noctum_cli_1.comandoNoctum)(args);
         case 'pulse': {
             if (args.posicionais[1] === 'responder') {
                 // I-41 (GO-FIX 1, B1 e B2): o caminho de volta do resumo. So o ingresso autenticado chama;
                 // argv traz identificadores e o envelope assinado vem por stdin, como no `gate answer`.
                 if (args.opcoes['resposta-stdin'] !== true || args.opcoes.resposta !== undefined || args.posicionais.length !== 2) {
-                    throw new Error('pulse responder exige --resposta-stdin e o envelope do ingresso autenticado');
+                    throw new Error((0, locale_1.msg)().operacao.pulseCadencia.responderUso);
                 }
                 const carregado = (0, manifest_1.exigirManifesto)();
                 const envelope = (0, hitl_gates_1.lerRespostaStdin)({ por: texto(args.opcoes.por), mensagem: texto(args.opcoes.mensagem),
                     origem: texto(args.opcoes.origem), canal: texto(args.opcoes.canal), conta: texto(args.opcoes.conta) });
                 const formato = texto(args.opcoes.formato);
                 if (formato !== undefined && formato !== 'telegram' && formato !== 'terminal')
-                    throw new Error('pulse responder: --formato telegram|terminal');
-                console.log(JSON.stringify((0, pulse_resposta_1.responderPeloPulse)(carregado.raiz, envelope, { canal: formato ?? 'telegram' })));
+                    throw new Error((0, locale_1.msg)().operacao.pulseCadencia.responderFormato);
+                // RM-057 (resposta curta, D3; GO-FIX 1, achado 2): a mensagem respondida (reply), `<código>:<id>`, que o gateway
+                // assinou no endereço do pulse; o núcleo só a aceita quando o id é o da mensagem em que a pergunta foi entregue.
+                // GO-FIX 2 (R1): `outra` é a palavra solta em reply a outra mensagem, que o núcleo recusa dizendo por quê.
+                const referencia = args.opcoes['em-resposta-a'];
+                if (referencia !== undefined && !(0, pulse_consentimento_1.referenciaDoReplyValida)(referencia)) {
+                    throw new Error((0, locale_1.msg)().operacao.pulseCadencia.responderReferencia);
+                }
+                console.log(JSON.stringify((0, pulse_resposta_1.responderPeloPulse)(carregado.raiz, envelope, { canal: formato ?? 'telegram',
+                    ...(typeof referencia === 'string' ? { referencia } : {}) })));
                 return 0;
             }
             if (args.posicionais[1] === 'cadencia')
                 return comandoCadenciaDoPulse(args);
-            const p = (0, pulse_1.montarPulse)((0, manifest_1.exigirManifesto)(), { registrar: args.opcoes.registrar === true,
+            // RM-061 (F2b, G2): o pulse grava (sensores, condução) e monta o --json em pt-BR; so o texto segue o locale.
+            const carregadoDoPulse = (0, manifest_1.exigirManifesto)();
+            const p = (0, locale_1.comLocale)('pt-BR', () => (0, pulse_1.montarPulse)(carregadoDoPulse, { registrar: args.opcoes.registrar === true,
                 escopo: texto(args.opcoes.escopo)?.split(',').map(s => s.trim()),
                 semRuntime: args.opcoes['sem-runtime'] === true,
-                linhasLogs: texto(args.opcoes.linhas) === undefined ? undefined : Number(texto(args.opcoes.linhas)) });
+                linhasLogs: texto(args.opcoes.linhas) === undefined ? undefined : Number(texto(args.opcoes.linhas)) }));
             console.log(args.opcoes.json === true ? JSON.stringify(p, null, 2) : (0, pulse_1.textoDoPulse)(p));
             return p.runtime.ok || args.opcoes['sem-runtime'] === true ? 0 : 1;
         }
@@ -4370,6 +4750,8 @@ function main(argvBruto) {
             return comandoVerify(args);
         case 'ci':
             return comandoCi(args);
+        case 'privado':
+            return comandoPrivado(args);
         case 'gate':
             return comandoGate(args);
         case 'retry':
@@ -4385,6 +4767,8 @@ function main(argvBruto) {
             console.log(JSON.stringify(result, null, 2));
             return ['ok', 'empty', 'unknown', 'withheld', 'applied', 'rolled-back'].includes(result.state) ? 0 : 1;
         }
+        case 'conhecimento':
+            return comandoConhecimento(args);
         case 'memory':
             return comandoMemory(args);
         case 'grafo': {
@@ -4392,8 +4776,18 @@ function main(argvBruto) {
             const carregado = (0, manifest_1.exigirManifesto)();
             return (0, intelligence_graph_cli_1.executarGrafo)(argv.slice(argv.indexOf('grafo') + 1), { raiz: carregado.raiz, estado: (0, estado_thread_1.raizDoEstado)(carregado.raiz), repositorio: carregado.manifesto.project.name, versao: versao_1.VERSAO_DO_ORK,
                 contextoDaThread: (id) => (0, mcp_grafo_1.lerEntradaDaThread)(carregado.raiz, id),
+                // RM-061 (F3d): a familia do grafo nao importa o catalogo (fronteira do KG3); a redacao vem daqui, no locale do comando.
+                textos: (0, locale_1.msg)().grafo,
                 escrever: (texto) => console.log(texto) });
         }
+        case 'security-scan': {
+            // Relatorio por SHA no estado da arvore principal; o argv cru depois do comando (o parser e estrito).
+            const carregado = (0, manifest_1.exigirManifesto)();
+            return (0, cli_1.executarSecurityScan)(argv.slice(argv.indexOf('security-scan') + 1), { raiz: carregado.raiz, estado: (0, estado_thread_1.raizDoEstado)(carregado.raiz), escrever: (texto) => console.log(texto),
+                ...(carregado.manifesto.check?.mode ? { modoDoManifesto: carregado.manifesto.check.mode } : {}),
+                ...(carregado.manifesto.check?.agile ? { agile: { osv_scanner: carregado.manifesto.check.agile.osv_scanner,
+                        oxlint: carregado.manifesto.check.agile.oxlint } } : {}) });
+        }
         case 'ship':
             return comandoShip(args);
         case 'activation':
@@ -4440,8 +4834,9 @@ function main(argvBruto) {
             console.log((0, ciclos_1.tabelaDeVariantes)());
             return 0;
         default:
-            console.error(`comando desconhecido: ${comando}`);
-            console.log(AJUDA);
+            (0, locale_1.ativarLocale)(localeDaAjuda());
+            console.error((0, locale_1.msg)().ajuda.comandoDesconhecido(comando));
+            console.log((0, locale_1.msg)().ajuda.texto(dadosDaAjuda()));
             return 2;
     }
 }
@@ -4455,13 +4850,20 @@ if (require.main === module) {
             console.log(process.argv.includes('--json') ? JSON.stringify(e.recusa, null, 2) : e.recusa.texto);
             process.exitCode = 3;
         }
+        else if (e instanceof fila_pesada_1.ErroDaFilaPesada) {
+            // RM-058 N2 (D10): a fila pesada que nao deu a vez no prazo responde como a conducao: o texto ou o JSON, e 3.
+            console.log(process.argv.includes('--json') ? JSON.stringify(e.recusa, null, 2) : e.recusa.texto);
+            process.exitCode = 3;
+        }
         else if (e instanceof projeto_alvo_1.ErroDeProjeto) {
             // RM-052 (D3): a recusa de projeto-alvo e a resposta (a escolha, os candidatos), nao um stack trace.
             console.log(process.argv.includes('--json') ? JSON.stringify(e.recusa, null, 2) : e.texto);
             process.exitCode = projeto_alvo_1.SAIDA_DE_PROJETO;
         }
         else {
-            console.error(`erro: ${e.message}`);
+            // RM-061 (F2a, D11): o prefixo segue o locale do comando coberto; a mensagem sai como veio, salvo o
+            // erro do catalogo, remontado no locale do comando (D14).
+            console.error((0, locale_1.msg)().cli.erro((0, locale_1.mensagemDoErro)(e)));
             process.exitCode = 1;
         }
     }