@orkastery/cli 0.5.3 → 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

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * RM-061, fatia F3a: a familia `gerados` do catalogo, o texto dos arquivos que o CLI escreve para pessoas e
+ * agentes lerem: os comentarios do `orkastery.yaml` e o bloco do `AGENTS.md` que o `ork init` gera, o bloco da
+ * experiencia que o `ork adapter install` escreve e o que o `ork docs init` imprime. O pt-BR e a fonte; o ingles e
+ * tipado por ele. Sem import do nucleo.
+ *
+ * A lingua de um arquivo gerado e a do dono no momento da geracao (D1 da thread ork-rm061f3a): o gerador recebe
+ * o locale por parametro, com pt-BR por omissao, e so a entrada do CLI passa a lingua do dono (D2). So o texto
+ * para pessoas mora aqui (D3): as chaves, os valores e os exemplos comentados do YAML ficam no esqueleto de
+ * `init.ts`, um so para as duas linguas, e os marcadores dos blocos ficam nos modulos donos. Cada comentario do
+ * YAML e uma ou mais linhas de texto, sem o `#` e sem o recuo, que o esqueleto acrescenta. O valor de exemplo
+ * de `owner.language` (comentado) mostra a lingua do proprio arquivo: quem o descomenta fica na lingua em que leu.
+ */
+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' +
+            'Limite duro de 16 KB: prosa longa vai para a memoria com tag, nao para este arquivo.',
+        abbrev: 'abbrev: ate 3 caracteres [a-z0-9], parte 1 do slug de sessao, unica no workspace',
+        fuso: 'fuso do dono (nome IANA): todo horario mostrado a pessoas usa este fuso.\nAusente: fuso do sistema. Exemplo:',
+        preferencias: (comando) => `Preferências: ${comando}`,
+        exemploDeIdioma: 'pt-BR',
+        idiomaAusente: 'ausente: locale do sistema',
+        experienciaFalse: 'false desativa o pacote na próxima instalação do adaptador',
+        runtimes: 'Runtimes homologados:\n  claude-bg (padrao, mais maduro): despacha `claude --bg`, sessao visivel no app\n' +
+            '            e em `claude agents --json`\n  codex: despacha `codex exec` headless na sessao autenticada do Codex CLI,\n' +
+            '         verificado no rollout de $CODEX_HOME/sessions (requer `codex login`)',
+        providerPolicy: 'subscription-only: proibido despachar por provider pago (cobra por token, fora da assinatura)',
+        sandbox: 'sandbox do runtime codex: read-only | workspace-write | danger-full-access\n' +
+            '(danger-full-access SO onde o bubblewrap nao roda; `ork doctor` tem a sonda)',
+        modoPadrao: 'modo usado quando o pedido do builder nao traz #TAG',
+        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' +
+            'isto NAO ocupa vaga do escalonador: a vaga volta para quem esta pronto para rodar',
+        handoff: 'gate de tokens (bloco B1): rotaciona a sessao acima destas ocupacoes de janela',
+        retry: 'autonomia do bloco B3: retry tipado por motivo de gate e fila duravel de rate limit\n' +
+            'max_tentativas e o LIMITE DE ESCALACAO: estourado, pausa qualquer modo, ate #Auto',
+        janelaPadrao: 'janela usada so quando o runtime diz "rate limit" e NAO diz a hora do reset\n' +
+            '(fica marcada como estimativa na fila; o ork nunca inventa horario medido)',
+        memoriaModo: 'files = fallback honesto sem OrkMind (handoff por arquivos, ponteiro path#ancora)\n' +
+            'orkmind = camada semantica do bloco B6 por cima, com degradacao honesta para files',
+        databaseUrl: 'NOME da variavel de ambiente com a DSN da base PROPRIA deste tenant, nunca a DSN.\n' +
+            'Vazio = o regime orkmind nao liga (o ork nao adivinha base: base alheia e pior que\n' +
+            'base nenhuma, precedente do incidente memory-orkmind).',
+        embedding: 'busca por significado (ork memory search --texto): sem o bloco, provider none (desligada).\n' +
+            'api_key_env recebe o NOME da variavel com a chave dedicada, nunca o valor.',
+        modeloOffline: 'modelo local offline, ex.: intfloat/multilingual-e5-small',
+        audit: 'governanca de custo dos auditores periodicos (bloco B5)\n' +
+            'janela ociosa da assinatura: fora dela a rodada so anda com --agora <quem>',
+    },
+    /** O bloco do `AGENTS.md` (`blocoAgentsMd`, em `agents-md.ts`), entre os marcadores do `ork init`. */
+    agents: {
+        projeto: (nome, abbrev, branch) => `Projeto: **${nome}** (${abbrev}). Branch base: \`${branch}\`.`,
+        comece: 'Comece com `ork doctor`, `ork onboarding` e `ork thread status <thread>`.',
+        ciclo: 'Conduza o ciclo GOAL → PLAN → GO → CHECK → SHIP → MASTER pelo `ork`.',
+        modo: (modos) => `Respeite o modo da thread: ${modos}.`,
+        worktree: 'Edite produto somente na worktree vinculada; estado em `.orkastery/` pertence ao núcleo.',
+        fases: 'PLAN não implementa. GO usa commits atômicos. CHECK não corrige. SHIP acontece por `ork ship`.',
+        claims: 'Toda alegação exige claim e comando reproduzível; self-report não é evidência.',
+        master: 'MASTER por omissão só da sua thread: `ork master <thread> --aceitar-omissao`; sem a thread, fecha também as ' +
+            'entregas de outras frentes.',
+        verificacoes: 'Verificações do manifesto:',
+        rodape: 'Este bloco é mantido por `ork init`. Edite livremente o restante do arquivo.',
+        /** O `ork init` recusa o `AGENTS.md` com marcadores repetidos ou fora de ordem, sem escrever. */
+        marcadoresAmbiguos: 'AGENTS.md possui marcadores Orkastery ambiguos; corrija o bloco antes de rodar ork init',
+    },
+    /**
+     * O bloco da experiencia que `ork adapter install` poe no `CLAUDE.md` (no `AGENTS.md`, para o Codex), entre os
+     * marcadores de `experiencia-instalacao.ts`. O diretorio das skills entra como JSON; sem recibo, o bloco e
+     * reconhecido pelo texto antes e depois dele, em qualquer das duas linguas (D8).
+     */
+    experiencia: {
+        titulo: 'Experiência de orquestração',
+        consulte: 'Consulte `ork experiencia show --json` neste projeto. Se experience for false, não ative o pacote.',
+        diretorio: (diretorio) => `Se ativo, leia a skill selecionada pelo campo skill no diretório ${diretorio}.`,
+        preferencias: 'As preferências são dados do núcleo; preserve gates, proveniência humana e permissões do host.',
+    },
+    /**
+     * O que o `ork docs init` imprime (D5): o comando segue o locale inteiro, e os sete arquivos que ele cria saem de
+     * `core/assets/docs/` (pt-BR) ou de `core/assets/docs-en/` (ingles), nos mesmos caminhos do projeto (D6).
+     */
+    docsInit: {
+        jaEstava: 'Documentacao como codigo ja estava no projeto: nada criado.',
+        criado: 'Criado:',
+        proximoPasso: 'Proximo passo: copie docs/produto/_modelo-feature.md e docs/roadmap/_modelo-item.md, e rode ork docs verificar',
+    },
+};
+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.',
+        abbrev: 'abbrev: up to 3 characters [a-z0-9], part 1 of the session slug, unique in the workspace',
+        fuso: 'owner\'s time zone (IANA name): every time shown to people uses this zone.\nAbsent: the system time zone. Example:',
+        preferencias: (comando) => `Preferences: ${comando}`,
+        exemploDeIdioma: 'en-US',
+        idiomaAusente: 'absent: the system locale',
+        experienciaFalse: 'false turns the package off at the next adapter install',
+        runtimes: 'Supported runtimes:\n  claude-bg (default, most mature): dispatches `claude --bg`, session visible in the app\n' +
+            '            and in `claude agents --json`\n  codex: dispatches `codex exec` headless in the signed-in Codex CLI session,\n' +
+            '         verified in the rollout under $CODEX_HOME/sessions (requires `codex login`)',
+        providerPolicy: 'subscription-only: never dispatch through a paid provider (billed per token, outside the subscription)',
+        sandbox: 'sandbox of the codex runtime: read-only | workspace-write | danger-full-access\n' +
+            '(danger-full-access ONLY where bubblewrap does not run; `ork doctor` has the probe)',
+        modoPadrao: 'mode used when the builder\'s request has no #TAG',
+        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' +
+            'this does NOT hold a scheduler slot: the slot goes back to whoever is ready to run',
+        handoff: 'token gate (block B1): rotates the session above these fractions of the context window',
+        retry: 'block B3 autonomy: typed retry per gate reason and a durable rate limit queue\n' +
+            'max_tentativas is the ESCALATION LIMIT: once exceeded, it pauses any mode, even #Auto',
+        janelaPadrao: 'window used only when the runtime says "rate limit" and does NOT say when it resets\n' +
+            '(marked as an estimate in the queue; ork never makes up a measured time)',
+        memoriaModo: 'files = honest fallback without OrkMind (handoff through files, path#anchor pointer)\n' +
+            'orkmind = semantic layer of block B6 on top, degrading honestly to files',
+        databaseUrl: 'NAME of the environment variable with the DSN of this tenant\'s OWN database, never the DSN.\n' +
+            'Empty = the orkmind mode stays off (ork does not guess a database: someone else\'s database is\n' +
+            'worse than none, the precedent of the memory-orkmind incident).',
+        embedding: 'search by meaning (ork memory search --texto): without this block, provider none (off).\n' +
+            'api_key_env takes the NAME of the variable with the dedicated key, never the value.',
+        modeloOffline: 'local offline model, e.g. intfloat/multilingual-e5-small',
+        audit: 'cost governance of the periodic auditors (block B5)\n' +
+            'idle window of the subscription: outside it, a round only runs with --agora <who>',
+    },
+    agents: {
+        projeto: (nome, abbrev, branch) => `Project: **${nome}** (${abbrev}). Base branch: \`${branch}\`.`,
+        comece: 'Start with `ork doctor`, `ork onboarding` and `ork thread status <thread>`.',
+        ciclo: 'Run the GOAL → PLAN → GO → CHECK → SHIP → MASTER cycle through `ork`.',
+        modo: (modos) => `Respect the thread mode: ${modos}.`,
+        worktree: 'Edit product code only in the linked worktree; the state in `.orkastery/` belongs to the core.',
+        fases: 'PLAN does not implement. GO makes atomic commits. CHECK does not fix. SHIP happens through `ork ship`.',
+        claims: 'Every statement needs a claim and a reproducible command; self-report is not evidence.',
+        master: 'Use the default acceptance of MASTER only for your own thread: `ork master <thread> --aceitar-omissao`; ' +
+            'without the thread, it also closes deliveries from other workstreams.',
+        verificacoes: 'Manifest verify commands:',
+        rodape: 'This block is maintained by `ork init`. Edit the rest of the file freely.',
+        marcadoresAmbiguos: 'AGENTS.md has ambiguous Orkastery markers; fix the block before you run `ork init`.',
+    },
+    experiencia: {
+        titulo: 'Orchestration experience',
+        consulte: 'Run `ork experiencia show --json` in this project. If `experience` is false, do not activate the package.',
+        diretorio: (diretorio) => `If active, read the skill selected by the \`skill\` field in the directory ${diretorio}.`,
+        preferencias: 'Preferences are core data; preserve gates, human provenance and host permissions.',
+    },
+    docsInit: {
+        jaEstava: 'Docs as code is already set up in this project: nothing created.',
+        criado: 'Created:',
+        proximoPasso: 'Next step: copy `docs/produto/_modelo-feature.md` and `docs/roadmap/_modelo-item.md`, then run `ork docs verificar`.',
+    },
+};