@orkastery/cli 0.5.1 → 0.5.6

package/dist/index.js

@@ -42,6 +42,7 @@ exports.main = main;
 const company_brain_cli_1 = require("./company-brain-cli");
 const estado_thread_1 = require("./estado-thread");
 const intelligence_graph_cli_1 = require("./intelligence-graph-cli");
+const mcp_grafo_1 = require("./mcp-grafo");
 const maestro_cli_1 = require("./maestro-cli");
 const hitl_public_receipt_1 = require("./hitl-public-receipt");
 const hitl_presentation_1 = require("./hitl-presentation");
@@ -92,6 +93,7 @@ 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 preflight_1 = require("./preflight");
@@ -106,6 +108,7 @@ const agents_md_1 = require("./agents-md");
 const leases_1 = require("./leases");
 const sessoes_inventario_1 = require("./sessoes-inventario");
 const ledger_stats_1 = require("./ledger-stats");
+const esgotamentos_1 = require("./esgotamentos");
 const sessoes_adopt_1 = require("./sessoes-adopt");
 const sessoes_1 = require("./sessoes");
 const runtime_ambiente_1 = require("./runtime-ambiente");
@@ -116,7 +119,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");
@@ -135,6 +138,7 @@ 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 phase_1 = require("./phase");
 const prompts_1 = require("./prompts");
 const sessoes_2 = require("./sessoes");
@@ -145,19 +149,30 @@ const thread_1 = require("./thread");
 const docs_1 = require("./docs");
 const roadmap_reservas_1 = require("./roadmap-reservas");
 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");
+const saida_segura_1 = require("./saida-segura");
+const rede_forja_1 = require("./rede-forja");
+const rede_status_1 = require("./rede-status");
 const ledger_1 = require("./ledger");
 const tokens_1 = require("./tokens");
 const types_1 = require("./types");
 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 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)();
@@ -193,13 +208,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)
@@ -207,343 +231,38 @@ 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
-  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]
-        [--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)
-  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 atual
-        [--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 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 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 --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>"
-        [--classe C[,C]] [--resumo R] [--por Q] [--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 --aceitar-omissao [--json]         Aceita as entregues por omissao, com registro
-  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 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] [--dry-run]   (evidencia, claim e proposta viajam junto)
-
-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];
@@ -574,15 +293,23 @@ function comandoThread(args) {
                     return 2;
                 }
             }
-            const brutoWorktreeAchado = args.opcoes.worktree;
-            const criarWorktreeAchado = brutoWorktreeAchado === true || brutoWorktreeAchado === 'auto';
+            // P4 do ensaio da 0.5.0 (D2): a thread do achado segue a mesma regra de worktree do `thread new`.
+            let pedidoAchado;
+            try {
+                pedidoAchado = (0, thread_1.pedidoDeWorktree)({ worktree: args.opcoes.worktree, semWorktree: args.opcoes['sem-worktree'] }, carregado.manifesto.worktree.por_thread);
+            }
+            catch (e) {
+                console.error(e.message);
+                return 2;
+            }
             const r = (0, auditrun_1.abrirThreadDoAchado)(carregado, doAchado, {
                 nome: args.posicionais[2],
                 modo: modoAchado ?? undefined,
                 slug: texto(args.opcoes.slug),
                 assunto: texto(args.opcoes.assunto),
-                criarWorktree: criarWorktreeAchado,
-                worktree: criarWorktreeAchado ? null : (texto(brutoWorktreeAchado) ?? null),
+                criarWorktree: pedidoAchado.criar,
+                worktree: pedidoAchado.dir,
+                origemDaWorktree: pedidoAchado.origem,
                 dryRun: args.opcoes['dry-run'] === true,
             });
             if (!r.ok) {
@@ -607,6 +334,13 @@ function comandoThread(args) {
                 console.log((0, thread_1.resumoDaThread)(r.thread));
                 console.log('');
                 console.log(`  slug em 3 partes: ${(0, phase_1.descreverSlug)(r.thread.slug)}`);
+                const linhaDaWorktreeDoAchado = (0, thread_1.linhaDaWorktree)(r.worktreePor, gravadaDoAchado);
+                if (linhaDaWorktreeDoAchado)
+                    console.log(linhaDaWorktreeDoAchado);
+                const avisoDaWorktreeDoAchado = r.worktreeFalharia ? (0, thread_1.avisoDeWorktreeQueFalharia)(r.worktreeFalharia)
+                    : (0, thread_1.avisoDaWorktree)(pedidoAchado.origem, { thread: r.thread, gravada: gravadaDoAchado, worktreePor: r.worktreePor }, carregado.manifesto);
+                if (avisoDaWorktreeDoAchado)
+                    console.error(avisoDaWorktreeDoAchado);
             }
             if (r.motivo === 'claims.unverifiable') {
                 console.log('');
@@ -635,8 +369,9 @@ function comandoThread(args) {
             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));
@@ -662,25 +397,52 @@ 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;
-        const brutoWorktree = args.opcoes.worktree;
-        // `--worktree auto` (ou `--worktree` sozinho) cria a worktree isolada da thread;
-        // um caminho reusa um diretorio que ja existe.
-        const criarWorktree = brutoWorktree === true || brutoWorktree === 'auto';
+        // 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.
+        let pedido;
+        try {
+            pedido = (0, thread_1.pedidoDeWorktree)({ worktree: args.opcoes.worktree, semWorktree: args.opcoes['sem-worktree'] }, carregado.manifesto.worktree.por_thread);
+        }
+        catch (e) {
+            console.error(e.message);
+            return 2;
+        }
         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(mt.cicloExigeWorktree(variante));
             return 2;
         }
         const brutoFatias = texto(args.opcoes.fatias);
@@ -688,16 +450,18 @@ 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),
                 assunto: texto(args.opcoes.assunto),
-                worktree: criarWorktree ? null : (texto(brutoWorktree) ?? null),
-                criarWorktree,
+                worktree: pedido.dir,
+                criarWorktree: pedido.criar,
+                origemDaWorktree: pedido.origem,
                 dryRun,
                 variante,
                 branch: texto(args.opcoes.branch),
@@ -705,44 +469,56 @@ 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);
+        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)
+            console.error(avisoDaWorktreeNova);
         if (avisoSemBase)
             console.error(avisoSemBase);
         return 0;
@@ -764,8 +540,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);
@@ -779,20 +556,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;
 }
 /**
@@ -804,7 +580,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)
@@ -833,6 +609,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 {
@@ -841,10 +618,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));
@@ -866,7 +646,7 @@ 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)();
@@ -980,7 +760,20 @@ function comandoAccounts(args) {
         imprimir();
         return falhas > 0 ? 1 : 0;
     }
-    console.error(`subcomando desconhecido: accounts ${sub} (use list, add, remove ou check)`);
+    if (sub === 'esgotamentos') {
+        // RM-040 (B7): so leitura do registro de contas e dos ledgers dos projetos registrados.
+        let relatorio;
+        try {
+            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)`);
+            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)`);
     return 2;
 }
 function comandoSetup(args) {
@@ -999,6 +792,91 @@ function comandoSetup(args) {
         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.');
         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(`Pasta das worktrees "${local.dir}" confirmada nesta maquina para ${local.raiz}.`);
+            console.log(`  Gravada em .orkastery/private/${worktree_local_1.ARQUIVO_WORKTREE_LOCAL} (local, fora do git). Para desfazer: ork setup worktree revogar.`);
+            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 ? 'Confirmacao local da pasta das worktrees revogada.' : 'Nao havia confirmacao local da pasta das worktrees.');
+            return 0;
+        }
+        if (acao !== undefined) {
+            console.error(`subcomando desconhecido: setup worktree ${acao} (use confirmar [<dir>] ou revogar)`);
+            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(`worktree.dir no orkastery.yaml: ${carregado.manifesto.worktree.dir} (${pedida.dir}, ${pedida.dentro ? 'dentro' : 'fora'} da raiz)`);
+        console.log(`confirmacao local desta maquina: ${local.local ? local.local.dir : `nenhuma (${local.motivo})`}`);
+        console.log(recusa === null ? 'criacao de worktree: permitida' : `criacao de worktree: recusada. ${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('uso: ork setup sandbox confirmar <read-only|workspace-write|danger-full-access> [--por Q]');
+                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(`Postura de sandbox "${p.sandbox}" confirmada nesta maquina para ${p.raiz}.`);
+            console.log(`  Gravada em ${(0, postura_local_1.caminhoDaPosturaLocal)(raiz)} (local, fora do git). Para desfazer: ork setup sandbox revogar.`);
+            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 ? 'Confirmacao local da postura de sandbox revogada.' : 'Nao havia confirmacao local de postura de sandbox.');
+            return 0;
+        }
+        if (acao !== undefined) {
+            console.error(`subcomando desconhecido: setup sandbox ${acao} (use confirmar <postura> ou revogar)`);
+            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(`runtime.sandbox no orkastery.yaml: ${pedida}`);
+        console.log(`confirmacao local desta maquina: ${local.postura ? local.postura.sandbox : `nenhuma (${local.motivo})`}`);
+        console.log(recusa === null ? 'despacho pelo codex: permitido' : `despacho pelo codex: recusado. ${(0, postura_local_1.comandoDeConfirmacao)(pedida)}`);
+        return 0;
+    }
     if (!modoBruto) {
         if (args.opcoes.reset === true) {
             (0, setup_1.resetarSetup)(raiz, undefined, por);
@@ -1067,29 +945,34 @@ 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),
             model: texto(args.opcoes.model),
             effort: texto(args.opcoes.effort),
+            perfil: texto(args.opcoes.perfil),
             dryRun: args.opcoes['dry-run'] === true,
             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));
@@ -1105,14 +988,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.
@@ -1121,69 +1003,71 @@ 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) {
@@ -1281,6 +1165,15 @@ function comandoSessions(args) {
         console.log(args.opcoes.json === true ? JSON.stringify(r, null, 2) : (0, sessoes_1.textoDoInventario)(r));
         return !r.ok || (args.opcoes['exigir-limpo'] === true && r.semThread > 0) ? 1 : 0;
     }
+    if (sub === 'limpar-fantasmas') {
+        if (!carregado) {
+            console.error('ork sessions limpar-fantasmas precisa de um projeto (orkastery.yaml)');
+            return 2;
+        }
+        const r = (0, sessoes_2.limparFantasmas)(raiz, { dryRun: args.opcoes['dry-run'] === true });
+        console.log(args.opcoes.json === true ? JSON.stringify(r, null, 2) : (0, sessoes_2.textoDaLimpeza)(r));
+        return r.ok ? 0 : 1;
+    }
     if (sub === 'hitl') {
         return comandoSessionsHitl(args, carregado ? raiz : '');
     }
@@ -1467,6 +1360,13 @@ function comandoClaims(args) {
             console.log('');
             console.log('AVISO: alegacao negativa sem comando de verificacao reprova em `ork verify`.');
         }
+        // RM-008 (B8): a conferencia local da policy claim_sem_prova_local avisa e segue.
+        const linhasDePolicy = (0, policies_1.linhasDeAviso)(claim.avisosDePolicy ?? []);
+        if (linhasDePolicy.length) {
+            console.log('');
+            for (const l of linhasDePolicy)
+                console.log(l);
+        }
         // 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('');
@@ -1474,6 +1374,40 @@ function comandoClaims(args) {
         }
         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('uso: ork claims conferir <thread-id> --claims C1,C2 | --tarefa T1 [--prazo S] [--json]');
+            return 2;
+        }
+        const conducao = conducaoDoCli(args);
+        try {
+            const r = (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(e.message);
+            return 2;
+        }
+    }
     if (sub === 'verificar') {
         const id = args.posicionais[2];
         const claimId = args.posicionais[3];
@@ -1533,25 +1467,36 @@ function comandoClaims(args) {
 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-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}`);
+        // 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));
+        console.log(m.baselineGravada(id));
+        console.log(m.baselineCommit(b.commit));
         for (const c of b.comandos) {
-            console.log(`  ${c.nome.padEnd(10)} ${c.ok ? 'passava' : `ja falhava (codigo ${c.code})`}  ${c.comando}`);
+            console.log(m.baselineComando(c.nome, c.ok, c.code, c.comando));
+        }
+        if (b.comandos.some((c) => !c.ok)) {
+            // Ensaio de 03/10 (R7): "ja falhava" sem dizer onde ver a saida do comando.
+            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 }));
     console.log((0, verify_1.textoDoVerify)(r));
     return r.ok ? 0 : 1;
 }
@@ -1559,10 +1504,45 @@ 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 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('uso: ork conducao sentinela status|bater|desligar [--sessao <id>] [--json]');
+    const sessao = texto(args.opcoes.sessao);
+    if (!sessao)
+        throw new Error(`uso: ork conducao sentinela ${acao} --sessao <id> [--json]`);
+    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
+            ? `Sentinela ${r.ligou ? 'ligada' : 'renovada'} na maquina ${r.presenca.maquina} pela sessao ${curta}; vale 3 min sem batida.`
+            : `Outra sessao (${curta}) conduz pela Sentinela na maquina ${r.presenca.maquina}; esta fica so olhando.`);
+        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
+        ? 'Sentinela desligada nesta maquina; o condutor externo volta a conduzir.'
+        : 'Nada a desligar: a presenca nesta maquina nao e desta sessao.');
+    return 0;
+}
 function comandoConducao(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
     const sub = args.posicionais[1];
     const id = args.posicionais[2];
+    if (sub === 'sentinela')
+        return comandoSentinela(carregado, args);
     if (sub === 'status') {
         if (!id)
             throw new Error('uso: ork conducao status <thread-id> [--json]');
@@ -1580,7 +1560,7 @@ function comandoConducao(args) {
         console.log(args.opcoes.json === true ? JSON.stringify(r, null, 2) : `${r.ok ? 'Conducao assumida.' : 'Handoff recusado.'} ${r.detalhe}`);
         return r.ok ? 0 : 3;
     }
-    throw new Error('uso: ork conducao status|assumir <thread-id>');
+    throw new Error('uso: ork conducao status|assumir <thread-id> | ork conducao sentinela status|bater|desligar');
 }
 /** RM-048 (D1): o gate aberto no contrato curto, com o codigo estavel e o "desde" do ledger. */
 function textoDoGateCurto(raiz, pedido, canal) {
@@ -1741,7 +1721,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);
@@ -1752,7 +1732,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;
@@ -1764,11 +1745,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));
         }
@@ -1848,7 +1829,7 @@ function comandoFix(args) {
             console.error('uso: ork fix open <thread-id> [--so-claims] [--reverify]');
             return 2;
         }
-        const conducao = conducaoDoCli(args);
+        const conducao = { ...conducaoDoCli(args), filaPesada: filaPesadaDoCli(args, 'verify', `ork fix open ${id} --esperar 30`) };
         const rodada = (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 })
@@ -1903,7 +1884,7 @@ function comandoFix(args) {
         }
         const rodadaBruta = texto(args.opcoes.rodada);
         const r = (0, fix_1.reverificar)(carregado, id, {
-            conducao: conducaoDoCli(args),
+            conducao: { ...conducaoDoCli(args), filaPesada: filaPesadaDoCli(args, 'verify', `ork fix reverify ${id} --esperar 30`) },
             rodada: rodadaBruta ? Number(rodadaBruta) : undefined,
             parcial: args.opcoes.parcial === true,
         });
@@ -1956,8 +1937,76 @@ function comandoHandoff(args) {
     console.error(`subcomando desconhecido: handoff ${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];
@@ -1965,43 +2014,68 @@ 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).
+        if (args.opcoes.remoto !== undefined)
+            (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 })]
+            : 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(m.avisoDeDocs(pendentes.length));
+            for (const d of pendentes) {
+                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;
         const registrariam = r.filter((x) => x.acao === 'registraria').length;
         if (registradas) {
             console.log('');
-            console.log(`${registradas} entrega(s) registrada(s). Fechar pelo MASTER: ork master --aceitar-omissao (a nota humana sobrescreve).`);
+            // 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(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),
+    // e `--remoto` sem valor nao vira `origin` em silencio.
+    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, {
+    // 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),
@@ -2009,10 +2083,28 @@ function comandoShip(args) {
         dryRun: args.opcoes['dry-run'] === true,
         autorizarPush: typeof autorizar === 'string' ? autorizar : 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(`portfolio.opcao-aposentada: --${opcao} era do Objective Envelope, aposentado na I-43, e o\n` +
+        '  portfolio show nunca a leu. As duas vigas do envelope 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');
+    return 2;
+}
 function comandoPortfolio(args) {
     const root = (0, manifest_1.exigirManifesto)().raiz;
     const sub = args.posicionais[1] ?? 'list';
@@ -2040,6 +2132,9 @@ function comandoPortfolio(args) {
         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>');
@@ -2194,10 +2289,15 @@ function comandoCi(args) {
     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)) {
-            console.error('uso: ork ci status --sha <commit> [--remoto origin]');
+            // 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]');
             return 2;
         }
-        const result = (0, ci_1.consultarCi)(carregado, sha, texto(args.opcoes.remoto) ?? 'origin');
+        // 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}`);
         return result.ok ? 0 : 1;
     }
@@ -2324,7 +2424,14 @@ const CONTRATO_DO_BOARD = 'ork.board/v1';
 function comandoFabrica(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
     const sub = args.posicionais[1];
+    // 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;
+    if (sub !== 'publicar')
+        (0, branch_de_estado_1.exigirRemoto)(remoto, 'fabrica');
     if (sub === 'publicar') {
         const silencioso = args.opcoes.silencioso === true;
         try {
@@ -2343,6 +2450,9 @@ function comandoFabrica(args) {
                         : `Fabrica: retrato de ${r.maquina} igual ao ultimo publicado; nada a enviar (use --forcar para publicar mesmo assim).`);
             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).');
+                // RM-047 (P5): o manifesto que pede a fabrica nao liga a publicacao desta maquina.
+                if (carregado.manifesto.fabrica.compartilhada)
+                    console.log('  o orkastery.yaml pede a fabrica compartilhada; quem liga e a maquina, com ork fabrica entrar.');
             }
             return 0;
         }
@@ -2376,13 +2486,14 @@ function comandoFabrica(args) {
         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.'));
         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('  AVISO: ORK_FABRICA_COMPARTILHADA=1 neste shell ainda liga a fabrica aqui.');
         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('uso: ork fabrica [--json] [--sem-remoto] | fabrica publicar [--forcar] [--json] | fabrica entrar [--maquina NOME] | fabrica sair' +
+            ' | fabrica batida [status|instalar|remover] [--por Q] [--json]');
         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.
@@ -2395,13 +2506,128 @@ function comandoFabrica(args) {
         naoLido: [projeto_alvo_1.FORA_DA_CONSULTA.roadmap, projeto_alvo_1.FORA_DA_CONSULTA.reservas, ...(url === null ? [(0, projeto_alvo_1.semRemoto)(remoto)] : [])],
     });
     if (args.opcoes.json === true) {
-        console.log(JSON.stringify({ ...painel, consulta }, null, 2));
+        // RM-053 (fatia 2): o mesmo JSON, com o invisivel do remoto escrito como \uXXXX.
+        console.log((0, saida_segura_1.jsonSemInvisivel)({ ...painel, consulta }));
         return 0;
     }
     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.`
         : (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);
+        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('uso: ork fabrica batida [status|instalar|remover] [--por Q] [--json]');
+    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
+ * atual, quando ha, so entra no retrato e na leitura da fabrica legada.
+ */
+function comandoNetwork(args) {
+    const sub = args.posicionais[1];
+    // RM-054: `network roadmap` tem o proprio --projeto e o proprio uso.
+    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]';
+    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);
+        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`);
+        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).`);
+        }
+        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.`);
+        }
+        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.');
+        }
+        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.
+            try {
+                (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 });
+                return 1;
+            }
+        }
+        const r = (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).`);
+        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).`);
+        }
+        return 0;
+    }
+    if (sub !== undefined && sub !== 'status') {
+        console.error(`subcomando desconhecido: network ${sub}`);
+        console.error(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 });
+    console.log(args.opcoes.json === true ? (0, rede_status_1.jsonDaRede)(status) : (0, rede_status_1.textoDaRede)(status));
     return 0;
 }
 /**
@@ -2581,8 +2807,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;
     }
@@ -2640,26 +2867,13 @@ function comandoMaster(args) {
         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 --aceitar-omissao   aceita as entregues, com indice e insumos no 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');
         return 2;
     }
-    if (args.opcoes['aceitar-omissao'] === true) {
-        const aceitos = (0, master_2.aceitarPendentesPorOmissao)(carregado.raiz);
-        if (args.opcoes.json === true) {
-            console.log(JSON.stringify(aceitos, null, 2));
-            return 0;
-        }
-        if (aceitos.length === 0) {
-            console.log('Nenhuma entrega esperando decisao.');
-            return 0;
-        }
-        console.log(`Aceitas por omissao: ${aceitos.length}. O indice e os insumos foram ao ledger.`);
-        for (const a of aceitos)
-            console.log(`  ${a.thread.padEnd(20)} indice ${a.indice.valor}/${a.indice.base}`);
-        console.log('');
-        console.log('Discordou? A nota humana sobrescreve, e o registro da omissao permanece.');
-        return 0;
+    if (args.opcoes['aceitar-omissao'] !== undefined) {
+        return comandoAceitarOmissao(args, carregado.raiz, primeiro);
     }
     if (primeiro === undefined) {
         console.log(args.opcoes.json
@@ -2675,7 +2889,7 @@ function comandoMaster(args) {
     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>"');
+        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.');
         return 2;
     }
@@ -2727,6 +2941,89 @@ function comandoMaster(args) {
     console.log(`Proximo passo: ork board --all   |   entregas e indice: ork master`);
     return 0;
 }
+/**
+ * RM-008 (03/10/2026): `ork master [<thread>] --aceitar-omissao [--thread T] [--dry-run] [--json]`.
+ *
+ * Tres vezes na madrugada de 03/10, um condutor rodou `ork master --aceitar-omissao` para fechar a
+ * propria thread, e o comando fechou tambem as entregues de outras frentes (ork-rm057fatia3t,
+ * ork-rm025modocon). A thread indicada (posicional, `--thread T` ou `--aceitar-omissao=T`) limita o
+ * aceite a ela. Sem thread, o padrao continua o mesmo, por decisao registrada: drenar todas, agora
+ * listando cada uma e avisando em stderr quando quem roda e processo de agente.
+ */
+function comandoAceitarOmissao(args, raiz, posicional) {
+    const bruto = args.opcoes['aceitar-omissao'];
+    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((0, locale_1.msg)().master.usoOmissao);
+        return 2;
+    }
+    const alvo = candidatos[0];
+    const dryRun = args.opcoes['dry-run'] === true;
+    const json = args.opcoes.json === true;
+    if (alvo) {
+        const fora = (0, master_2.motivoForaDaOmissao)(raiz, alvo);
+        if (fora) {
+            if (json)
+                console.log(JSON.stringify(dryRun ? { dryRun: true, fecharia: [], motivo: fora.motivo } : [], null, 2));
+            else
+                (fora.motivo === 'ja-fechada' ? console.log : console.error)(fora.texto);
+            return fora.motivo === 'ja-fechada' ? 0 : 1;
+        }
+    }
+    if (dryRun) {
+        const fecharia = (0, master_2.entregasParaOmissao)(raiz, alvo).map((p) => ({ thread: p.thread.id, indice: (0, master_2.indiceDaThread)(raiz, p.thread.id) }));
+        if (json) {
+            console.log(JSON.stringify({ dryRun: true, fecharia }, null, 2));
+            return 0;
+        }
+        const m = (0, locale_1.msg)().master;
+        console.log(m.ensaio);
+        if (fecharia.length === 0) {
+            console.log(m.nadaEsperando);
+            return 0;
+        }
+        console.log(m.fecharia(fecharia.length));
+        for (const f of fecharia)
+            console.log(m.linhaDoIndice(f.thread, f.indice.valor, f.indice.base));
+        avisoDeOmissaoSemAlvo(alvo, fecharia.length, true);
+        return 0;
+    }
+    // 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(m.nadaEsperando);
+        return 0;
+    }
+    console.log(m.aceitas(aceitos.length));
+    for (const a of aceitos)
+        console.log(m.linhaDoIndice(a.thread, a.indice.valor, a.indice.base));
+    console.log('');
+    console.log(m.discordou);
+    return 0;
+}
+/**
+ * O aviso do aceite SEM thread vindo de processo de agente que alcanca mais de uma entrega. A marca
+ * e a mesma do `master.prova-de-canal` (ambiente do host ou do despacho). Vai para stderr: o stdout,
+ * inclusive o `--json`, fica como era.
+ */
+function avisoDeOmissaoSemAlvo(alvo, quantas, ensaio) {
+    if (alvo || quantas <= 1)
+        return;
+    const marca = (0, master_nota_1.marcaDeHost)(process.env);
+    if (!marca)
+        return;
+    const propria = (process.env[runtime_ambiente_1.ENV_THREAD_DO_DESPACHO] ?? '').trim();
+    console.error('');
+    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) {
     const carregado = (0, manifest_1.exigirManifesto)();
@@ -2764,9 +3061,26 @@ function comandoRoadmap(args) {
                     : soltas.map((s) => `${s.item}: ${s.detalhe} (thread fechada ${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') {
@@ -2774,7 +3088,11 @@ 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;
     }
@@ -2824,7 +3142,7 @@ function comandoRoadmap(args) {
  * RM-054 (fatia 1): `ork network roadmap`, o roadmap da rede de qualquer diretorio. Pedido de projeto
  * ambiguo ou desconhecido e resposta, nao erro: a recusa com os candidatos, e o codigo da RM-052.
  */
-function comandoNetwork(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]');
@@ -2897,11 +3215,13 @@ function comandoDocs(args) {
         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`);
@@ -2957,12 +3277,18 @@ function comandoPrompt(args) {
             return 2;
         }
         const thread = (0, thread_1.lerThread)(obrigatorio.raiz, threadId);
+        // 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);
         const prompt = idTemplate
-            ? (0, prompts_1.renderizar)(template, (0, phase_1.valoresDoPrompt)(thread, fase, pedido))
-            : (0, phase_1.montarPrompt)(thread, fase, pedido, obrigatorio.raiz);
+            ? (0, prompts_1.renderizar)(template, (0, phase_1.valoresDoPrompt)(thread, fase, pedidoDaFase))
+            : (0, phase_1.montarPrompt)(thread, fase, pedidoDaFase, 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)}`);
+        if (guardado)
+            console.log(`# pedido guardado na criacao da thread (sha256 ${(0, util_1.shaCurto)(guardado.sha256)})`);
         console.log('');
         console.log(prompt);
         return 0;
@@ -2981,6 +3307,19 @@ function exigirFaseCanonica(bruto) {
 /**
  * `ork adapter list|show|install <host>`: instalacao dos adaptadores de Camada 1 (bloco B4).
  */
+/**
+ * O caminho real do `ork` em execução, quando o processo é este CLI (argv[1] resolve para este arquivo).
+ * Importado por outro script, devolve undefined e o install volta à ordem antiga (PATH, catálogo).
+ */
+function orkEmExecucao() {
+    try {
+        const proprio = fs.realpathSync(__filename);
+        return process.argv[1] && fs.realpathSync(process.argv[1]) === proprio ? proprio : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function comandoAdapter(args) {
     const sub = args.posicionais[1] ?? 'list';
     if (sub === 'list') {
@@ -3014,11 +3353,15 @@ function comandoAdapter(args) {
             dryRun: args.opcoes['dry-run'] === true,
             force: args.opcoes.force === true || args.opcoes.forcar === true,
             orkBin: texto(args.opcoes.ork),
+            // Ensaio de 03/10: a extensão chama o ork que a instalou, não o primeiro do PATH.
+            orkEmExecucao: orkEmExecucao(),
             versao: VERSAO,
             // I-43 (D5): a decisao por ARQUIVO, que e o que faz `--force` deixar de ser o
             // 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; o texto impresso segue em pt-BR (F3b).
+            locale: (0, locale_1.resolverLocale)(carregado?.manifesto.owner?.language).locale,
         });
         console.log((0, hosts_1.textoDaInstalacao)(r));
         return r.ok ? 0 : 2;
@@ -3033,7 +3376,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;
@@ -3184,6 +3528,9 @@ function comandoAudit(args) {
         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]');
@@ -3432,8 +3779,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')
@@ -3446,9 +3794,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) {
@@ -3650,7 +3998,20 @@ function comandoMemory(args) {
         const config = (0, manifest_1.configDeEmbedding)(carregado.manifesto);
         const driver = (0, orkmind_1.configDoManifesto)(carregado.manifesto);
         const embedder = new orkmind_1.DriverCliOrkMind(driver);
-        const universo = (0, indice_vetorial_1.universoDoTenant)(memoria, memoria.estado.tenant);
+        // RM-038: o universo da busca inteiro, numa leitura; sem ele, nada e embedado (nunca um pedaco).
+        let universo;
+        try {
+            universo = (0, indice_vetorial_1.universoDaBusca)(memoria, memoria.estado.tenant);
+        }
+        catch (erro) {
+            const motivo = (0, indice_vetorial_1.codigoDaFalha)(erro);
+            const detalhe = 'o universo da busca nao foi lido inteiro; nada foi embedado';
+            if (args.opcoes.json === true)
+                console.log(JSON.stringify({ motivo, detalhe }, null, 2));
+            else
+                console.error(`memory.index: ${motivo}; ${detalhe}`);
+            return 1;
+        }
         const alvos = modelo === 'todos' ? ['primario', 'fallback'] : [modelo];
         const resultados = alvos.map(alvo => (0, indice_vetorial_1.indexar)({ raiz: carregado.raiz, tenant: memoria.estado.tenant,
             dsn: driver.dsn, config, alvo, universo, dryRun: args.opcoes['dry-run'] === true,
@@ -3663,7 +4024,7 @@ function comandoMemory(args) {
         }
         else {
             for (const r of resultados)
-                console.log(textoDoIndice(r));
+                console.log((0, indice_vetorial_1.textoDoIndice)(r));
         }
         return resultados.some(r => !r.dryRun && r.motivo) ? 1 : 0;
     }
@@ -3675,7 +4036,7 @@ 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.
@@ -3701,51 +4062,43 @@ function buscaPorTexto(args, carregado) {
     const memoria = (0, memoria_1.abrirMemoria)(carregado);
     const config = (0, manifest_1.configDeEmbedding)(carregado.manifesto);
     let r;
+    const vazio = { texto: frase, modo, origem: 'nenhum', modeloUsado: null, deterministico: false,
+        resultados: [], listas: { vetor: [], fts: [] }, ftsForaDoUniverso: 0, coberturaDoIndice: null };
+    let universo = null;
+    let falhaDoUniverso = '';
+    if (memoria.ativo) {
+        try {
+            universo = (0, indice_vetorial_1.universoDaBusca)(memoria, memoria.estado.tenant);
+        }
+        catch (erro) {
+            falhaDoUniverso = (0, indice_vetorial_1.codigoDaFalha)(erro);
+        }
+    }
     if (!memoria.ativo) {
-        r = { texto: frase, modo, origem: 'nenhum', modeloUsado: null, deterministico: false, motivo: memoria.estado.motivo,
-            detalhe: `${memoria.estado.detalhe}; correcao: ${memoria.estado.correcao}`, resultados: [], listas: { vetor: [], fts: [] } };
+        r = { ...vazio, motivo: memoria.estado.motivo, detalhe: `${memoria.estado.detalhe}; correcao: ${memoria.estado.correcao}` };
+    }
+    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' };
     }
     else {
         const driver = (0, orkmind_1.configDoManifesto)(carregado.manifesto);
         const transporte = new orkmind_1.DriverCliOrkMind(driver);
         const fallback = memoria.estado.embeddings?.fallback;
         r = (0, busca_semantica_1.buscarPorSignificado)({ raiz: carregado.raiz, tenant: memoria.estado.tenant, dsn: driver.dsn, config,
-            universo: (0, indice_vetorial_1.universoDoTenant)(memoria, memoria.estado.tenant, colecao ? [colecao] : orkmind_1.COLECOES_DO_ORK),
+            universo, colecao: colecao,
             texto: frase, modo, limite, timeoutMs: driver.timeoutMs,
             chavePresente: memoria.estado.embeddings?.chavePresente === true,
             fallbackUsavel: memoria.estado.embeddings?.sondado === true && fallback?.dependencias === true,
             embeddar: (p, o) => transporte.embeddar(p, o), buscarTexto: (t, q) => transporte.buscarTexto(t, q) });
     }
+    const codigo = universo ? 0 : 1;
     if (args.opcoes.json === true) {
         console.log(JSON.stringify(r, null, 2));
-        return 0;
+        return codigo;
     }
-    console.log(`Busca por significado (NAO deterministica; modo ${r.modo}, origem ${r.origem}${r.modeloUsado ? ` ${r.modeloUsado}` : ''})`);
-    if (r.motivo)
-        console.log(`  motivo: ${r.motivo}${r.detalhe ? `; ${r.detalhe}` : ''}`);
-    console.log('');
-    r.resultados.forEach((e, i) => {
-        const sim = e.similaridade === null ? '' : `  similaridade ${e.similaridade}`;
-        console.log(`  ${i + 1}. [${e.collection}] ${e.id}  score ${e.score}  ${e.fontes.join('+')}${sim}`);
-        console.log(`      ${e.resumo}`);
-    });
-    console.log('');
-    console.log(`  ${r.resultados.length} resultado(s); busca por tag continua em ork memory search --tags`);
-    return 0;
-}
-/** Texto de `ork memory index`: o que foi (ou seria) embedado e quanto custa estimado. */
-function textoDoIndice(r) {
-    const custo = r.custoEstimadoUsd === null ? 'nao estimado' : `US$ ${r.custoEstimadoUsd.toFixed(8)}`;
-    return [
-        `Indice vetorial (${r.alvo}${r.dryRun ? ', --dry-run' : ''}): ${r.modelo ?? '(sem modelo)'}${r.dim ? ` / ${r.dim} dim` : ''}`,
-        `  universo do tenant   ${r.universo} entrada(s); coerentes ${r.coerentes}`,
-        `  embedados            ${r.embedados} (reescritos ${r.reescritos}); removidos ${r.removidos}`,
-        `  fora do indice       ${r.recusados} recusada(s) por padrao de segredo, ${r.foraDoLimite} acima do limite`,
-        ...(r.truncados ? [`  truncados            ${r.truncados} acima do contexto do modelo local, embedados pelo comeco`] : []),
-        `  estimativa           ${r.tokensEstimados} token(s), ${custo}; chamadas ao provider ${r.chamadasAoProvider}`,
-        ...(r.arquivo ? [`  arquivo              ${r.arquivo}`] : []),
-        ...(r.motivo ? [`  motivo               ${r.motivo}: ${r.detalhe}`] : r.detalhe ? [`  ${r.detalhe}`] : []),
-    ].join('\n');
+    console.log((0, busca_semantica_1.textoDaBuscaPorSignificado)(r));
+    return codigo;
 }
 /**
  * RM-052: `--projeto <nome|caminho>` e opcao GLOBAL. Sai do argv em qualquer posicao, antes de
@@ -3775,24 +4128,58 @@ function extrairOpcaoDeProjeto(argv) {
 }
 /** 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']);
+/**
+ * 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
@@ -3819,8 +4206,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));
     }
@@ -3832,11 +4220,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'
@@ -3854,6 +4244,13 @@ 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 da D2
+    // da F2a (`doctor --modo`, `thread new --from-finding` 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);
@@ -3896,39 +4293,48 @@ function main(argvBruto) {
                 console.log((0, preflight_1.textoPreflight)(r));
                 return r.prontoPrimeiroBloco ? 0 : 1;
             }
-            const r = (0, doctor_1.doctor)((0, manifest_1.diretorioDoProjeto)(), nomesHerdados);
+            // RM-031: o check dos analisadores do grafo entra por aqui, a porta da familia do grafo (fronteira do KG1).
+            // RM-061 (F2a): a redacao do check vem do catalogo, no locale do comando (a familia do grafo nao o importa).
+            const r = (0, doctor_1.doctor)((0, manifest_1.diretorioDoProjeto)(), nomesHerdados, () => (0, intelligence_graph_cli_1.checarAnalisadoresDoGrafo)(versao_1.VERSAO_DO_ORK, undefined, undefined, (0, locale_1.msg)().doctor.grafo));
             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': {
@@ -3996,16 +4402,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':
@@ -4040,10 +4447,12 @@ function main(argvBruto) {
             }
             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;
         }
@@ -4075,7 +4484,9 @@ function main(argvBruto) {
         case 'grafo': {
             // RM-031 KG3 (D7): o argv cru depois do comando; o parser do grafo e estrito.
             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, escrever: (texto) => console.log(texto) });
+            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),
+                escrever: (texto) => console.log(texto) });
         }
         case 'ship':
             return comandoShip(args);
@@ -4123,8 +4534,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;
     }
 }
@@ -4138,13 +4550,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;
         }
     }