@orkastery/cli 0.5.3 → 0.5.6

package/dist/locale.js

@@ -0,0 +1,714 @@
+"use strict";
+/**
+ * CLI em ingles e pt-BR (RM-061): F1 com `doctor` e `init`, F2a com o caminho da primeira experiencia.
+ *
+ * Um catalogo de mensagens por locale, sem dependencia nova: pt-BR e o padrao e a fonte; `en` e a
+ * alternativa. O catalogo ingles e tipado pelo portugues (`typeof PT_BR`), entao chave faltando ou
+ * assinatura diferente nao compila.
+ *
+ * Quem decide o locale, nesta ordem:
+ *   1. `owner.language` do manifesto, a escolha do onboarding (etapa maestro);
+ *   2. `LC_ALL`, `LC_MESSAGES` e `LANG`, a primeira nao vazia (a ordem do POSIX);
+ *   3. pt-BR.
+ * So `en*` vira ingles; qualquer outra lingua (es, fr, C, POSIX) fica no pt-BR, a lingua do CLI.
+ *
+ * O locale so vale nos comandos que o CLI ativa por `ativarLocale` (`COMANDOS_COM_LOCALE`, no texto;
+ * o `--json` e contrato e nao passa por aqui). Sem ativacao, tudo segue pt-BR: nenhum outro comando
+ * muda de lingua pela metade.
+ *
+ * F2a (D1 e D6 da thread ork-rm061f2a): o catalogo traduz o texto que o comando monta para a pessoa.
+ * Dado gravado (ledger, `thread.json`, prompt, estado do onboarding, recusa registrada, policy
+ * avaliada) e montado dentro de `comLocale('pt-BR', ...)` e sai como foi gravado. Valor que e dado,
+ * como o nome de um check ou o `pausaSobre` de um bloco, so e traduzido na impressao.
+ *
+ * D14: o erro que o catalogo monta e que nasce no escopo pt-BR da gravacao (`ErroDoCatalogo`: manifesto
+ * ausente, os erros de argumento de `thread new`, `--runtime` e o modelo ao trocar de runtime no `phase run`)
+ * e remontado no locale do comando pela entrada do CLI. Seguem como o modulo dono escreve, ate a familia dele migrar: o validador
+ * do manifesto (fora os avisos de preferencia da experiencia, traduzidos na impressao), o regime de
+ * memoria, o erro de estado durante a gravacao e, na F2b, a recusa `ship.remoto-invalido` do `exigirRemoto`
+ * (`branch-de-estado.ts`, modulo compartilhado com a fabrica e a rede). O cabecalho `Projeto consultado:` e `Não lido:` e
+ * contrato do RM-052 com os hosts e fica igual nas duas linguas.
+ *
+ * F2b (G2 e D1 da thread ork-rm061f2b): o texto que o proprio comando monta e que tambem vai ao ledger ou
+ * ao `--json` (o detalhe de uma claim reexecutada, o bloqueio do ship, a razao do retry) nasce em pt-BR por
+ * `textoDoCatalogo`, dentro do escopo da gravacao, e a impressao o remonta no locale ativo por `remontar`.
+ * O registro dos montadores so existe nos comandos cobertos (`ligarRemontagem`); o servidor MCP e o cron
+ * nunca o ligam. O que outro processo gravou, a policy avaliada e a saida de ferramenta externa saem como
+ * vieram, e tambem (G5) o proximo passo e o estado da entrega de uma thread parada no condutor
+ * (`parado-no-condutor.ts`, a familia de entregas), ate a F3. Motivo tipado, acao e bloqueio do retry, codigo,
+ * comando e sha saem iguais nas duas linguas (G4); valor de estado mostrado em tabela ou entre parenteses (a
+ * acao do `registrar-pr`, o tipo da autorizacao do ship, o status da thread, o veredito e a cobertura do
+ * CHECK-REVERIFY, o titulo do grupo do roadmap, a classe do item do pulse) e dado do `--json` e so se traduz
+ * na impressao, pelo id (D4).
+ *
+ * F3a (D1 a D3 da thread ork-rm061f3a): o que o CLI escreve em arquivo para pessoas e agentes lerem (os comentarios
+ * do `orkastery.yaml`, o bloco do `AGENTS.md`, o bloco da experiencia no `CLAUDE.md` e os modelos do `ork docs init`)
+ * nasce na lingua do dono no momento da geracao, pela familia `gerados` e por `core/assets/docs-en/`.
+ * O gerador recebe o locale por parametro, com pt-BR por omissao, e so a entrada do CLI passa a lingua do dono: o
+ * locale ativo nunca escolhe a lingua de um arquivo. Chave, valor e marcador do arquivo nao mudam com a lingua.
+ *
+ * Ingles (D8): curto, no imperativo onde e instrucao, com os mesmos termos em todo o CLI (`thread`,
+ * `phase`, `claim`, `verify`, `ship`, `pulse`, `lease`, `ledger`, `worktree`, `slug`). Comando, flag
+ * e identificador dentro de frase vao entre crases; valor que e so um comando (a linha `fix:`) fica nu.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErroDoCatalogo = exports.COMANDOS_COM_LOCALE = exports.LOCALE_PADRAO = void 0;
+exports.chaveDoLocale = chaveDoLocale;
+exports.cobreLocale = cobreLocale;
+exports.localeDe = localeDe;
+exports.resolverLocale = resolverLocale;
+exports.ativarLocale = ativarLocale;
+exports.localeAtivo = localeAtivo;
+exports.comLocale = comLocale;
+exports.msg = msg;
+exports.mensagemDoErro = mensagemDoErro;
+exports.ligarRemontagem = ligarRemontagem;
+exports.textoDoCatalogo = textoDoCatalogo;
+exports.remontar = remontar;
+exports.nomeDoCheck = nomeDoCheck;
+const locale_onboarding_1 = require("./locale-onboarding");
+const locale_thread_1 = require("./locale-thread");
+const locale_phase_1 = require("./locale-phase");
+const locale_ajuda_1 = require("./locale-ajuda");
+const locale_verify_1 = require("./locale-verify");
+const locale_ship_1 = require("./locale-ship");
+const locale_retry_1 = require("./locale-retry");
+const locale_master_1 = require("./locale-master");
+const locale_pulse_1 = require("./locale-pulse");
+const locale_roadmap_1 = require("./locale-roadmap");
+const locale_gerados_1 = require("./locale-gerados");
+exports.LOCALE_PADRAO = 'pt-BR';
+/**
+ * Comandos cujo texto ja sai pelo catalogo, por `comando` ou por `comando subcomando`; `comando ?` e o
+ * subcomando desconhecido (o erro de uso e do proprio comando). Os demais seguem em pt-BR. Ficam de
+ * fora por decisao (D2 da F2a): `doctor --modo`, `thread new --from-finding`, `onboarding sync`,
+ * `experiencia uninstall` e `thread list|close|entrega`. A F2b (G3) acrescenta `verify` (com `--baseline`),
+ * `ship`, `ship registrar-pr`, `retry plan`, `retry run`, `master` (o indice), `master aceitar-omissao` e
+ * `master pedir`, `pulse` (sem `responder` nem `cadencia`) e `roadmap status`. A F3a (D5) acrescenta `docs init`;
+ * `docs verificar` e `docs sincronizar` seguem em pt-BR.
+ */
+exports.COMANDOS_COM_LOCALE = ['doctor', 'init', 'onboarding show', 'onboarding set', 'onboarding reset',
+    'onboarding ?', 'experiencia show', 'experiencia ?', 'thread new', 'thread status', 'thread ?',
+    'phase list', 'phase run', 'phase ?', 'verify', 'ship', 'ship registrar-pr', 'retry plan', 'retry run',
+    'master', 'master aceitar-omissao', 'master pedir', 'pulse', 'roadmap status', 'docs init'];
+/** Os comandos com subcomando: o padrao (sem subcomando) e os conhecidos; o resto vira `?`. */
+const FAMILIAS = new Map([
+    ['onboarding', { padrao: 'show', conhecidos: ['show', 'set', 'reset', 'sync'] }],
+    ['experiencia', { padrao: 'show', conhecidos: ['show', 'uninstall'] }],
+    ['thread', { padrao: 'list', conhecidos: ['new', 'list', 'status', 'close', 'entrega'] }],
+    ['phase', { padrao: null, conhecidos: ['run', 'list'] }],
+    ['retry', { padrao: null, conhecidos: ['plan', 'run', 'policy', 'parse', 'list', 'resume', 'cancel'] }],
+    ['roadmap', { padrao: 'reservas', conhecidos: ['reservas', 'status', 'feat', 'pegar', 'soltar'] }],
+    ['docs', { padrao: 'verificar', conhecidos: ['verificar', 'sincronizar', 'init'] }],
+]);
+/** A entrada de `COMANDOS_COM_LOCALE` que a linha de comando pede, com o subcomando padrao de cada um. */
+function chaveDoLocale(posicionais, opcoes) {
+    const [comando = '', bruto] = posicionais;
+    // F2b (D2): `ork ship <thread>` tem a thread no lugar do subcomando; so `registrar-pr` e rota propria.
+    if (comando === 'ship')
+        return bruto === 'registrar-pr' ? 'ship registrar-pr' : 'ship';
+    if (comando === 'master')
+        return chaveDoMaster(bruto, opcoes);
+    // `ork pulse` le qualquer posicional como o pulse de sempre; `responder` e `cadencia` sao rotas proprias.
+    if (comando === 'pulse')
+        return bruto === 'responder' || bruto === 'cadencia' ? `pulse ${bruto}` : 'pulse';
+    const familia = FAMILIAS.get(comando);
+    if (!familia)
+        return comando;
+    const sub = comando === 'onboarding' && 'reset' in opcoes ? 'reset' : bruto ?? familia.padrao;
+    return `${comando} ${sub !== null && familia.conhecidos.includes(sub) ? sub : '?'}`;
+}
+/** Os subcomandos do `ork master` que nao seguem o locale (G3 da F2b): cada um e rota propria. */
+const SUBCOMANDOS_DO_MASTER = ['audit', 'digest', 'migrar', 'classes', 'ratificar', 'batch', 'propor'];
+/**
+ * A rota do `ork master`, na mesma ordem em que o comando a decide: `pedir` (nunca com `--formato json`),
+ * os subcomandos proprios, `--batch`, o aceite por omissao e, sem nada, o indice. A thread sozinha e a nota
+ * (`--score`), que segue em pt-BR.
+ */
+function chaveDoMaster(bruto, opcoes) {
+    if (bruto === 'pedir')
+        return opcoes.formato === 'json' ? 'master pedir json' : 'master pedir';
+    if (bruto !== undefined && SUBCOMANDOS_DO_MASTER.includes(bruto))
+        return `master ${bruto}`;
+    if (opcoes.batch !== undefined)
+        return 'master batch';
+    if (opcoes['aceitar-omissao'] !== undefined)
+        return 'master aceitar-omissao';
+    return bruto === undefined ? 'master' : 'master <thread>';
+}
+/** O comando pede o texto pelo locale? Nunca com `--json`, nem nos recortes da D2. */
+function cobreLocale(posicionais, opcoes) {
+    if (opcoes.json !== undefined)
+        return false;
+    if (posicionais[0] === 'doctor' && opcoes.modo !== undefined)
+        return false;
+    if (opcoes['from-finding'] !== undefined || opcoes['do-achado'] !== undefined)
+        return false;
+    return exports.COMANDOS_COM_LOCALE.includes(chaveDoLocale(posicionais, opcoes));
+}
+/** `en_US.UTF-8`, `en-GB`, `en` viram `en`; `pt_BR.UTF-8`, `pt` viram pt-BR; o resto, undefined. */
+function localeDe(valor) {
+    if (typeof valor !== 'string')
+        return undefined;
+    const lingua = valor.trim().split(/[.@]/)[0].replace(/_/g, '-').split('-')[0].toLowerCase();
+    if (lingua === 'en')
+        return 'en';
+    if (lingua === 'pt')
+        return 'pt-BR';
+    return undefined;
+}
+/** O locale do processo: a escolha do onboarding vence o ambiente; sem nenhum, pt-BR. */
+function resolverLocale(ownerLanguage, env = process.env) {
+    if (typeof ownerLanguage === 'string' && ownerLanguage.trim()) {
+        return { locale: localeDe(ownerLanguage) ?? exports.LOCALE_PADRAO, origem: 'manifesto' };
+    }
+    for (const nome of ['LC_ALL', 'LC_MESSAGES', 'LANG']) {
+        const v = env[nome];
+        if (v && v.trim())
+            return { locale: localeDe(v) ?? exports.LOCALE_PADRAO, origem: nome };
+    }
+    return { locale: exports.LOCALE_PADRAO, origem: 'padrao' };
+}
+let ativo = exports.LOCALE_PADRAO;
+/** Fixa o locale do processo (o CLI, nos comandos de `COMANDOS_COM_LOCALE`; os testes). */
+function ativarLocale(locale) {
+    ativo = locale ?? exports.LOCALE_PADRAO;
+}
+function localeAtivo() {
+    return ativo;
+}
+/**
+ * Roda `fn` no locale pedido e volta ao anterior, mesmo com erro. Nos comandos cobertos, o que grava
+ * estado roda em `comLocale('pt-BR', ...)`: o texto sai em ingles, o dado gravado nao muda (D1, D6).
+ */
+function comLocale(locale, fn) {
+    const anterior = ativo;
+    ativo = locale;
+    try {
+        return fn();
+    }
+    finally {
+        ativo = anterior;
+    }
+}
+// ---------------------------------------------------------------------------
+// Catalogo
+// ---------------------------------------------------------------------------
+const PT_BR = {
+    cli: {
+        /** Prefixo do erro que a entrada do CLI imprime (D11). */
+        erro: (mensagem) => `erro: ${mensagem}`,
+        subcomandoDesconhecido: (comando, sub) => `subcomando desconhecido: ${comando} ${sub}`,
+        /** `exigirManifesto` fora de um projeto: o primeiro erro de quem chega (D14). */
+        manifestoNaoEncontrado: (nome, dir) => `manifesto ${nome} nao encontrado a partir de ${dir}. Rode: ork init`,
+    },
+    horario: {
+        brasilia: 'horário de Brasília',
+        legendaBrasilia: 'Horários de Brasília.',
+        legenda: (rotulo) => `Horários em ${rotulo}.`,
+        duracaoDesconhecida: 'tempo desconhecido',
+        menosDeUmMin: 'menos de 1 min',
+        /** `faltaPara` (ratelimit.ts): quanto falta para o pedido da fila liberar. */
+        jaLiberou: 'ja liberou',
+        emMinutos: (n) => `em ${n} min`,
+        emHoras: (h, mm) => `em ${h}h${mm}`,
+    },
+    doctor: {
+        titulo: 'ork doctor: o que vale nesta maquina agora',
+        correcao: 'correcao',
+        bloqueado: (falhas, avisos) => `Veredito: BLOQUEADO (${falhas} fail, ${avisos} warn). Corrija os itens acima antes de despachar fase.`,
+        pronto: (avisos) => `Veredito: PRONTO (${avisos} warn). Despacho de fase liberado por \`ork phase run\`.`,
+        /** Nome de cada check como aparece no texto; o `Check.nome` gravado nao muda. */
+        nomes: {},
+        instaleNode: 'instale Node 20 ou superior',
+        gitAusente: 'nao encontrado no PATH',
+        instaleGit: 'instale o git',
+        branch: (branch, semCommit) => `branch ${branch}${semCommit ? ' (sem commit)' : ''}`,
+        foraDeRepo: 'fora de um repositorio git',
+        rodeDentroDeRepo: 'rode o ork dentro de um repositorio git',
+        versaoDesconhecida: 'versao desconhecida',
+        codexAusenteUsado: 'binario `codex` fora do PATH (o projeto despacha por ele: veja despacho pelo codex)',
+        codexAusenteOpcional: 'binario `codex` fora do PATH (opcional: claude-bg e o runtime padrao)',
+        instaleCodex: 'para despachar pelo codex, instale o Codex CLI e autentique com `codex login`',
+        sandboxOk: '`codex sandbox true` executa nesta maquina',
+        sandboxFalhou: (detalhe) => `sonda \`codex sandbox true\` falhou: ${detalhe}`,
+        sandboxCorrecao: (confirmar) => 'instale o pacote bubblewrap do sistema (o bwrap embutido nao cria user namespace ' +
+            `nesta maquina) ou declare runtime.sandbox: danger-full-access ciente do risco e confirme nesta maquina com ${confirmar}`,
+        manifestoAusente: (nome, dir) => `${nome} nao encontrado a partir de ${dir}`,
+        rodeInit: 'ork init',
+        entreNoRepoEInit: 'entre no repositorio do projeto (ou crie um com git init e o primeiro commit) e rode ork init',
+        corrijaManifesto: 'corrija o manifesto e rode ork doctor de novo',
+        abbrevOk: (abbrev) => `"${abbrev}" (parte 1 do slug de sessao)`,
+        abbrevCorrecao: 'defina project.abbrev com ate 3 caracteres [a-z0-9]',
+        modos: (padrao, permitidos) => `padrao ${padrao}; permitidos ${permitidos}`,
+        fusoDoManifesto: (fuso, chave, rotulo) => `${fuso} (${chave}); horarios para pessoas em ${rotulo}`,
+        fusoDoSistema: (fuso, chave) => `${fuso} (fuso do sistema; ${chave} nao configurado)`,
+        fusoCorrecao: (chave) => `corrija ${chave} com um nome IANA`,
+        filaVazia: 'vazia: nenhuma fase morreu por limite de uso neste projeto',
+        filaResumo: (esperando, escalados) => `${esperando} aguardando janela, ${escalados} escalado(s) para humano`,
+        filaProxima: (quando) => `; proxima janela em ${quando}`,
+        estadoOk: (dir, qtd) => `${dir} (${qtd} thread(s))`,
+        estadoAusente: (dir) => `${dir} ausente`,
+        estadoCorrecao: 'ork init cria o diretorio de estado',
+        claudeSemLogin: (detalhe, auth) => `${detalhe}; ${auth}: o despacho pelo claude-bg falharia`,
+        claudeLoginPago: 'faca o login de assinatura (claude.ai) no `claude`, sem API key nem provider de nuvem',
+        claudeLogin: 'rode `claude` uma vez, faca o login de assinatura (/login) e aceite a confianca no diretorio do projeto; ' +
+            'ou crie um perfil com ork accounts add <id> --runtime claude-bg --dir <pasta>',
+        onboardingPendente: (n, etapas) => `${n} etapa(s) pendente(s): ${etapas}`,
+        onboardingCompleto: '9 etapas respondidas',
+        foraDaRede: 'fora da rede; ork network entrar poe esta maquina na rede da pessoa',
+        manifestoOk: (caminho, bytes, limite) => `${caminho} (${bytes} B de ${limite})`,
+        politicaViolada: (politica, envs) => `politica ${politica} violada: ${envs} redireciona o despacho do claude`,
+        politicaComPaga: (politica, envs) => `politica ${politica}; despacho segue na assinatura local, mas ha credencial paga no ambiente: ${envs}`,
+        politicaLimpa: (politica) => `politica ${politica}; nenhuma variavel de provider pago ativa`,
+        removaDoAmbiente: (envs) => `remova do ambiente: ${envs} (o despacho usa a assinatura Claude local)`,
+        nuncaDespachePorPaga: (envs) => `nenhuma acao obrigatoria; nunca despache fase por ${envs}`,
+        providersAtivos: (nomes) => `nomes ativos: ${nomes}`,
+        nenhumProvider: 'nenhum nome da lista de provider ativo',
+        memoriaFiles: 'files (fallback honesto: handoff por arquivos, ponteiro path#ancora)',
+        embeddingNone: 'memory.embedding com provider none: busca por significado desligada',
+        semPerfis: 'nenhum perfil configurado: cada runtime despacha pelo ambiente do processo',
+        // F2a: o resto do doctor.
+        manifestoForaDoRepo: (nome, caminho, topo) => `o ${nome} lido fica fora deste repositorio (${caminho}): o ork conduz o projeto daquela pasta, nao o de ${topo}`,
+        manifestoForaDoRepoCorrecao: (topo) => `rode ork init na raiz deste repositorio (${topo}); se o manifesto de fora ` +
+            'nasceu por engano, apague-o junto com o AGENTS.md e o .orkastery/ ao lado dele',
+        storeInvalido: (erro) => `store de perfis invalido: ${erro}`,
+        storeCorrecao: 'o store fica em .orkastery/private/runtime-profiles.json (arquivo 0600, pasta 0700)',
+        contaPaga: 'provider pago (nunca despacha)',
+        contaInconclusiva: 'conferencia de login inconclusiva',
+        contaSemLogin: 'sem login',
+        contaPronta: 'pronto',
+        contaFora: (estado, ate) => `${estado}${ate ? ` ate ${ate}` : ''}`,
+        contasCorrecao: 'ork accounts check marca os perfis (sem-auth, provider-pago); ork accounts add refaz o login de assinatura ' +
+            'pelo proprio CLI, nunca copiando credencial',
+        embeddingPago: (variavel) => `memory.embedding.api_key_env declara ${variavel}, nome da lista de provider pago`,
+        embeddingPagoCorrecao: 'use uma chave dedicada ao Orkastery com nome proprio, por exemplo ORKASTERY_EMBEDDING_API_KEY',
+        embeddingSemVariavel: (provider) => `memory.embedding com provider ${provider} sem api_key_env`,
+        embeddingSemVariavelCorrecao: 'declare em memory.embedding.api_key_env o NOME da variavel com a chave dedicada',
+        embeddingRecusada: (variavel) => `${variavel} tem valor recusado: parece URL, DSN ou texto com espaco (valor nunca impresso)`,
+        embeddingRecusadaCorrecao: (variavel) => `confira se ${variavel} guarda a chave dedicada, e nao outra credencial`,
+        embeddingPresente: (variavel, provider, modelo) => `${variavel} presente no ambiente (valor nunca impresso); ${provider} ${modelo}`,
+        embeddingAusente: (variavel) => `${variavel} ausente do ambiente: a busca por significado usa o fallback local ou cai para FTS; o regime nao muda`,
+        embeddingAusenteCorrecao: (variavel) => `exporte ${variavel} com a chave dedicada ao Orkastery (com limite de credito no painel do provider)`,
+        donoOutro: (total, dir, uids, uid, exemplos, parcialDe) => `${total} entrada(s) de ${dir} com outro dono (uid ${uids}; o do repositorio e ${uid}): ${exemplos}; o git do dono nao grava nelas, ` +
+            `e o fetch e o commit falham${parcialDe !== null ? ` (conferencia parcial: mais de ${parcialDe} entradas)` : ''}`,
+        donoCorrecao: (comando) => `${comando} (o ork nao roda isso sozinho)`,
+        donoParcial: (teto, dir) => `mais de ${teto} entradas em ${dir}: conferencia parcial, sem outro dono ate aqui`,
+        donoParcialCorrecao: (comando) => `confira o resto com: ${comando}`,
+        donoOk: (vistos, dir, uid) => `${vistos} entradas de ${dir} com o dono do repositorio (uid ${uid})`,
+        entrevistaMemoria: (escolha, declarado) => `entrevista escolheu ${escolha}; manifesto declara ${declarado}`,
+        entrevistaMemoriaCorrecao: (escolha) => `revise memory.mode: ${escolha} em orkastery.yaml; a entrevista não altera o manifesto`,
+        entrevistaFuso: (informado, declarado, chave) => `entrevista informou ${informado}; manifesto declara ${declarado ?? `${chave} ausente`}`,
+        entrevistaFusoCorrecao: (chave, informado) => `revise ${chave}: "${informado}" em orkastery.yaml; a entrevista não altera o manifesto`,
+        claudeOpcional: (fallback) => 'binario `claude` fora do PATH (opcional para as fases: nenhum bloco dos modos permitidos despacha pelo claude-bg' +
+            (fallback ? `; o fallback de ${fallback.blocos} bloco(s) cai nele e falharia: ${fallback.texto}` : '') +
+            '; o ork audit run ainda despacha por ele)',
+        claudeOpcionalCorrecao: 'para despachar pelo claude-bg (e rodar ork audit run), instale o Claude Code e garanta `claude` no PATH',
+        claudeAusente: (principal) => 'binario `claude` fora do PATH' +
+            (principal ? `; ${principal.blocos} bloco(s) dos modos permitidos despacham por ele (${principal.texto})` : ''),
+        claudeAusenteCorrecao: 'instale o Claude Code e garanta `claude` no PATH; so com o Codex, passe cada bloco para ele ' +
+            '(ork setup <modo> --bloco N --runtime codex --model <modelo>) ou tire o modo de conduction.allowed_modes ' +
+            '(mantenha o conduction.default_mode entre os permitidos)',
+        origemDoCodex: (pelaAdapter, blocos) => [pelaAdapter ? 'runtime.adapter: codex' : '',
+            blocos ? `${blocos.blocos} bloco(s) dos modos permitidos no codex (${blocos.texto})` : ''].filter(Boolean).join(' e '),
+        codexForaNoDespacho: (origem) => `${origem}, mas o binario \`codex\` esta fora do PATH`,
+        codexSandboxQuebrado: (origem, sandbox) => `${origem} com sandbox "${sandbox}", mas o sandbox nao executa nesta maquina (o agente narraria sucesso sem rodar nada)`,
+        codexSandboxOk: (origem, sandbox) => `${origem} com sandbox "${sandbox}"`,
+        codexSemConfirmacao: (origem, sandbox) => `${origem} com sandbox "${sandbox}" pedido pelo orkastery.yaml, ` +
+            'sem a confirmacao desta maquina: o despacho recusa com runtime.sandbox-nao-confirmado',
+        codexForaNoDespachoCorrecao: 'instale o Codex CLI e autentique com `codex login` (assinatura, nunca API key)',
+        codexSandboxQuebradoCorrecao: (confirmar) => `instale o bubblewrap do sistema, ou declare runtime.sandbox: danger-full-access ciente do risco e confirme nesta maquina com ${confirmar}`,
+        codexSemConfirmacaoCorrecao: (confirmar) => `${confirmar} (ou volte o manifesto para workspace-write)`,
+        fabricaPedida: 'o orkastery.yaml pede fabrica.compartilhada: true e esta maquina nao entrou: nada desta maquina e publicado no remoto',
+        fabricaPedidaCorrecao: 'ork fabrica entrar, se esta maquina deve publicar o retrato dela no remoto do projeto',
+        pastaForaDaRaiz: (dir) => `worktree.dir "${dir}" leva para fora da raiz e esta maquina nao confirmou: a criacao de worktree recusa com worktree.dir-fora-da-raiz`,
+        pastaForaDaRaizCorrecao: (confirmar) => `${confirmar}, ou volte worktree.dir para dentro do projeto`,
+        fonteDaMemoria: (fonte, divergente) => `${fonte}${divergente ? ' (cópia da worktree divergente preservada)' : ''}`,
+        regimeDegradado: (motivo, detalhe) => `pedido orkmind, efetivo files (${motivo}): ${detalhe}`,
+        regimeOrkmind: (tenant, variavel) => `orkmind ativo no tenant "${tenant}" pela variavel ${variavel}`,
+        filaEscaladoCorrecao: 'pedido escalado alem do limite de retry.max_tentativas: ork retry list e ork gate request <thread>',
+        filaEsperaCorrecao: 'ork retry resume retoma o que ja liberou',
+        governanca: (g) => `${g.usuario}, Claude e Codex, global com histórico: ${g.total} sessões; ` +
+            `${g.semThread} sem thread; ${g.ambiguas} ambíguas; ` +
+            `inventário ${g.ok ? 'válido' : 'INCOMPLETO (zero não comprovado)'}` +
+            (g.ausentes.length ? `; fonte ausente: ${g.ausentes.join(', ')}` : ''),
+        governancaCorrecao: 'ork sessions --global --all --json; adote identidades sem vínculo com ork sessions adopt <id>',
+        umaskNaoMedido: 'umask do processo nao medido nesta plataforma',
+        umaskOk: (umask) => `umask ${umask} nega escrita de grupo e outros`,
+        umaskAberto: (umask) => `umask ${umask} permite escrita de grupo ou outros: o que o runtime criar sera recusado pelo sensor (bits 0o022)`,
+        umaskCorrecao: 'umask 022 (ou 077) no shell que roda o ork e os runtimes',
+        estadoNaoDiretorio: (dir) => `${dir} nao e diretorio real`,
+        estadoAberto: (dir, modo) => `${dir} com modo ${modo}: grupo ou outros podem escrever no estado`,
+        estadoComModo: (dir, modo) => `${dir} com modo ${modo}`,
+        privadaAusente: (dir) => `${dir} ausente: criada sob demanda com 0700`,
+        privadaAberta: (dir, modo) => `${dir} precisa ser diretorio 0700 do proprio usuario (modo ${modo}): recibo HITL e perfis recusam`,
+        privadaOk: (dir) => `${dir} com modo 0700`,
+        cronSemComando: 'comando crontab ausente nesta maquina',
+        cronFalhou: (detalhe) => `crontab -l falhou: ${detalhe}`,
+        cronSaiu: (codigo) => `crontab -l saiu ${codigo}`,
+        cronAdicione: (linha) => `adicione ao crontab (crontab -e), como no template monitor/pulse.cron: ${linha}`,
+        cronSemLeitura: (motivo) => `pulse-host.json presente, mas sem crontab para ler (${motivo}): a varredura nao bate`,
+        cronSemLinha: (script) => `pulse-host.json presente, e nenhuma linha do crontab roda ${script}: o resumo nao sai`,
+        cronOk: (linhas) => `varredura no cron a cada 15 minutos ou menos (${linhas} linha(s))`,
+        cronRitmo: (intervalo) => intervalo === null ? 'com horario que o doctor nao le'
+            : intervalo === 60 ? 'de hora em hora' : `a cada ${intervalo} minutos`,
+        cronLento: (ritmo, linha) => `a varredura do pulse bate ${ritmo} (\`${linha}\`): a cadencia por tag (RM-039) pede 15 minutos`,
+        cronTroque: (linha) => `troque a linha no crontab (crontab -e) por: ${linha}`,
+        // RM-063 (F1): com thread aberta, a falta da batida reprova, com ou sem pulse-host.json.
+        batidaAusente: (abertas, detalhe) => `${abertas} thread(s) aberta(s) e nenhuma batida da varredura: ${detalhe}; a fabrica para sem ninguem saber`,
+        batidaSemLeitura: (motivo) => `sem crontab para ler (${motivo})`,
+        batidaSemLinha: (script) => `nenhuma linha do crontab roda ${script} para este projeto`,
+        batidaInstale: (comando) => `${comando} (instala a linha do template monitor/pulse.cron no crontab desta maquina)`,
+        batidaPeloLog: (minutos) => `nenhuma linha no crontab, mas a varredura rodou ha ${minutos} min (hitl.log): a batida vem de outro agendador`,
+        redeSaiu: 'fora da rede (saiu com ork network sair)',
+        redeMembroHerdado: 'membro herdado da fabrica',
+        redeMembro: 'membro',
+        redeCasa: (casa) => `casa ${casa}`,
+        redeSemCasa: 'casa ainda nao gravada',
+        redeBatida: (quando, idade) => `ultima batida ${quando} (ha ${idade})`,
+        redeSemBatida: 'nenhuma batida publicada',
+        redeFalha: (quando, origem, erro) => `ultima falha ${quando}${origem ? ` (${origem})` : ''}: ${erro}`,
+        redeSemDetalhe: 'sem detalhe',
+        redeSemFalha: 'nenhuma falha no rede.log',
+        redeParadaCorrecao: 'a batida sai do pulse: confira o cron do pulse e rode ork network publicar',
+        redeSemCasaCorrecao: 'a casa da rede ainda nao existe: o dono roda ork network entrar, que cria o repositorio privado; ' +
+            'ou ork network sair, para tirar esta maquina da rede',
+        redeSemForjaCorrecao: 'faca login na forja (gh auth login ou glab auth login) e rode ork network publicar',
+        redePublicaCorrecao: 'torne a casa da rede privada na forja; nada e publicado num repositorio publico',
+        redeNomeCorrecao: 'escolha outro nome com ork network entrar --maquina NOME, ou tome este com --forcar',
+        redeOutraCorrecao: 'ork network status mostra as lacunas; ork network publicar tenta de novo',
+        /**
+         * Redacao do check "analisadores do grafo" (a forma de `RedacaoDosAnalisadores`). A familia do grafo nao
+         * importa o catalogo (fronteira do KG3): ela guarda o pt-BR para o `ork grafo status`, e o doctor passa
+         * esta. Um teste confere que o pt-BR das duas e o mesmo.
+         */
+        grafo: {
+            recusa: (motivo) => `${motivo}: o ork grafo indexar recusa nesta instalacao, e sem o indice as consultas e as tools ork_grafo_* tambem`,
+            soEsm: (versaoDoNode) => `o micromark e so ESM, e este Node (${versaoDoNode}) nao o carrega por require: use Node 20.19, ` +
+                '22.12 ou mais novo, sem a opcao --no-experimental-require-module (na linha de comando ou no NODE_OPTIONS)',
+            reinstale: (fixada) => `reinstale o ork global, que traz os analisadores como dependencias: npm install -g @orkastery/cli${fixada}` +
+                ' (instalado dentro de um projeto ou pelo npx, o npm deixa os analisadores fora do pacote do ork, e o grafo os recusa)',
+        },
+        /** A fonte de sessoes ausente, como o inventario a nomeia (dado); o ingles so troca o rotulo da conta. */
+        fonteDaSessao: (origem) => origem,
+    },
+    onboarding: locale_onboarding_1.ONBOARDING_PT_BR,
+    thread: locale_thread_1.THREAD_PT_BR,
+    phase: locale_phase_1.PHASE_PT_BR,
+    ajuda: locale_ajuda_1.AJUDA_PT_BR,
+    verify: locale_verify_1.VERIFY_PT_BR,
+    ship: locale_ship_1.SHIP_PT_BR,
+    retry: locale_retry_1.RETRY_PT_BR,
+    master: locale_master_1.MASTER_PT_BR,
+    pulse: locale_pulse_1.PULSE_PT_BR,
+    roadmap: locale_roadmap_1.ROADMAP_PT_BR,
+    gerados: locale_gerados_1.GERADOS_PT_BR,
+    init: {
+        foraDoRepositorio: (dir) => `init.fora-do-repositorio: ${dir} não está num repositório git; nada foi criado. ` +
+            'Entre no repositório do projeto (ou crie um com git init e o primeiro commit) e rode ork init de novo.',
+        jaExiste: (caminho) => `Manifesto ja existe: ${caminho}`,
+        nadaSobrescrito: 'Nada foi sobrescrito. Use --force para regerar.',
+        agentsMd: (estado, caminho) => `AGENTS.md ${estado}: ${caminho}`,
+        agentsMdLinha: (estado, caminho) => `  AGENTS.md   ${estado}: ${caminho}`,
+        estadosAgents: { criado: 'criado', atualizado: 'atualizado', inalterado: 'inalterado' },
+        criado: (caminho) => `Manifesto criado: ${caminho}`,
+        projeto: (nome, abbrev) => `  projeto     ${nome} (abbrev "${abbrev}")`,
+        branchBase: (branch) => `  branch base ${branch}`,
+        gerenciador: (g) => `  gerenciador ${g}`,
+        verify: (v) => `  verify      ${v}`,
+        semScript: '(nenhum script detectado)',
+        estado: (dir) => `  estado      ${dir}/ fora do git (${dir}/.gitignore com *; o seu .gitignore fica como está)`,
+        proximoPasso: 'Proximo passo: ork doctor; depois ork onboarding para conduzir a entrevista do projeto.',
+    },
+};
+const EN = {
+    cli: {
+        erro: (mensagem) => `error: ${mensagem}`,
+        subcomandoDesconhecido: (comando, sub) => sub === undefined ? `missing subcommand: ${comando}` : `unknown subcommand: ${comando} ${sub}`,
+        manifestoNaoEncontrado: (nome, dir) => `\`${nome}\` not found in ${dir} or any parent directory; run \`ork init\` first.`,
+    },
+    horario: {
+        brasilia: 'Brasília time',
+        legendaBrasilia: 'Times in Brasília time.',
+        legenda: (rotulo) => `Times in ${rotulo}.`,
+        duracaoDesconhecida: 'unknown time',
+        menosDeUmMin: 'less than 1 min',
+        jaLiberou: 'already released',
+        emMinutos: (n) => `in ${n} min`,
+        emHoras: (h, mm) => `in ${h}h${mm}`,
+    },
+    doctor: {
+        titulo: 'ork doctor: what holds on this machine now',
+        correcao: 'fix',
+        bloqueado: (falhas, avisos) => `Verdict: BLOCKED (${falhas} fail, ${avisos} warn). Fix the items above before dispatching a phase.`,
+        pronto: (avisos) => `Verdict: READY (${avisos} warn). Phase dispatch allowed through \`ork phase run\`.`,
+        nomes: {
+            'repositorio': 'repository',
+            'manifesto': 'manifest',
+            'manifesto do repositorio': 'repository manifest',
+            'analisadores do grafo': 'graph analyzers',
+            'abbrev do projeto': 'project abbrev',
+            'modos de conducao': 'conduction modes',
+            'fuso do dono': 'owner time zone',
+            'despacho pelo codex': 'codex dispatch',
+            'custo e provider herdado': 'cost and inherited provider',
+            'provider efetivo da fabrica': 'effective factory provider',
+            'fonte da memoria': 'memory source',
+            'regime de memoria': 'memory regime',
+            'chave de embedding': 'embedding key',
+            'fila de rate limit': 'rate limit queue',
+            'estado do projeto': 'project state',
+            'contas por runtime': 'accounts per runtime',
+            'governanca de sessoes': 'session governance',
+            'dono do .git': '.git owner',
+            'onboarding memoria': 'onboarding memory',
+            'onboarding fuso': 'onboarding time zone',
+            'rede': 'network',
+            'sandbox do codex': 'codex sandbox',
+            'permissoes do estado': 'state permissions',
+            'pasta privada': 'private folder',
+            'cadencia do pulse no cron': 'pulse cron cadence',
+            'fabrica compartilhada': 'shared factory',
+            'pasta das worktrees': 'worktree folder',
+        },
+        instaleNode: 'install Node 20 or later',
+        gitAusente: 'not found on PATH',
+        instaleGit: 'install git',
+        branch: (branch, semCommit) => `branch ${branch}${semCommit ? ' (no commit)' : ''}`,
+        foraDeRepo: 'outside a git repository',
+        rodeDentroDeRepo: 'run `ork` inside a git repository',
+        versaoDesconhecida: 'unknown version',
+        codexAusenteUsado: '`codex` binary not on PATH (the project dispatches through it: see codex dispatch)',
+        codexAusenteOpcional: '`codex` binary not on PATH (optional: claude-bg is the default runtime)',
+        instaleCodex: 'to dispatch through codex, install the Codex CLI and sign in with `codex login`',
+        sandboxOk: '`codex sandbox true` runs on this machine',
+        sandboxFalhou: (detalhe) => `probe \`codex sandbox true\` failed: ${detalhe}`,
+        sandboxCorrecao: (confirmar) => 'install the system bubblewrap package (the bundled bwrap cannot create a user namespace ' +
+            `on this machine) or declare \`runtime.sandbox: danger-full-access\` knowing the risk, and confirm on this machine with \`${confirmar}\``,
+        manifestoAusente: (nome, dir) => `${nome} not found in ${dir} or any parent directory`,
+        rodeInit: 'ork init',
+        entreNoRepoEInit: 'enter the project repository (or create one with `git init` and a first commit) and run `ork init`',
+        corrijaManifesto: 'fix the manifest and run `ork doctor` again',
+        abbrevOk: (abbrev) => `"${abbrev}" (part 1 of the session slug)`,
+        abbrevCorrecao: 'set project.abbrev with up to 3 characters [a-z0-9]',
+        modos: (padrao, permitidos) => `default ${padrao}; allowed ${permitidos}`,
+        fusoDoManifesto: (fuso, chave, rotulo) => `${fuso} (${chave}); times for people in ${rotulo}`,
+        fusoDoSistema: (fuso, chave) => `${fuso} (system time zone; ${chave} not set)`,
+        fusoCorrecao: (chave) => `set ${chave} to an IANA name`,
+        filaVazia: 'empty: no phase died from a usage limit in this project',
+        filaResumo: (esperando, escalados) => `${esperando} waiting for a window, ${escalados} escalated to a human`,
+        filaProxima: (quando) => `; next window at ${quando}`,
+        estadoOk: (dir, qtd) => `${dir} (${qtd} thread(s))`,
+        estadoAusente: (dir) => `${dir} missing`,
+        estadoCorrecao: '`ork init` creates the state directory',
+        claudeSemLogin: (detalhe, auth) => `${detalhe}; ${auth}: dispatch through claude-bg would fail`,
+        claudeLoginPago: 'sign in with a subscription (claude.ai) in `claude`, without an API key or a cloud provider',
+        claudeLogin: 'run `claude` once, sign in with your subscription (/login) and accept trust in the project directory; ' +
+            'or create a profile with `ork accounts add <id> --runtime claude-bg --dir <folder>`',
+        onboardingPendente: (n, etapas) => `${n} step(s) pending: ${etapas}`,
+        onboardingCompleto: '9 steps answered',
+        foraDaRede: 'outside the network; `ork network entrar` puts this machine on your network',
+        manifestoOk: (caminho, bytes, limite) => `${caminho} (${bytes} B of ${limite})`,
+        politicaViolada: (politica, envs) => `policy ${politica} violated: ${envs} redirects the claude dispatch`,
+        politicaComPaga: (politica, envs) => `policy ${politica}; dispatch stays on the local subscription, but there is a paid credential in the environment: ${envs}`,
+        politicaLimpa: (politica) => `policy ${politica}; no paid provider variable active`,
+        removaDoAmbiente: (envs) => `remove from the environment: ${envs} (dispatch uses the local Claude subscription)`,
+        nuncaDespachePorPaga: (envs) => `no action required; never dispatch a phase through ${envs}`,
+        providersAtivos: (nomes) => `active names: ${nomes}`,
+        nenhumProvider: 'no name from the provider list is active',
+        memoriaFiles: 'files (honest fallback: handoff through files, path#anchor pointer)',
+        embeddingNone: 'memory.embedding with provider none: semantic search is off',
+        semPerfis: 'no profile configured: each runtime dispatches through the process environment',
+        manifestoForaDoRepo: (nome, caminho, topo) => `the ${nome} that was read sits outside this repository (${caminho}): ork runs the project in that folder, not the one in ${topo}`,
+        manifestoForaDoRepoCorrecao: (topo) => `run \`ork init\` at the root of this repository (${topo}); if the outside manifest ` +
+            'was created by mistake, delete it together with the AGENTS.md and the .orkastery/ next to it',
+        storeInvalido: (erro) => `invalid profile store: ${erro}`,
+        storeCorrecao: 'the store lives in .orkastery/private/runtime-profiles.json (file 0600, folder 0700)',
+        contaPaga: 'paid provider (never dispatches)',
+        contaInconclusiva: 'login check inconclusive',
+        contaSemLogin: 'not signed in',
+        contaPronta: 'ready',
+        contaFora: (estado, ate) => `${estado}${ate ? ` until ${ate}` : ''}`,
+        contasCorrecao: '`ork accounts check` marks the profiles (sem-auth, provider-pago); `ork accounts add` redoes the subscription ' +
+            'login through the CLI itself, never copying a credential',
+        embeddingPago: (variavel) => `memory.embedding.api_key_env declares ${variavel}, a name from the paid provider list`,
+        embeddingPagoCorrecao: 'use a key dedicated to Orkastery, with its own name, for example ORKASTERY_EMBEDDING_API_KEY',
+        embeddingSemVariavel: (provider) => `memory.embedding with provider ${provider} and no api_key_env`,
+        embeddingSemVariavelCorrecao: 'declare in memory.embedding.api_key_env the NAME of the variable that holds the dedicated key',
+        embeddingRecusada: (variavel) => `${variavel} has a refused value: it looks like a URL, a DSN or text with spaces (the value is never printed)`,
+        embeddingRecusadaCorrecao: (variavel) => `check that ${variavel} holds the dedicated key, not another credential`,
+        embeddingPresente: (variavel, provider, modelo) => `${variavel} present in the environment (value never printed); ${provider} ${modelo}`,
+        embeddingAusente: (variavel) => `${variavel} missing from the environment: semantic search uses the local fallback or falls back to FTS; the regime does not change`,
+        embeddingAusenteCorrecao: (variavel) => `export ${variavel} with the key dedicated to Orkastery (with a credit limit in the provider dashboard)`,
+        donoOutro: (total, dir, uids, uid, exemplos, parcialDe) => `${total} entry(ies) in ${dir} owned by another user (uid ${uids}; the repository owner is ${uid}): ${exemplos}; ` +
+            `the owner's git cannot write to them, so fetch and commit fail${parcialDe !== null ? ` (partial check: more than ${parcialDe} entries)` : ''}`,
+        donoCorrecao: (comando) => `${comando} (ork never runs this on its own)`,
+        donoParcial: (teto, dir) => `more than ${teto} entries in ${dir}: partial check, no other owner so far`,
+        donoParcialCorrecao: (comando) => `check the rest with: ${comando}`,
+        donoOk: (vistos, dir, uid) => `${vistos} entries in ${dir} owned by the repository owner (uid ${uid})`,
+        entrevistaMemoria: (escolha, declarado) => `the interview chose ${escolha}; the manifest declares ${declarado}`,
+        entrevistaMemoriaCorrecao: (escolha) => `review memory.mode: ${escolha} in orkastery.yaml; the interview does not change the manifest`,
+        entrevistaFuso: (informado, declarado, chave) => `the interview gave ${informado}; ${declarado ? `the manifest declares ${declarado}` : `the manifest has no ${chave}`}`,
+        entrevistaFusoCorrecao: (chave, informado) => `review ${chave}: "${informado}" in orkastery.yaml; the interview does not change the manifest`,
+        claudeOpcional: (fallback) => '`claude` binary not on PATH (optional for phases: no block of the allowed modes dispatches through claude-bg' +
+            (fallback ? `; the fallback of ${fallback.blocos} block(s) lands on it and would fail: ${fallback.texto}` : '') +
+            '; `ork audit run` still dispatches through it)',
+        claudeOpcionalCorrecao: 'to dispatch through claude-bg (and run `ork audit run`), install Claude Code and make sure `claude` is on PATH',
+        claudeAusente: (principal) => '`claude` binary not on PATH' +
+            (principal ? `; ${principal.blocos} block(s) of the allowed modes dispatch through it (${principal.texto})` : ''),
+        claudeAusenteCorrecao: 'install Claude Code and make sure `claude` is on PATH; with Codex only, move each block to it ' +
+            '(`ork setup <mode> --bloco N --runtime codex --model <model>`) or remove the mode from conduction.allowed_modes ' +
+            '(keep conduction.default_mode among the allowed ones)',
+        origemDoCodex: (pelaAdapter, blocos) => [pelaAdapter ? 'runtime.adapter: codex' : '',
+            blocos ? `${blocos.blocos} block(s) of the allowed modes on codex (${blocos.texto})` : ''].filter(Boolean).join(' and '),
+        codexForaNoDespacho: (origem) => `${origem}, but the \`codex\` binary is not on PATH`,
+        codexSandboxQuebrado: (origem, sandbox) => `${origem} with sandbox "${sandbox}", but the sandbox does not run on this machine (the agent would narrate success without running anything)`,
+        codexSandboxOk: (origem, sandbox) => `${origem} with sandbox "${sandbox}"`,
+        codexSemConfirmacao: (origem, sandbox) => `${origem} with sandbox "${sandbox}" requested by \`orkastery.yaml\` but not confirmed ` +
+            'on this machine: dispatch is refused with `runtime.sandbox-nao-confirmado`',
+        codexForaNoDespachoCorrecao: 'install the Codex CLI and sign in with `codex login` (subscription, never an API key)',
+        codexSandboxQuebradoCorrecao: (confirmar) => `install the system bubblewrap, or declare \`runtime.sandbox: danger-full-access\` knowing the risk, and confirm on this machine with \`${confirmar}\``,
+        codexSemConfirmacaoCorrecao: (confirmar) => `\`${confirmar}\` (or set the manifest back to \`workspace-write\`)`,
+        fabricaPedida: '`orkastery.yaml` asks for `fabrica.compartilhada: true` and this machine has not joined: nothing from this machine is published to the remote',
+        fabricaPedidaCorrecao: '`ork fabrica entrar`, if this machine should publish its snapshot to the project remote',
+        pastaForaDaRaiz: (dir) => `\`worktree.dir\` "${dir}" points outside the project root and this machine has not confirmed it: worktree creation is refused with \`worktree.dir-fora-da-raiz\``,
+        pastaForaDaRaizCorrecao: (confirmar) => `\`${confirmar}\`, or move \`worktree.dir\` back inside the project`,
+        fonteDaMemoria: (fonte, divergente) => `${fonte}${divergente ? ' (divergent worktree copy kept)' : ''}`,
+        regimeDegradado: (motivo, detalhe) => `orkmind requested, files in effect (${motivo}): ${detalhe}`,
+        regimeOrkmind: (tenant, variavel) => `orkmind active in tenant "${tenant}" through the variable ${variavel}`,
+        filaEscaladoCorrecao: 'request escalated past the retry.max_tentativas limit: `ork retry list` and `ork gate request <thread>`',
+        filaEsperaCorrecao: '`ork retry resume` picks up what is already released',
+        governanca: (g) => `${g.usuario}, Claude and Codex, global with history: ${g.total} sessions; ` +
+            `${g.semThread} without a thread; ${g.ambiguas} ambiguous; ` +
+            `inventory ${g.ok ? 'valid' : 'INCOMPLETE (zero not proven)'}` +
+            (g.ausentes.length ? `; source missing: ${g.ausentes.join(', ')}` : ''),
+        governancaCorrecao: '`ork sessions --global --all --json`; adopt unlinked identities with `ork sessions adopt <id>`',
+        umaskNaoMedido: 'process umask not measured on this platform',
+        umaskOk: (umask) => `umask ${umask} denies write to group and others`,
+        umaskAberto: (umask) => `umask ${umask} allows write by group or others: whatever the runtime creates will be refused by the sensor (bits 0o022)`,
+        umaskCorrecao: '`umask 022` (or 077) in the shell that runs ork and the runtimes',
+        estadoNaoDiretorio: (dir) => `${dir} is not a real directory`,
+        estadoAberto: (dir, modo) => `${dir} with mode ${modo}: group or others can write to the state`,
+        estadoComModo: (dir, modo) => `${dir} with mode ${modo}`,
+        privadaAusente: (dir) => `${dir} missing: created on demand with 0700`,
+        privadaAberta: (dir, modo) => `${dir} must be a 0700 directory owned by the user (mode ${modo}): HITL receipts and profiles refuse it`,
+        privadaOk: (dir) => `${dir} with mode 0700`,
+        cronSemComando: 'crontab command missing on this machine',
+        cronFalhou: (detalhe) => `\`crontab -l\` failed: ${detalhe}`,
+        cronSaiu: (codigo) => `\`crontab -l\` exited ${codigo}`,
+        cronAdicione: (linha) => `add to the crontab (\`crontab -e\`), as in the \`monitor/pulse.cron\` template: ${linha}`,
+        cronSemLeitura: (motivo) => `pulse-host.json present, but there is no crontab to read (${motivo}): the scan never runs`,
+        cronSemLinha: (script) => `pulse-host.json present, and no crontab line runs ${script}: the summary never goes out`,
+        cronOk: (linhas) => `scan in cron every 15 minutes or less (${linhas} line(s))`,
+        cronRitmo: (intervalo) => intervalo === null ? 'on a schedule the doctor cannot read'
+            : intervalo === 60 ? 'every hour' : `every ${intervalo} minutes`,
+        cronLento: (ritmo, linha) => `the pulse scan runs ${ritmo} (\`${linha}\`): the cadence by tag (RM-039) needs 15 minutes`,
+        cronTroque: (linha) => `replace the crontab line (\`crontab -e\`) with: ${linha}`,
+        batidaAusente: (abertas, detalhe) => `${abertas} open thread(s) and no scan beat: ${detalhe}; the factory stops and nobody knows`,
+        batidaSemLeitura: (motivo) => `no crontab to read (${motivo})`,
+        batidaSemLinha: (script) => `no crontab line runs ${script} for this project`,
+        batidaInstale: (comando) => `\`${comando}\` (installs the \`monitor/pulse.cron\` template line in this machine's crontab)`,
+        batidaPeloLog: (minutos) => `no crontab line, but the scan ran ${minutos} min ago (hitl.log): the beat comes from another scheduler`,
+        redeSaiu: 'outside the network (left with `ork network sair`)',
+        redeMembroHerdado: 'member inherited from the factory',
+        redeMembro: 'member',
+        redeCasa: (casa) => `home ${casa}`,
+        redeSemCasa: 'home not recorded yet',
+        redeBatida: (quando, idade) => `last heartbeat ${quando} (${idade} ago)`,
+        redeSemBatida: 'no heartbeat published',
+        redeFalha: (quando, origem, erro) => `last failure ${quando}${origem ? ` (${origem})` : ''}: ${erro}`,
+        redeSemDetalhe: 'no detail',
+        redeSemFalha: 'no failure in rede.log',
+        redeParadaCorrecao: 'the heartbeat comes from the pulse: check the pulse cron and run `ork network publicar`',
+        redeSemCasaCorrecao: 'the network home does not exist yet: the owner runs `ork network entrar`, which creates the private ' +
+            'repository; or `ork network sair`, to take this machine out of the network',
+        redeSemForjaCorrecao: 'sign in to the forge (`gh auth login` or `glab auth login`) and run `ork network publicar`',
+        redePublicaCorrecao: 'make the network home private on the forge; nothing is published to a public repository',
+        redeNomeCorrecao: 'pick another name with `ork network entrar --maquina NOME`, or take this one with `--forcar`',
+        redeOutraCorrecao: '`ork network status` shows the gaps; `ork network publicar` tries again',
+        grafo: {
+            recusa: (motivo) => `${motivo}: \`ork grafo indexar\` refuses on this installation, and without the index the queries and the ork_grafo_* tools refuse too`,
+            soEsm: (versaoDoNode) => `micromark is ESM only, and this Node (${versaoDoNode}) cannot load it with require: use Node 20.19, ` +
+                '22.12 or newer, without the --no-experimental-require-module option (on the command line or in NODE_OPTIONS)',
+            reinstale: (fixada) => `reinstall the global ork, which brings the analyzers as dependencies: npm install -g @orkastery/cli${fixada}` +
+                ' (installed inside a project or through npx, npm leaves the analyzers outside the ork package, and the graph refuses them)',
+        },
+        fonteDaSessao: (origem) => origem.replace(/\(conta do processo\)$/, '(process account)').replace(/\(perfil ([^)]+)\)$/, '(profile $1)'),
+    },
+    onboarding: locale_onboarding_1.ONBOARDING_EN,
+    thread: locale_thread_1.THREAD_EN,
+    phase: locale_phase_1.PHASE_EN,
+    ajuda: locale_ajuda_1.AJUDA_EN,
+    verify: locale_verify_1.VERIFY_EN,
+    ship: locale_ship_1.SHIP_EN,
+    retry: locale_retry_1.RETRY_EN,
+    master: locale_master_1.MASTER_EN,
+    pulse: locale_pulse_1.PULSE_EN,
+    roadmap: locale_roadmap_1.ROADMAP_EN,
+    gerados: locale_gerados_1.GERADOS_EN,
+    init: {
+        foraDoRepositorio: (dir) => `init.fora-do-repositorio: ${dir} is not inside a git repository; nothing was created. ` +
+            'Enter the project repository (or create one with `git init` and a first commit) and run `ork init` again.',
+        jaExiste: (caminho) => `Manifest already exists: ${caminho}`,
+        nadaSobrescrito: 'Nothing was overwritten. Use `--force` to regenerate.',
+        agentsMd: (estado, caminho) => `AGENTS.md ${estado}: ${caminho}`,
+        agentsMdLinha: (estado, caminho) => `  AGENTS.md   ${estado}: ${caminho}`,
+        estadosAgents: { criado: 'created', atualizado: 'updated', inalterado: 'unchanged' },
+        criado: (caminho) => `Manifest created: ${caminho}`,
+        projeto: (nome, abbrev) => `  project     ${nome} (abbrev "${abbrev}")`,
+        branchBase: (branch) => `  base branch ${branch}`,
+        gerenciador: (g) => `  package mgr ${g}`,
+        verify: (v) => `  verify      ${v}`,
+        semScript: '(no script detected)',
+        estado: (dir) => `  state       ${dir}/ kept out of git (${dir}/.gitignore with *; your .gitignore stays as is)`,
+        proximoPasso: 'Next step: `ork doctor`; then `ork onboarding` to run the project interview.',
+    },
+};
+const CATALOGO = { 'pt-BR': PT_BR, en: EN };
+/** As mensagens do locale pedido, ou do ativo. */
+function msg(locale = ativo) {
+    return CATALOGO[locale];
+}
+/**
+ * D14: erro cujo texto vem do catalogo. Ele nasce no locale ativo (dentro de `comLocale('pt-BR', ...)`,
+ * em pt-BR, como o que la se grava), e a entrada do CLI o remonta no locale do comando ao imprimir.
+ */
+class ErroDoCatalogo extends Error {
+    montar;
+    constructor(montar) {
+        super(montar(msg()));
+        this.montar = montar;
+    }
+}
+exports.ErroDoCatalogo = ErroDoCatalogo;
+/** A mensagem de um erro para a pessoa: a do catalogo no locale ativo; as demais como vieram. */
+function mensagemDoErro(e) {
+    return e instanceof ErroDoCatalogo ? e.montar(msg()) : e instanceof Error ? e.message : String(e);
+}
+/** G2 e D1 da F2b: os montadores dos textos que o comando coberto guardou num resultado, pelo texto. */
+let remontagem = null;
+/**
+ * Liga o registro dos montadores (o CLI, nos comandos cobertos) ou o desliga (o `main`, no comeco de cada
+ * chamada). Desligado, nada se guarda: o servidor MCP e o cron nao acumulam texto.
+ */
+function ligarRemontagem(ligada) {
+    remontagem = ligada ? new Map() : null;
+}
+/**
+ * O texto no locale ativo. No escopo da gravacao ele sai em pt-BR, como o ledger e o `--json` o guardam;
+ * com o registro ligado, o montador fica guardado para a impressao remonta-lo no locale do comando.
+ */
+function textoDoCatalogo(montar) {
+    const texto = montar(msg());
+    remontagem?.set(texto, montar);
+    return texto;
+}
+/** O texto como a pessoa o le no locale ativo: o que veio do catalogo e remontado; o resto sai como veio. */
+function remontar(texto) {
+    const montar = remontagem?.get(texto);
+    return montar ? montar(msg()) : texto;
+}
+/** Nome de check como o texto o mostra no locale ativo. */
+function nomeDoCheck(nome, locale = ativo) {
+    return CATALOGO[locale].doctor.nomes[nome] ?? nome;
+}