@orkastery/cli 0.5.6 → 0.6.0

package/dist/locale-estado.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * RM-061, fatia F3b: a familia `estado` do catalogo de mensagens, os erros de estado e de procedencia
+ * (`estado-thread.ts`, `procedencia.ts`, `manifest.ts` e a postura local) e a conferencia do estado unico que o `ork worktree
+ * audit` mostra. O pt-BR e a
+ * fonte; o ingles e tipado por ele. Sem import do nucleo.
+ *
+ * Os erros nascem por `ErroDoCatalogo` no locale ativo: no escopo pt-BR da gravacao, no servidor MCP e no cron, em pt-BR
+ * como sempre; a entrada do CLI os remonta no locale do comando. O motivo tipado do comeco da mensagem (`estado.link`,
+ * `estado.rastreado`, `transporte.rastreado`, `ponteiro.fora-da-raiz`) e o mesmo nas duas linguas: ha codigo que o le.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ESTADO_EN = exports.ESTADO_PT_BR = void 0;
+exports.ESTADO_PT_BR = {
+    gitInvalido: (local) => `.git inválido em ${local}`,
+    arvorePrincipal: (comum) => `árvore principal não resolvida pelo git-common-dir: ${comum}`,
+    idInvalido: 'id de thread inválido',
+    link: (rel) => `estado.link: ${rel} é link simbólico; o estado do ork fica em ` +
+        'pastas de verdade dentro da raiz (um link versionado levaria a escrita para fora dela). Remova o link.',
+    legadoComLink: (nome) => `estado legado contém link: ${nome}`,
+    legadoEspecial: (nome) => `estado legado contém arquivo especial: ${nome}`,
+    foraDaArvore: 'worktree não pertence à árvore principal',
+    indiceIndisponivel: (saida) => `índice da worktree indisponível: ${saida}`,
+    naoPreservou: (saida) => `não foi possível preservar o estado versionado no índice: ${saida}`,
+    threadsVinculado: 'diretório de threads inesperadamente vinculado',
+    linkOutroDestino: (local) => `link de estado aponta para outro destino: ${local}`,
+    dividido: (nome, local, alvo) => `estado dividido: ${nome} diverge entre ${local} e ${alvo}; reconcilie antes do sync`,
+    linkQuebrado: (local) => `link de estado quebrado: ${local}`,
+    preparacaoFalhou: (saida) => `preparação do estado para Git falhou: ${saida}`,
+    alteradoDuranteGit: (local) => `estado local alterado durante operação Git: ${local}; cópia e main preservadas para reconciliação`,
+    /** O detalhe do check `estado-unico` do audit: vai ao ledger em pt-BR e a impressao o remonta. */
+    estadoUnico: (ok, main, local, caminho) => `${ok ? 'mesmo estado' : 'estado dividido'}: main=${main} eventos, worktree=${local} eventos; ${caminho}`,
+    estadoUnicoCorrecao: (id) => `ork worktree sync ${id}; divergências exigem reconciliação preservando evidências`,
+    // procedencia.ts
+    rastreado: (rel) => `estado.rastreado: ${rel} está versionado no git, e estado versionado ` +
+        'não escolhe onde o ork roda (ele pode ter vindo de outro repositório). Tire o estado do índice ' +
+        '(git rm -r --cached .orkastery e .orkastery/ no .gitignore) e rode o comando de novo.',
+    worktreeNaoRegistrada: (dir, id) => `estado.worktree-nao-registrada: ${dir} não aparece em ` +
+        'git worktree list deste repositório, e o ork só roda git e agente na raiz do projeto ou numa worktree ' +
+        `registrada. Recrie a worktree da thread com ork worktree ensure ${id}.`,
+    transporteRastreado: (arquivo) => `transporte.rastreado: ${arquivo} está versionado no git, e o transporte do ` +
+        'pulse e do digest só vale do arquivo local desta máquina. Tire-o do índice (git rm --cached) e grave-o ' +
+        'de novo nesta máquina.',
+    transporteNaoComum: (arquivo) => `transporte.rastreado: ${arquivo} precisa ser um arquivo comum desta máquina, ` +
+        'não link nem diretório.',
+    ponteiroForaDaRaiz: (origem) => `ponteiro.fora-da-raiz: ${origem} aponta para fora da raiz do ` +
+        'projeto e da worktree registrada da thread (também por link simbólico). Um ponteiro guardado no estado só lê ' +
+        'arquivo de dentro do projeto. Exporte o handoff de novo (ork handoff export) ou copie o arquivo para dentro do projeto.',
+    // manifest.ts (o diretorio de estado da raiz) e postura-local.ts (a pasta privada da confirmacao local)
+    dirEstadoLink: (dir) => `estado.link: ${dir} é link simbólico; o estado do ork fica numa pasta de verdade dentro da raiz. Remova o link.`,
+    posturaEstadoLink: 'estado.link: .orkastery precisa ser pasta de verdade',
+    posturaPrivadaLink: 'estado.link: .orkastery/private precisa ser pasta de verdade',
+    posturaRastreada: (nome) => `estado.rastreado: ${nome} está versionado no git; tire-o do índice (git rm --cached) antes de confirmar`,
+    // branch-de-estado.ts: o remoto que nunca vai ao git (`<prefixo>` e de quem usa: ship, roadmap, fabrica, ci)
+    remotoInvalido: (prefixo, remoto) => `${prefixo}.remoto-invalido: o remoto ${remoto} não é nome de remoto do git ` +
+        '(letras, dígitos, ".", "_", "-" e "/" entre partes, cada parte começando por letra ou dígito, sem URL); nada foi passado ao git. ' +
+        'Corrija fabrica.remoto no orkastery.yaml ou --remoto (padrão: origin).',
+    gitFalhou: (prefixo, comando, saida) => `${prefixo}.git: git ${comando} falhou: ${saida}`,
+    pushFalhou: (prefixo, remoto, saida) => `${prefixo}.sem-remoto: o push para ${remoto} falhou: ${saida}`,
+};
+exports.ESTADO_EN = {
+    gitInvalido: (local) => `invalid \`.git\` in ${local}`,
+    arvorePrincipal: (comum) => `main tree not resolved from git-common-dir: ${comum}`,
+    idInvalido: 'invalid thread id',
+    link: (rel) => `estado.link: ${rel} is a symbolic link; ork state lives in real folders inside the root ` +
+        '(a versioned link would send writes outside it). Remove the link.',
+    legadoComLink: (nome) => `legacy state contains a link: ${nome}`,
+    legadoEspecial: (nome) => `legacy state contains a special file: ${nome}`,
+    foraDaArvore: 'the worktree does not belong to the main tree',
+    indiceIndisponivel: (saida) => `worktree index unavailable: ${saida}`,
+    naoPreservou: (saida) => `could not keep the versioned state in the index: ${saida}`,
+    threadsVinculado: 'threads directory unexpectedly linked',
+    linkOutroDestino: (local) => `state link points to another target: ${local}`,
+    dividido: (nome, local, alvo) => `split state: ${nome} differs between ${local} and ${alvo}; reconcile before the sync`,
+    linkQuebrado: (local) => `broken state link: ${local}`,
+    preparacaoFalhou: (saida) => `preparing the state for Git failed: ${saida}`,
+    alteradoDuranteGit: (local) => `local state changed during a Git operation: ${local}; copy and main kept for reconciliation`,
+    estadoUnico: (ok, main, local, caminho) => `${ok ? 'same state' : 'split state'}: main=${main} events, worktree=${local} events; ${caminho}`,
+    estadoUnicoCorrecao: (id) => `ork worktree sync ${id}; divergences need a reconciliation that keeps the evidence`,
+    rastreado: (rel) => `estado.rastreado: ${rel} is versioned in git, and versioned state does not choose where ork runs ` +
+        '(it may have come from another repository). Remove the state from the index ' +
+        '(`git rm -r --cached .orkastery` and `.orkastery/` in `.gitignore`) and run the command again.',
+    worktreeNaoRegistrada: (dir, id) => `estado.worktree-nao-registrada: ${dir} does not show up in this repository's ` +
+        '`git worktree list`, and ork only runs git and agents at the project root or in a registered worktree. ' +
+        `Recreate the thread worktree with \`ork worktree ensure ${id}\`.`,
+    transporteRastreado: (arquivo) => `transporte.rastreado: ${arquivo} is versioned in git, and the pulse and digest transport ` +
+        'only counts from this machine\'s local file. Remove it from the index (`git rm --cached`) and write it again on this machine.',
+    transporteNaoComum: (arquivo) => `transporte.rastreado: ${arquivo} must be a regular file on this machine, not a link or a directory.`,
+    ponteiroForaDaRaiz: (origem) => `ponteiro.fora-da-raiz: ${origem} points outside the project root and the thread's registered ` +
+        'worktree (also through a symbolic link). A pointer kept in the state only reads files inside the project. ' +
+        'Export the handoff again (`ork handoff export`) or copy the file into the project.',
+    dirEstadoLink: (dir) => `estado.link: ${dir} is a symbolic link; ork state lives in a real folder inside the root. Remove the link.`,
+    posturaEstadoLink: 'estado.link: .orkastery must be a real folder',
+    posturaPrivadaLink: 'estado.link: .orkastery/private must be a real folder',
+    posturaRastreada: (nome) => `estado.rastreado: ${nome} is versioned in git; take it out of the index (\`git rm --cached\`) before confirming`,
+    remotoInvalido: (prefixo, remoto) => `${prefixo}.remoto-invalido: remote ${remoto} is not a git remote name ` +
+        '(letters, digits, ".", "_", "-" and "/" between parts, each part starting with a letter or digit, no URL); nothing was passed to git. ' +
+        'Fix `fabrica.remoto` in `orkastery.yaml` or `--remoto` (default: origin).',
+    gitFalhou: (prefixo, comando, saida) => `${prefixo}.git: git ${comando} failed: ${saida}`,
+    pushFalhou: (prefixo, remoto, saida) => `${prefixo}.sem-remoto: the push to ${remoto} failed: ${saida}`,
+};

package/dist/locale-forja.js

@@ -0,0 +1,290 @@
+"use strict";
+/**
+ * A familia `forja` do catalogo: o motivo de cada erro tipado da forja (`forja.*`), para a pessoa. O codigo sai igual
+ * nas duas linguas, no comeco da frase; o detalhe e dado (status HTTP, metodo, caminho, host) e sai como veio. O
+ * pt-BR e a fonte; o ingles e tipado por ele. Sem import do nucleo.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORJA_EN = exports.FORJA_PT_BR = void 0;
+exports.FORJA_PT_BR = {
+    motivo: (e, tipo) => {
+        const d = e.detalhe;
+        switch (e.codigo) {
+            case 'forja.desconhecida': return `forja.desconhecida: nenhuma CLI com login em ${d} respondeu como forja; declare forja.tipo no orkastery.yaml`;
+            case 'forja.ambigua': return `forja.ambigua: ${d} respondeu como mais de uma forja; declare forja.tipo no orkastery.yaml`;
+            case 'forja.remoto-divergente': return `forja.remoto-divergente: o remoto não é da forja que o orkastery.yaml declara (${d})`;
+            case 'forja.sem-login': return `forja.sem-login: a CLI da forja não tem login no host (${d})`;
+            case 'forja.sem-permissao': return `forja.sem-permissao: o login da CLI não tem permissão para isto (${d})`;
+            case 'forja.nao-achei': return tipo === 'gitlab'
+                ? `forja.nao-achei: ${d}; no GitLab, projeto privado sem acesso também responde 404`
+                : `forja.nao-achei: ${d}`;
+            case 'forja.limite': return `forja.limite: a cota de requisições da forja acabou (${d})${e.tentarEm ? `; tente depois de ${e.tentarEm}` : ''}`;
+            case 'forja.conflito': return `forja.conflito: a forja recusou por conflito com o estado atual (${d})`;
+            case 'forja.indisponivel': return `forja.indisponivel: a forja não respondeu (${d})`;
+            case 'forja.pedido-recusado': return `forja.pedido-recusado: a forja recusou o pedido (${d})`;
+            case 'forja.incompleto': return `forja.incompleto: a lista passou do teto de leitura e não foi lida inteira (${d})`;
+            case 'forja.resposta-invalida': return `forja.resposta-invalida: resposta fora do formato esperado (${d})`;
+            case 'forja.versao-abaixo-do-piso': return `forja.versao-abaixo-do-piso: ${d}; o ork não opera esta versão`;
+            case 'forja.sem-capacidade': return `forja.sem-capacidade: o adaptador não implementa ${d}`;
+            case 'forja.ausente': return `forja.ausente: a CLI da forja não está instalada nesta máquina (${d})`;
+            default: return `${e.codigo}: ${d}`;
+        }
+    },
+    /** As linhas da secao "forja" do `ork doctor` (`doctor-forja.ts`). */
+    doctor: {
+        flagComValor: 'erro: ork doctor --forja não leva valor (uso: ork doctor --json [--forja]); sem a flag, a seção forja não roda',
+        origens: { manifesto: 'manifesto', remoto: 'remoto', sondagem: 'sondagem', padrao: 'padrão' },
+        identidade: (tipo, host, porta, base, repo, origens) => `${tipo} em ${host}, porta ${porta}, caminho base ${base}; projeto ${repo} (${origens})`,
+        origensDosCampos: (tipo, host, porta, base) => `tipo: ${tipo}; host: ${host}; porta: ${porta}; caminho base: ${base}`,
+        semHostComBloco: (remoto) => `o orkastery.yaml declara o bloco forja, mas o remoto ${remoto} não aponta uma forja (sem remoto, ou caminho local)`,
+        semHostCorrecao: (remoto) => `aponte o remoto para a forja (git remote set-url ${remoto} <url>) ou retire o bloco forja do orkastery.yaml`,
+        identidadeCorrecao: 'declare forja.tipo no orkastery.yaml (e forja.host, se a web tem outro nome que o remoto), ou faça o login da CLI ' +
+            'no host: gh auth login ou glab auth login',
+        divergenteCorrecao: 'confira forja.host, forja.ssh_host e forja.caminho_base do orkastery.yaml contra o remoto',
+        portas: { aberta: 'aberta', recusada: 'recusada', 'sem-resposta': 'sem resposta' },
+        alcance: (web, ssh) => `HTTPS ${web}; SSH ${ssh}`,
+        alcanceDe: (host, porta, estado) => `${host}:${porta} ${estado}`,
+        webForaCorrecao: (host, porta) => `confira a rede até ${host}:${porta} (firewall, proxy, VPN) e forja.porta no orkastery.yaml`,
+        sshForaCorrecao: 'sem SSH, a entrega vai pelo HTTPS: o transporte forja-https usa o login da CLI',
+        tlsHttp: (host) => `o remoto usa http: ${host} sem TLS`,
+        tlsHttpCorrecao: 'use o endereço https da forja no remoto',
+        caAusente: (ca) => `forja.ca aponta ${ca}, que não existe ou não é legível nesta máquina`,
+        caAusenteCorrecao: 'corrija forja.ca no orkastery.yaml ou instale o PEM nesse caminho nesta máquina',
+        tlsFalhou: (host, motivo) => `a cadeia TLS de ${host} não valida (${motivo}); a verificação nunca é desligada`,
+        tlsCorrecao: 'instale a CA interna no sistema ou declare forja.ca com o arquivo PEM dela',
+        tlsOk: (host, ca) => (ca ? `a cadeia TLS de ${host} valida com a CA ${ca}` : `a cadeia TLS de ${host} valida com a CA do sistema`),
+        tlsCaForaDoLinux: (host, ca) => `a cadeia TLS de ${host} valida com a CA ${ca}, mas fora do Linux ela não chega ao gh (SSL_CERT_FILE só vale no Linux)`,
+        tlsCaForaDoLinuxCorrecao: 'instale a CA interna no armazenamento de certificados do sistema',
+        cli: (cmd, versao, minima) => `${cmd} ${versao} (mínimo ${minima})`,
+        cliAusente: (cmd, minima) => `${cmd} não está instalado nesta máquina (mínimo ${minima})`,
+        cliIlegivel: (cmd) => `${cmd} --version não disse a versão`,
+        cliAbaixo: (cmd, versao, minima) => `${cmd} ${versao} abaixo do mínimo ${minima}`,
+        cliCorrecao: (cmd, minima) => `instale ou atualize o ${cmd} para ${minima} ou acima`,
+        login: (cmd, alvo) => `${cmd} com login em ${alvo}`,
+        semLogin: (cmd, alvo) => `${cmd} sem login em ${alvo}`,
+        loginCorrecao: (comando) => `rode ${comando}`,
+        subcaminho: (base) => `${base}/api/v4/metadata responde`,
+        subcaminhoFalhou: (base, motivo) => `${base}/api/v4/metadata não respondeu: ${motivo}`,
+        subcaminhoCorrecao: 'confira forja.caminho_base contra o relative_url_root da instância',
+        faixas: { testada: 'testada', compativel: 'compatível', 'abaixo-do-piso': 'abaixo do piso', 'sem-faixa': 'sem faixa' },
+        servidor: (versao, edicao, faixa) => `${versao} ${edicao}, faixa ${faixa}`,
+        servidorSemFaixa: (host, versao) => (versao ? `${host} ${versao}` : host),
+        servidorFalhou: (motivo) => `a versão do servidor não foi lida: ${motivo}`,
+        servidorFalhouCorrecao: 'confira o alcance, o login e a permissão da CLI no host',
+        servidorAbaixo: (versao, piso) => `${versao} abaixo do piso ${piso}: o ork não opera esta versão`,
+        servidorCorrecao: (piso) => `atualize a instância para ${piso} ou acima`,
+        doCache: 'lido há menos de 24 h',
+        nenhum: 'nenhum',
+        escopo: (lista) => `escopos do token: ${lista}`,
+        escopoSemLeitura: (lista) => `o token não lê a API (escopos: ${lista}); falta api ou read_api`,
+        escopoCorrecao: 'refaça o login da CLI com um token que tenha api ou read_api',
+        escopoSemEscrita: (lista) => `o SHIP do MCP empurra pelo forja-https, e o token não escreve no repositório (escopos: ${lista}); falta write_repository ou api`,
+        escopoSemEscritaCorrecao: 'refaça o login da CLI com um token que tenha write_repository (ou api), ou instale o SHIP com --ship-transport forja-ssh',
+        escopoNaoMedivel: (motivo) => `não medível: ${motivo}`,
+        escopoNaoMedivelCorrecao: 'com token de acesso pessoal o doctor mede os escopos; com OAuth, confira-os na forja',
+        escopoFineGrained: 'não medível: token fine-grained ou de GitHub App não declara escopos',
+        escopoSemRepo: (lista) => `escopos do token: ${lista}; sem repo, repositório privado não é lido`,
+        escopoSemRepoCorrecao: 'rode gh auth refresh -s repo',
+        projetoFalhou: (repo, motivo) => `o projeto ${repo} não foi lido: ${motivo}`,
+        projetoFalhouCorrecao: 'confira o caminho do projeto no remoto e a permissão do login da CLI nele',
+        naoDisponivel: 'não disponível nesta edição',
+        naoMedivel: 'não medível',
+        ligado: 'ligado',
+        desligado: 'desligado',
+        permitido: 'permitido',
+        projetoGitlab: (metodo, squash, mergedResults, mergeTrain) => `merge ${metodo}; squash ${squash}; merged results ${mergedResults}; merge train ${mergeTrain}`,
+        projetoGithub: (merge, squash, rebase) => `merge commit ${merge}; squash ${squash}; rebase ${rebase}`,
+        avisoFf: 'com fast-forward não há commit de merge: o assunto ship(<thread>) não chega à base',
+        avisoMensagemPadrao: 'a mensagem de merge padrão (Merge branch …) não começa por ship(<thread>)',
+        avisoSquash: (opcao) => `squash ${opcao}: a entrega por squash não se liga ao head verificado (entrega.sem-vinculo)`,
+        avisoSemMergeCommit: 'sem merge commit, a entrega por PR não se liga ao head verificado (entrega.sem-vinculo)',
+        projetoGitlabCorrecao: 'em Settings > Merge requests, use merge commit e um modelo de mensagem de merge que comece por %{title}',
+        projetoGithubCorrecao: 'em Settings > General > Pull Requests, permita merge commits',
+        capacidades: (ligadas) => `ligadas: ${ligadas}`,
+        capacidadesDesligadas: (ligadas, desligadas) => `ligadas: ${ligadas}; desligadas (o adaptador não implementa): ${desligadas}`,
+        capacidadesCorrecao: 'cada capacidade desligada segue o caminho de reserva do ork, como hoje',
+    },
+    /** O transporte do `ork_ship` do MCP: a frase de cada recusa e as linhas da instalacao. */
+    transporteShip: {
+        recusa: (codigo, d) => {
+            const frase = (() => {
+                switch (codigo) {
+                    case 'mcp.ship.transport.urls': return `o origin precisa de uma URL só, de forja ou de bare local (${d})`;
+                    case 'mcp.ship.transport.modo': return `o origin não serve a este transporte; use --ship-transport ${d}`;
+                    case 'mcp.ship.transport.forja': return `a forja do origin não foi resolvida (${d})`;
+                    case 'mcp.ship.transport.ssh.divergente': return `o origin e a forja resolvida apontam SSH diferente (${d}); acerte forja.ssh_host e forja.ssh_porta ou a URL do origin`;
+                    case 'mcp.ship.transport.ssh.sem-resposta': return `${d} não entregou chave de servidor SSH; se a forja não abre SSH, use --ship-transport forja-https`;
+                    case 'mcp.ship.transport.ssh.revogada': return `o seu known_hosts revoga uma chave que ${d} apresentou; não instale até saber por quê`;
+                    case 'mcp.ship.transport.ssh.nao-confirmada': return `confira a impressão com quem administra a forja e rode de novo com --ssh-fingerprint <impressão> (${d})`;
+                    case 'mcp.ship.transport.ssh.impressao-divergente': return `a impressão dita não é de nenhuma chave que o servidor apresentou (${d}); não instale até saber por quê`;
+                    case 'mcp.ship.transport.ssh.known-hosts-ilegivel': return `o seu known_hosts existe e não pôde ser lido (${d}); sem ele, uma chave revogada passaria; acerte o arquivo e rode de novo`;
+                    case 'mcp.ship.transport.ssh.caminho': return `o known_hosts fixado precisa de caminho absoluto sem espaço nem caractere especial (${d})`;
+                    case 'mcp.ship.transport.ssh.known-hosts-alterado': return `o known_hosts fixado mudou depois da instalação (${d}); reinstale o MCP`;
+                    case 'mcp.ship.transport.ssh.credencial-na-url': return `o ${d} leva senha ou token na URL SSH; tire-os com git remote set-url origin ssh://<usuário>@<host>/<caminho>.git`;
+                    case 'mcp.ship.transport.https.sem-tls': return `HTTP sem TLS levaria a credencial em claro; use https:// no origin (${d})`;
+                    case 'mcp.ship.transport.https.credencial-na-url': return `o ${d} leva usuário ou token na URL; tire-os com git remote set-url origin https://<host>/<caminho>.git`;
+                    case 'mcp.ship.transport.https.divergente': return `o origin e a forja resolvida apontam HTTPS diferente (${d}); acerte forja.host e forja.porta ou a URL do origin`;
+                    case 'mcp.ship.transport.sem-cli': return `a CLI da forja não está instalada; instale ${d} ou acima`;
+                    case 'mcp.ship.transport.sem-helper': return `a CLI instalada não tem auth git-credential (${d}); atualize até a versão mínima`;
+                    case 'mcp.ship.transport.sem-login': return `a CLI não tem login no host (${d}); faça o login e rode de novo (o ork doctor mostra o comando)`;
+                    case 'mcp.ship.transport.binario': return `a CLI precisa ser arquivo executável seu ou do root, sem escrita de grupo ou de outros (${d})`;
+                    case 'mcp.ship.transport.ca': return `a CA de forja.ca precisa ser um PEM legível, seu ou do root, sem escrita de grupo ou de outros (${d})`;
+                    case 'mcp.ship.transport.ca-alterada': return `a CA mudou depois da instalação (${d}); reinstale o MCP`;
+                    case 'mcp.ship.transport.fixacao-ausente': return `este transporte não foi instalado nesta máquina; rode ${d}`;
+                    case 'mcp.ship.transport.fixacao-insegura': return `a fixação do transporte precisa ser sua, sem link e sem acesso de grupo ou de outros (${d})`;
+                    case 'mcp.ship.transport.fixacao-divergente': return `a instalação fixou outro transporte ou outro origin (${d}); reinstale o MCP`;
+                    case 'mcp.ship.transport.cli-config': return `${d} precisa ser um caminho absoluto sem caractere de controle; é a pasta de config da CLI da forja, que o push leva ao helper de credencial`;
+                    case 'mcp.ship.transport.mudou-no-push': return `o ${d} ou a config do git mudou durante o push; o push pode ter sido feito, mas a entrega não foi provada: confira o remoto, a branch e a config antes de repetir`;
+                    default: return d;
+                }
+            })();
+            return `${codigo}: ${frase}`;
+        },
+        fixadoSsh: (nome, chaves, arquivo) => `SHIP por forja-ssh: a chave de ${nome} (${chaves}) ficou fixada em ${arquivo}; cada push confere essa chave, sem perguntar.`,
+        fixadoHttps: (origem, cli, ca) => `SHIP por forja-https: o git pede a credencial de ${origem} só ao ${cli} (auth git-credential)${ca ? `, com a CA ${ca} conferida pelo hash a cada push` : ''}.`,
+        fixariaSsh: (nome, chaves, arquivo) => `SHIP por forja-ssh: a chave de ${nome} (${chaves}) seria fixada em ${arquivo}; nada foi gravado.`,
+        fixariaHttps: (origem, cli, ca) => `SHIP por forja-https: o git pediria a credencial de ${origem} só ao ${cli} (auth git-credential)${ca ? `, com a CA ${ca} conferida pelo hash a cada push` : ''}; nada foi gravado.`,
+        consultaNoFixado: (modo) => `mcp.experiencia.transporte-fixado: consulta indisponível no transporte fixado ${modo}: o fetch das consultas ainda não leva a chave, o helper e as travas fixados, e sem eles iria à rede pela config do usuário`,
+        proposta: (modo) => `SHIP: o origin deste projeto pede --ship-transport ${modo}; com o transporte padrão, o ork_ship fica indisponível. Para trocar, remova a entrada orkastery e reinstale com a opção.`,
+    },
+};
+exports.FORJA_EN = {
+    motivo: (e, tipo) => {
+        const d = e.detalhe;
+        switch (e.codigo) {
+            case 'forja.desconhecida': return `forja.desconhecida: no CLI logged in to ${d} answered as a forge; declare forja.tipo in orkastery.yaml`;
+            case 'forja.ambigua': return `forja.ambigua: ${d} answered as more than one forge; declare forja.tipo in orkastery.yaml`;
+            case 'forja.remoto-divergente': return `forja.remoto-divergente: the remote is not on the forge that orkastery.yaml declares (${d})`;
+            case 'forja.sem-login': return `forja.sem-login: the forge CLI is not logged in to the host (${d})`;
+            case 'forja.sem-permissao': return `forja.sem-permissao: the CLI login is not allowed to do this (${d})`;
+            case 'forja.nao-achei': return tipo === 'gitlab'
+                ? `forja.nao-achei: ${d}; on GitLab, a private project you cannot access also answers 404`
+                : `forja.nao-achei: ${d}`;
+            case 'forja.limite': return `forja.limite: the forge request quota ran out (${d})${e.tentarEm ? `; try again after ${e.tentarEm}` : ''}`;
+            case 'forja.conflito': return `forja.conflito: the forge refused because of a conflict with the current state (${d})`;
+            case 'forja.indisponivel': return `forja.indisponivel: the forge did not answer (${d})`;
+            case 'forja.pedido-recusado': return `forja.pedido-recusado: the forge refused the request (${d})`;
+            case 'forja.incompleto': return `forja.incompleto: the list went past the read cap and was not read in full (${d})`;
+            case 'forja.resposta-invalida': return `forja.resposta-invalida: the response is not in the expected format (${d})`;
+            case 'forja.versao-abaixo-do-piso': return `forja.versao-abaixo-do-piso: ${d}; ork does not operate this version`;
+            case 'forja.sem-capacidade': return `forja.sem-capacidade: the adapter does not implement ${d}`;
+            case 'forja.ausente': return `forja.ausente: the forge CLI is not installed on this machine (${d})`;
+            default: return `${e.codigo}: ${d}`;
+        }
+    },
+    doctor: {
+        flagComValor: 'error: ork doctor --forja takes no value (usage: ork doctor --json [--forja]); without the flag, the forge section does not run',
+        origens: { manifesto: 'manifest', remoto: 'remote', sondagem: 'probe', padrao: 'default' },
+        identidade: (tipo, host, porta, base, repo, origens) => `${tipo} at ${host}, port ${porta}, base path ${base}; project ${repo} (${origens})`,
+        origensDosCampos: (tipo, host, porta, base) => `type: ${tipo}; host: ${host}; port: ${porta}; base path: ${base}`,
+        semHostComBloco: (remoto) => `orkastery.yaml declares the forja block, but remote ${remoto} does not point to a forge (no remote, or a local path)`,
+        semHostCorrecao: (remoto) => `point the remote to the forge (git remote set-url ${remoto} <url>) or remove the forja block from orkastery.yaml`,
+        identidadeCorrecao: 'declare forja.tipo in orkastery.yaml (and forja.host, if the web uses another name than the remote), or log the CLI ' +
+            'in to the host: gh auth login or glab auth login',
+        divergenteCorrecao: 'check forja.host, forja.ssh_host and forja.caminho_base in orkastery.yaml against the remote',
+        portas: { aberta: 'open', recusada: 'refused', 'sem-resposta': 'no answer' },
+        alcance: (web, ssh) => `HTTPS ${web}; SSH ${ssh}`,
+        alcanceDe: (host, porta, estado) => `${host}:${porta} ${estado}`,
+        webForaCorrecao: (host, porta) => `check the network to ${host}:${porta} (firewall, proxy, VPN) and forja.porta in orkastery.yaml`,
+        sshForaCorrecao: 'without SSH, delivery goes over HTTPS: the forja-https transport uses the CLI login',
+        tlsHttp: (host) => `the remote uses http: ${host} without TLS`,
+        tlsHttpCorrecao: 'use the https address of the forge in the remote',
+        caAusente: (ca) => `forja.ca points to ${ca}, which does not exist or is not readable on this machine`,
+        caAusenteCorrecao: 'fix forja.ca in orkastery.yaml or install the PEM at that path on this machine',
+        tlsFalhou: (host, motivo) => `the TLS chain of ${host} does not validate (${motivo}); verification is never turned off`,
+        tlsCorrecao: 'install the internal CA in the system or declare forja.ca with its PEM file',
+        tlsOk: (host, ca) => (ca ? `the TLS chain of ${host} validates with the CA ${ca}` : `the TLS chain of ${host} validates with the system CA`),
+        tlsCaForaDoLinux: (host, ca) => `the TLS chain of ${host} validates with the CA ${ca}, but outside Linux it does not reach gh (SSL_CERT_FILE only works on Linux)`,
+        tlsCaForaDoLinuxCorrecao: 'install the internal CA in the system certificate store',
+        cli: (cmd, versao, minima) => `${cmd} ${versao} (minimum ${minima})`,
+        cliAusente: (cmd, minima) => `${cmd} is not installed on this machine (minimum ${minima})`,
+        cliIlegivel: (cmd) => `${cmd} --version did not tell the version`,
+        cliAbaixo: (cmd, versao, minima) => `${cmd} ${versao} below the minimum ${minima}`,
+        cliCorrecao: (cmd, minima) => `install or upgrade ${cmd} to ${minima} or later`,
+        login: (cmd, alvo) => `${cmd} logged in to ${alvo}`,
+        semLogin: (cmd, alvo) => `${cmd} not logged in to ${alvo}`,
+        loginCorrecao: (comando) => `run ${comando}`,
+        subcaminho: (base) => `${base}/api/v4/metadata answers`,
+        subcaminhoFalhou: (base, motivo) => `${base}/api/v4/metadata did not answer: ${motivo}`,
+        subcaminhoCorrecao: 'check forja.caminho_base against the relative_url_root of the instance',
+        faixas: { testada: 'tested', compativel: 'compatible', 'abaixo-do-piso': 'below the floor', 'sem-faixa': 'no range' },
+        servidor: (versao, edicao, faixa) => `${versao} ${edicao}, range ${faixa}`,
+        servidorSemFaixa: (host, versao) => (versao ? `${host} ${versao}` : host),
+        servidorFalhou: (motivo) => `the server version was not read: ${motivo}`,
+        servidorFalhouCorrecao: 'check the reach, the login and the permission of the CLI on the host',
+        servidorAbaixo: (versao, piso) => `${versao} below the floor ${piso}: ork does not operate this version`,
+        servidorCorrecao: (piso) => `upgrade the instance to ${piso} or later`,
+        doCache: 'read less than 24 h ago',
+        nenhum: 'none',
+        escopo: (lista) => `token scopes: ${lista}`,
+        escopoSemLeitura: (lista) => `the token cannot read the API (scopes: ${lista}); api or read_api is missing`,
+        escopoCorrecao: 'log the CLI in again with a token that has api or read_api',
+        escopoSemEscrita: (lista) => `the MCP SHIP pushes over forja-https, and the token cannot write to the repository (scopes: ${lista}); write_repository or api is missing`,
+        escopoSemEscritaCorrecao: 'log the CLI in again with a token that has write_repository (or api), or install the SHIP with --ship-transport forja-ssh',
+        escopoNaoMedivel: (motivo) => `not measurable: ${motivo}`,
+        escopoNaoMedivelCorrecao: 'with a personal access token the doctor measures the scopes; with OAuth, check them on the forge',
+        escopoFineGrained: 'not measurable: a fine-grained or GitHub App token does not declare scopes',
+        escopoSemRepo: (lista) => `token scopes: ${lista}; without repo, a private repository is not read`,
+        escopoSemRepoCorrecao: 'run gh auth refresh -s repo',
+        projetoFalhou: (repo, motivo) => `project ${repo} was not read: ${motivo}`,
+        projetoFalhouCorrecao: 'check the project path in the remote and the permission of the CLI login on it',
+        naoDisponivel: 'not available in this edition',
+        naoMedivel: 'not measurable',
+        ligado: 'on',
+        desligado: 'off',
+        permitido: 'allowed',
+        projetoGitlab: (metodo, squash, mergedResults, mergeTrain) => `merge ${metodo}; squash ${squash}; merged results ${mergedResults}; merge train ${mergeTrain}`,
+        projetoGithub: (merge, squash, rebase) => `merge commit ${merge}; squash ${squash}; rebase ${rebase}`,
+        avisoFf: 'with fast-forward there is no merge commit: the ship(<thread>) subject does not reach the base',
+        avisoMensagemPadrao: 'the default merge message (Merge branch …) does not start with ship(<thread>)',
+        avisoSquash: (opcao) => `squash ${opcao}: a squash delivery is not linked to the verified head (entrega.sem-vinculo)`,
+        avisoSemMergeCommit: 'without merge commits, a PR delivery is not linked to the verified head (entrega.sem-vinculo)',
+        projetoGitlabCorrecao: 'in Settings > Merge requests, use merge commit and a merge message template that starts with %{title}',
+        projetoGithubCorrecao: 'in Settings > General > Pull Requests, allow merge commits',
+        capacidades: (ligadas) => `on: ${ligadas}`,
+        capacidadesDesligadas: (ligadas, desligadas) => `on: ${ligadas}; off (the adapter does not implement them): ${desligadas}`,
+        capacidadesCorrecao: 'each capability that is off follows the ork fallback path, as today',
+    },
+    transporteShip: {
+        recusa: (codigo, d) => {
+            const frase = (() => {
+                switch (codigo) {
+                    case 'mcp.ship.transport.urls': return `origin needs a single URL, of a forge or of a local bare repository (${d})`;
+                    case 'mcp.ship.transport.modo': return `origin does not fit this transport; use --ship-transport ${d}`;
+                    case 'mcp.ship.transport.forja': return `the forge of origin could not be resolved (${d})`;
+                    case 'mcp.ship.transport.ssh.divergente': return `origin and the resolved forge point to different SSH (${d}); fix forja.ssh_host and forja.ssh_porta or the origin URL`;
+                    case 'mcp.ship.transport.ssh.sem-resposta': return `${d} did not offer an SSH host key; if the forge has no SSH, use --ship-transport forja-https`;
+                    case 'mcp.ship.transport.ssh.revogada': return `your known_hosts revokes a key that ${d} offered; do not install until you know why`;
+                    case 'mcp.ship.transport.ssh.nao-confirmada': return `check the fingerprint with whoever runs the forge and run again with --ssh-fingerprint <fingerprint> (${d})`;
+                    case 'mcp.ship.transport.ssh.impressao-divergente': return `the given fingerprint matches no key the server offered (${d}); do not install until you know why`;
+                    case 'mcp.ship.transport.ssh.known-hosts-ilegivel': return `your known_hosts exists but could not be read (${d}); without it, a revoked key would pass; fix the file and run again`;
+                    case 'mcp.ship.transport.ssh.caminho': return `the pinned known_hosts needs an absolute path without spaces or special characters (${d})`;
+                    case 'mcp.ship.transport.ssh.known-hosts-alterado': return `the pinned known_hosts changed after the install (${d}); reinstall the MCP`;
+                    case 'mcp.ship.transport.ssh.credencial-na-url': return `${d} carries a password or token in the SSH URL; remove them with git remote set-url origin ssh://<user>@<host>/<path>.git`;
+                    case 'mcp.ship.transport.https.sem-tls': return `HTTP without TLS would send the credential in clear text; use https:// in origin (${d})`;
+                    case 'mcp.ship.transport.https.credencial-na-url': return `${d} carries a user or token in the URL; remove them with git remote set-url origin https://<host>/<path>.git`;
+                    case 'mcp.ship.transport.https.divergente': return `origin and the resolved forge point to different HTTPS (${d}); fix forja.host and forja.porta or the origin URL`;
+                    case 'mcp.ship.transport.sem-cli': return `the forge CLI is not installed; install ${d} or later`;
+                    case 'mcp.ship.transport.sem-helper': return `the installed CLI has no auth git-credential (${d}); upgrade to the minimum version`;
+                    case 'mcp.ship.transport.sem-login': return `the CLI is not logged in to the host (${d}); log in and run again (ork doctor shows the command)`;
+                    case 'mcp.ship.transport.binario': return `the CLI must be an executable file owned by you or root, not writable by group or others (${d})`;
+                    case 'mcp.ship.transport.ca': return `the CA in forja.ca must be a readable PEM, owned by you or root, not writable by group or others (${d})`;
+                    case 'mcp.ship.transport.ca-alterada': return `the CA changed after the install (${d}); reinstall the MCP`;
+                    case 'mcp.ship.transport.fixacao-ausente': return `this transport was not installed on this machine; run ${d}`;
+                    case 'mcp.ship.transport.fixacao-insegura': return `the transport pin must be yours, with no link and no group or other access (${d})`;
+                    case 'mcp.ship.transport.fixacao-divergente': return `the install pinned another transport or another origin (${d}); reinstall the MCP`;
+                    case 'mcp.ship.transport.cli-config': return `${d} must be an absolute path without control characters; it is the config folder of the forge CLI, which the push hands to the credential helper`;
+                    case 'mcp.ship.transport.mudou-no-push': return `the ${d} or the git config changed during the push; the push may have gone out, but the delivery was not proved: check the remote, the branch and the config before trying again`;
+                    default: return d;
+                }
+            })();
+            return `${codigo}: ${frase}`;
+        },
+        fixadoSsh: (nome, chaves, arquivo) => `SHIP over forja-ssh: the key of ${nome} (${chaves}) is pinned in ${arquivo}; every push checks this key, without asking.`,
+        fixadoHttps: (origem, cli, ca) => `SHIP over forja-https: git asks only ${cli} (auth git-credential) for the credential of ${origem}${ca ? `, with the CA ${ca} checked by hash on every push` : ''}.`,
+        fixariaSsh: (nome, chaves, arquivo) => `SHIP over forja-ssh: the key of ${nome} (${chaves}) would be pinned in ${arquivo}; nothing was written.`,
+        fixariaHttps: (origem, cli, ca) => `SHIP over forja-https: git would ask only ${cli} (auth git-credential) for the credential of ${origem}${ca ? `, with the CA ${ca} checked by hash on every push` : ''}; nothing was written.`,
+        consultaNoFixado: (modo) => `mcp.experiencia.transporte-fixado: lookup unavailable on the pinned transport ${modo}: the lookup fetch does not carry the pinned key, helper and locks yet, and without them it would reach the network through the user's config`,
+        proposta: (modo) => `SHIP: this project's origin needs --ship-transport ${modo}; with the default transport, ork_ship is unavailable. To switch, remove the orkastery entry and reinstall with the option.`,
+    },
+};

package/dist/locale-gerados.js

@@ -15,6 +15,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GERADOS_EN = exports.GERADOS_PT_BR = void 0;
 exports.GERADOS_PT_BR = {
+    /** O `.orkastery/.gitignore` que o `ork init` cria; `*` continua dado, fora do catalogo. */
+    gitignoreDaMaquina: 'Criado pelo ork: esta pasta é da máquina, não do repositório.',
     /** Os comentarios do `orkastery.yaml` (`manifestoYaml`, em `init.ts`). */
     manifesto: {
         cabecalho: 'Manifesto do Orkastery (v1, bloco B0)\nGerado por `ork init`. Fonte unica da configuracao do projeto.\n' +
@@ -35,6 +37,7 @@ exports.GERADOS_PT_BR = {
         porThread: 'true: o ork thread new cria a worktree e a branch da thread sem flag (--sem-worktree cria sem);\n' +
             'false ou ausente: só com --worktree auto',
         naoDetectado: 'nao detectado',
+        securityScan: 'varredura de seguranca no verify; ativa quando ha JS/TS, Python ou Go, comentada sem stack',
         ci: 'Ative depois de publicar o workflow e tornar ork-verify um check obrigatório.',
         ciComando: 'perfil hermético opcional do runner; sem ele, usa verify acima',
         staleAfter: 'thread despachada sem atividade (ledger parado, sessao nao-working) por mais que\n' +
@@ -93,6 +96,7 @@ exports.GERADOS_PT_BR = {
     },
 };
 exports.GERADOS_EN = {
+    gitignoreDaMaquina: 'Created by ork: this folder belongs to the machine, not the repository.',
     manifesto: {
         cabecalho: 'Orkastery manifest (v1, block B0)\nGenerated by `ork init`. The single source of the project configuration.\n' +
             'Hard limit of 16 KB: long prose goes to tagged memory, not to this file.',
@@ -112,6 +116,7 @@ exports.GERADOS_EN = {
         porThread: 'true: ork thread new creates the thread worktree and branch without a flag (--sem-worktree skips them);\n' +
             'false or absent: only with --worktree auto',
         naoDetectado: 'not detected',
+        securityScan: 'security scan in verify; on when JS/TS, Python or Go is found, commented out otherwise',
         ci: 'Turn it on after you publish the workflow and make ork-verify a required check.',
         ciComando: 'optional hermetic profile of the runner; without it, the verify commands above run',
         staleAfter: 'a dispatched thread with no activity (idle ledger, session not working) for longer than\n' +

package/dist/locale-grafo.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GRAFO_EN = exports.GRAFO_PT_BR = void 0;
+/** RM-061 F3d: moldura humana do grafo; schemas, códigos e JSON continuam em pt-BR. */
+exports.GRAFO_PT_BR = {
+    uso: [
+        'uso: ork grafo indexar [--verificar] [--forcar] [--json]',
+        '     ork grafo status [--json]',
+        '     ork grafo contexto <thread> [--json [--teto-bytes N]]',
+        '     ork grafo vizinhos <no> [--profundidade N] [--sentido entrada|saida|ambos] [--tipo T,...] [--limite N] [--json [--teto-bytes N]]',
+        '     ork grafo chamadores <simbolo> [--profundidade N] [--limite N] [--json [--teto-bytes N]]',
+        '     ork grafo importadores <arquivo|simbolo> [--profundidade N] [--limite N] [--json [--teto-bytes N]]',
+        '     ork grafo caminho <de> <para> [--sentido saida|entrada|ambos] [--tipo T,...] [--json [--teto-bytes N]]',
+        '     ork grafo amostra [--por-estrato N] | ork grafo amostra --conferir ARQ [--json]',
+        '     ork grafo limpar [--tudo] [--json]',
+    ],
+    erroUso: (motivo) => `grafo.uso: ${motivo}`,
+    motivos: {
+        semSub: 'falta o subcomando', desconhecido: (sub) => `subcomando desconhecido: ${sub}`,
+        repetida: (nome) => `--${nome} repetida`, semValor: (nome) => `--${nome} nao leva valor`,
+        exigeValor: (nome) => `--${nome} exige valor`, opcao: (sub, valor) => `opcao desconhecida para ${sub}: ${valor}`,
+        argumentos: (sub, esperados, recebidos) => `${sub} pede ${esperados} argumento(s), veio ${recebidos}`,
+        inteiro: (nome) => `--${nome} precisa ser inteiro`, tipo: (tipo, lista) => `--tipo desconhecido: ${tipo} (use ${lista})`,
+        sentido: (valor) => `--sentido desconhecido: ${valor}`, tetoJson: '--teto-bytes exige --json', tetoMin: '--teto-bytes precisa ser ao menos 1',
+        amostraExclusiva: '--conferir e --por-estrato nao combinam', estratoMin: '--por-estrato precisa ser ao menos 1',
+    },
+    indexar: {
+        titulo: (repo, estado) => `indice do grafo de ${repo}: ${estado}`,
+        // O rotulo ocupa 13 colunas antes do valor, como na base: 12 do nome e um espaco.
+        campo: (nome, valor) => `  ${nome.padEnd(12)} ${valor}`,
+        campos: { revisao: 'revisao', chave: 'chave', snapshot: 'snapshot', digest: 'digest', conferencia: 'conferencia',
+            nos: 'nos', arestas: 'arestas', lugar: 'lugar', motivo: 'motivo', tempo: 'tempo' },
+        conferencia: (fontes, evidencias) => `conferirFontes verificada: ${fontes} fontes e ${evidencias} evidencias contra os bytes`,
+        determinismo: (ordem, digest, relatorio, unidades, igual) => `  determinismo ${ordem}: digest ${digest}, relatorio ${relatorio}, unidades ${unidades}, ${igual ? 'igual' : 'DIFERENTE'}`,
+        incremental: (base, igual) => `  incremental  a partir do indice de ${base}: ${igual ? 'igual a completa nos quatro arquivos' : 'DIFERENTE'}`,
+        naoConferido: (motivo) => `  incremental  nao conferido: ${motivo}`, aprovado: 'aprovado', semBase: 'sem base',
+    },
+    status: {
+        titulo: (head, arvore) => `grafo: HEAD ${head}, arvore ${arvore}`,
+        indice: (chave, estado) => `  indice do HEAD  ${chave} ${estado}`,
+        ausente: '(ausente: rode ork grafo indexar)', semAnalisadores: '(sem os analisadores nesta instalacao, nem a consulta nem o indexar rodam)',
+        semChave: '(sem a chave do indice: o erro esta na linha de baixo)', analisadores: (v) => `  analisadores    ${v}`,
+        correcao: (v) => `  correcao        ${v}`, pasta: (dir, n, mb) => `  pasta           ${dir} (${n} indice(s), ${mb})`,
+        semCommit: 'sem commit', indisponivel: 'indisponivel', naoCriada: 'ainda nao criada', sobras: (v) => `  sobras          ${v}`,
+    },
+    contexto: {
+        titulo: (thread, revisao) => `Contexto ${thread} @ ${revisao}`,
+        resumo: (sementes, total, arestas, ligacoes, bytes) => `  ${sementes}/${total} sementes, ${arestas}/${ligacoes} ligacoes agregadas; ${bytes} bytes JSON`,
+        tamanho: (bytes) => `  tamanho dos arquivos no pacote (nao descoberta): ${bytes} bytes (revisao indexada); tokens: unavailable`,
+        diff: (v) => `  diff: ${v}`, mudadas: (n) => `  ligacoes com fonte modificada na arvore: ${n}`,
+        final: (truncado, arvore) => `  truncado: ${truncado}; arvore: ${arvore}; use --json para nos e evidencias`,
+    },
+    amostra: {
+        titulo: (arestas, estratos, revisao) => `amostra: ${arestas} arestas em ${estratos} estratos, auditada na revisao ${revisao}`,
+        vereditos: (v) => `  vereditos ${v}`, conferidas: (ok, total) => `  conferidas contra o indice do HEAD: ${ok} de ${total}`,
+        falha: (v) => `FALHA ${v}`, reprovado: (n) => `reprovado: ${n} falha(s)`, aprovado: 'aprovado',
+    },
+    limpar: (n, mb) => `grafo limpar: ${n} removido(s), ${mb}`,
+    consulta: {
+        titulo: (repo, revisao, chave, snapshot) => `grafo de ${repo} na revisao ${revisao}, indice ${chave}, snapshot ${snapshot}`,
+        arvore: 'aviso: a arvore tem mudanca rastreada; a resposta e do HEAD, nao da arvore',
+        fontes: (v, resto) => `fontes que mudaram na arvore: ${v}${resto ? ` e mais ${resto}` : ''}`,
+        marca: '  [fonte modificada na arvore]', pagina: (p) => `pagina ${p}`, extratores: (v) => `extratores: ${v}`,
+        semCaminho: (de, para, sentido, nos) => `sem caminho de ${de} para ${para} (sentido ${sentido}): ${nos} nos explorados`,
+        caminho: (de, para, sentido, passos) => `caminho de ${de} para ${para} (sentido ${sentido}): ${passos} passo(s)`,
+        contra: '(contra a aresta) ', todos: 'todos',
+        resultado: (tipo, alvo, profundidade, filtro, arestas, nos) => `${tipo} de ${alvo} (profundidade ${profundidade}${filtro}): ${arestas} aresta(s), ${nos} no(s)`,
+        filtro: (sentido, tipos) => `, sentido ${sentido}, tipos ${tipos}`,
+        truncado: (n, total) => `truncado: ${n} de ${total} arestas, as mais perto do alvo; use --limite`,
+        parcial: 'parcial: so arestas que o extrator prova; chamada por despacho de tipo, import nao resolvido e as lacunas do relatorio de extracao ficam fora',
+    },
+};
+exports.GRAFO_EN = {
+    uso: [
+        'usage: ork grafo indexar [--verificar] [--forcar] [--json]', '       ork grafo status [--json]',
+        '       ork grafo contexto <thread> [--json [--teto-bytes N]]',
+        '       ork grafo vizinhos <node> [--profundidade N] [--sentido entrada|saida|ambos] [--tipo T,...] [--limite N] [--json [--teto-bytes N]]',
+        '       ork grafo chamadores <symbol> [--profundidade N] [--limite N] [--json [--teto-bytes N]]',
+        '       ork grafo importadores <file|symbol> [--profundidade N] [--limite N] [--json [--teto-bytes N]]',
+        '       ork grafo caminho <from> <to> [--sentido saida|entrada|ambos] [--tipo T,...] [--json [--teto-bytes N]]',
+        '       ork grafo amostra [--por-estrato N] | ork grafo amostra --conferir FILE [--json]', '       ork grafo limpar [--tudo] [--json]',
+    ],
+    erroUso: (reason) => `grafo.uso: ${reason}`,
+    motivos: {
+        semSub: 'missing subcommand', desconhecido: (sub) => `unknown subcommand: ${sub}`, repetida: (name) => `--${name} repeated`,
+        semValor: (name) => `--${name} takes no value`, exigeValor: (name) => `--${name} requires a value`, opcao: (sub, value) => `unknown option for ${sub}: ${value}`,
+        argumentos: (sub, expected, received) => `${sub} expects ${expected} argument(s), received ${received}`, inteiro: (name) => `--${name} must be an integer`,
+        tipo: (type, list) => `unknown --tipo: ${type} (use ${list})`, sentido: (value) => `unknown --sentido: ${value}`,
+        tetoJson: '--teto-bytes requires --json', tetoMin: '--teto-bytes must be at least 1', amostraExclusiva: '--conferir and --por-estrato cannot be combined', estratoMin: '--por-estrato must be at least 1',
+    },
+    indexar: {
+        titulo: (repo, state) => `graph index for ${repo}: ${state}`, campo: (name, value) => `  ${name.padEnd(12)} ${value}`,
+        campos: { revisao: 'revision', chave: 'key', snapshot: 'snapshot', digest: 'digest', conferencia: 'check',
+            nos: 'nodes', arestas: 'edges', lugar: 'location', motivo: 'reason', tempo: 'time' },
+        conferencia: (sources, evidence) => `conferirFontes verified: ${sources} sources and ${evidence} evidence items against the bytes`,
+        determinismo: (order, digest, report, units, equal) => `  determinism   ${order}: digest ${digest}, report ${report}, units ${units}, ${equal ? 'equal' : 'DIFFERENT'}`,
+        incremental: (base, equal) => `  incremental  from index ${base}: ${equal ? 'equal to the full build in all four files' : 'DIFFERENT'}`,
+        naoConferido: (reason) => `  incremental  not checked: ${reason}`, aprovado: 'approved', semBase: 'no base',
+    },
+    status: {
+        titulo: (head, tree) => `graph: HEAD ${head}, tree ${tree}`, indice: (key, state) => `  HEAD index     ${key} ${state}`,
+        ausente: '(missing: run ork grafo indexar)', semAnalisadores: '(without analyzers in this installation, neither queries nor indexing can run)',
+        semChave: '(no index key: the error is on the next line)', analisadores: (v) => `  analyzers      ${v}`, correcao: (v) => `  fix            ${v}`,
+        pasta: (dir, n, mb) => `  directory      ${dir} (${n} index(es), ${mb})`, semCommit: 'no commit', indisponivel: 'unavailable', naoCriada: 'not created yet', sobras: (v) => `  leftovers      ${v}`,
+    },
+    contexto: {
+        titulo: (thread, revision) => `Context ${thread} @ ${revision}`,
+        resumo: (seeds, total, edges, links, bytes) => `  ${seeds}/${total} seeds, ${edges}/${links} aggregated links; ${bytes} JSON bytes`,
+        tamanho: (bytes) => `  file size in the package (not discovery): ${bytes} bytes (indexed revision); tokens: unavailable`,
+        diff: (v) => `  diff: ${v}`, mudadas: (n) => `  links with a modified source in the tree: ${n}`,
+        final: (truncated, tree) => `  truncated: ${truncated}; tree: ${tree}; use --json for nodes and evidence`,
+    },
+    amostra: {
+        titulo: (edges, strata, revision) => `sample: ${edges} edges in ${strata} strata, audited at revision ${revision}`,
+        vereditos: (v) => `  verdicts ${v}`, conferidas: (ok, total) => `  checked against the HEAD index: ${ok} of ${total}`,
+        falha: (v) => `FAIL ${v}`, reprovado: (n) => `failed: ${n} failure(s)`, aprovado: 'approved',
+    },
+    limpar: (n, mb) => `graph cleanup: ${n} removed, ${mb}`,
+    consulta: {
+        titulo: (repo, revision, key, snapshot) => `graph for ${repo} at revision ${revision}, index ${key}, snapshot ${snapshot}`,
+        arvore: 'warning: the tree has tracked changes; the answer is from HEAD, not the tree',
+        fontes: (v, rest) => `sources changed in the tree: ${v}${rest ? ` and ${rest} more` : ''}`, marca: '  [source modified in tree]', pagina: (p) => `page ${p}`,
+        extratores: (v) => `extractors: ${v}`, semCaminho: (from, to, direction, nodes) => `no path from ${from} to ${to} (direction ${direction}): ${nodes} nodes explored`,
+        caminho: (from, to, direction, steps) => `path from ${from} to ${to} (direction ${direction}): ${steps} step(s)`, contra: '(against the edge) ', todos: 'all',
+        resultado: (type, target, depth, filter, edges, nodes) => `${type} of ${target} (depth ${depth}${filter}): ${edges} edge(s), ${nodes} node(s)`,
+        filtro: (direction, types) => `, direction ${direction}, types ${types}`, truncado: (n, total) => `truncated: ${n} of ${total} edges, nearest to the target; use --limite`,
+        parcial: 'partial: only edges proven by the extractor; dynamic dispatch calls, unresolved imports, and extraction-report gaps are excluded',
+    },
+};