@orkastery/cli 0.5.6 → 0.6.0

package/dist/locale-conhecimento.js

@@ -0,0 +1,181 @@
+"use strict";
+/**
+ * RM-026 K7, fatia 2: a familia `conhecimento` do catalogo de mensagens (o conhecimento escrito,
+ * `ork.conhecimento/v1`). O pt-BR e a fonte; o ingles e tipado por ele. Sem import do nucleo.
+ *
+ * O detalhe de cada lacuna vai ao `--json` e a resposta das tools MCP em pt-BR: o leitor e a consulta o montam por
+ * `textoDoCatalogo`, e so a impressao o remonta no locale (o padrao da F2b da RM-061). O pt-BR das lacunas da fatia 1
+ * e o de antes, byte a byte. Sai como veio: o codigo da lacuna, o id, o arquivo, a referencia, o titulo e o corpo do
+ * documento (dado do repositorio) e a mensagem do `lerYaml` (o modulo dono a escreve, como o validador do manifesto
+ * na D14 da F2a).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONHECIMENTO_EN = exports.CONHECIMENTO_PT_BR = void 0;
+exports.CONHECIMENTO_PT_BR = {
+    uso: 'uso: ork conhecimento [listar [--colecao C]|mostrar <doc-id>|colecoes|verificar] [--json]',
+    // ork conhecimento: o texto para gente (D13). O titulo, o id, o arquivo e o corpo sao dado do repositorio.
+    naoLido: 'Conhecimento: a pasta não foi lida.',
+    listar: (dir, n, colecao) => `Conhecimento em ${dir}${colecao === null ? '' : `, coleção ${colecao}`}: ${n} documento(s).`,
+    documento: (id, titulo, colecoes) => `  ${id}  ${titulo} (${colecoes})`,
+    nenhumDocumento: '  (nenhum documento)',
+    paraLer: 'Para ler um documento: ork conhecimento mostrar <doc-id>.',
+    colecoes: (dir, n) => `Coleções em ${dir}: ${n}.`,
+    colecao: (nome, documentos) => `  ${nome}  ${documentos}`,
+    nenhumaColecao: '  (nenhuma coleção)',
+    mostrar: (id, titulo) => `${id}: ${titulo}`,
+    semDocumento: (id) => `${id}: nenhum documento válido com este id.`,
+    colecoesDoDocumento: (colecoes) => `  coleções   ${colecoes}`,
+    arquivo: (arquivo) => `  arquivo    ${arquivo}`,
+    versao: (sha256, bytes) => `  versão     sha256 ${sha256}, ${bytes} bytes`,
+    brain: (id, titulo, kind, versao, fonte) => `  Brain      ${id}: ${titulo} (${kind}, versão ${versao}, fonte ${fonte})`,
+    decisao: (ref, tipo, fonte) => `  decisão    ${ref}: ${tipo} (fonte ${fonte})`,
+    semReferencia: '  referências nenhuma',
+    corpo: 'Corpo do documento:',
+    verificar: (dir, documentos, brain, decisoes) => `Conhecimento em ${dir}: ${documentos} documento(s) válido(s), ${brain} id(s) do Brain e ${decisoes} decisão(ões) conferido(s).`,
+    aprovado: 'Verificação aprovada: nenhuma lacuna.',
+    reprovado: (n) => `Verificação reprovada: ${n} lacuna(s).`,
+    lacunasTitulo: (n) => `${n} lacuna(s), o que ficou fora da resposta:`,
+    lacuna: (codigo, onde, detalhe) => `  ${codigo}  ${onde}: ${detalhe}`,
+    pasta: 'a pasta',
+    naReferencia: (referencia) => `referência ${referencia}`,
+    lacunas: {
+        naoDeclarado: 'o orkastery.yaml não declara conhecimento.dir',
+        dirForma: 'conhecimento.dir precisa ser uma pasta relativa à raiz, sem "..", fora de .git e .orkastery, como ' +
+            'docs/conhecimento; nada foi lido',
+        dirNaoAbre: 'a pasta de conhecimento.dir não existe ou não abre',
+        dirForaDaRaiz: 'pelo caminho real (links resolvidos), conhecimento.dir sai da raiz do projeto; o manifesto vem com o ' +
+            'repositório e não escolhe caminho fora dela; nada foi lido',
+        dirReal: 'pelo caminho real, conhecimento.dir é a própria raiz, cai em .git ou .orkastery, ou tem caractere invisível; ' +
+            'nada foi lido',
+        dirNaoEPasta: 'conhecimento.dir não é uma pasta',
+        limiteEntradas: (n) => `a pasta passa de ${n} entradas; nenhum documento foi devolvido`,
+        limiteNiveis: (n) => `a pasta passa de ${n} níveis; nenhum documento foi devolvido`,
+        limiteTotal: (mib) => `os documentos passam de ${mib} MiB no total; nenhum documento foi devolvido`,
+        link: 'link simbólico não é seguido; o documento é o arquivo versionado',
+        pastaNaoAbriu: 'a pasta não abriu para leitura; o que está nela não foi lido',
+        nomeInvalido: 'nome fora de UTF-8 ou com caractere invisível; não foi lido',
+        entradaNaoAbriu: 'a entrada não abriu para leitura; não foi lida',
+        naoRegular: 'não é arquivo comum; não foi lido',
+        naoAbriuComoArquivo: 'não abriu como arquivo comum, ou mudou durante a leitura',
+        grandeDemais: (kib) => `o documento passa de ${kib} KiB`,
+        codificacao: 'o arquivo não é UTF-8',
+        semFrontmatter: 'o arquivo não começa com o frontmatter entre duas linhas ---',
+        frontmatterGrande: (kib) => `o frontmatter passa de ${kib} KiB`,
+        /** A mensagem do `lerYaml`, que diz a linha do arquivo; no pt-BR ela e o detalhe inteiro. */
+        frontmatterYaml: (erro) => erro,
+        frontmatterNaoEMapa: 'o frontmatter precisa ser um mapa de chaves',
+        idInvalido: 'id precisa ser doc- seguido de 3 a 48 letras minúsculas, números ou hífens, começando por letra ou número',
+        chaveDesconhecida: (chaves, doContrato) => `chave fora do contrato: ${chaves} (o frontmatter tem só ${doContrato})`,
+        tituloInvalido: (n) => `titulo precisa ser texto de 1 a ${n} caracteres, sem caractere de controle`,
+        colecoesInvalidas: (n) => `colecoes precisa listar de 1 a ${n} nomes de 1 a 48 letras minúsculas, números ou hífens, ` +
+            'sem repetir',
+        referenciasInvalidas: (n) => `referencias é um mapa só com brain e decisoes, cada uma uma lista de até ${n} textos`,
+        idRepetido: (n) => `o id aparece em ${n} arquivos; nenhum deles vale até sobrar um`,
+        brainForma: 'id do Brain é prod-, proj- ou init-, na regra dos ids do portfólio',
+        decisaoForma: 'decisão é <thread>#<linha>, com o id da thread e a linha do ledger a partir de 1',
+        ledgerLinkOuId: 'a pasta da thread no estado do projeto é link ou fica fora da regra de id',
+        ledgerNaoAbriu: (thread) => `o ledger da thread ${thread} não abriu para leitura`,
+        semLedger: (thread) => `a thread ${thread} não tem ledger neste projeto`,
+        ledgerNaoRegular: (thread, mib) => `o ledger da thread ${thread} não é arquivo comum de até ${mib} MiB`,
+        ledgerNaoUtf8: (thread) => `o ledger da thread ${thread} não é UTF-8`,
+        ledgersDemais: (mib) => `a leitura passa de ${mib} MiB de ledger lido; a decisão não foi conferida`,
+        linhasCompletas: (thread, n) => `o ledger da thread ${thread} tem ${n} linha(s) completa(s)`,
+        naoEJson: (linha, thread) => `a linha ${linha} do ledger da thread ${thread} não é um evento JSON`,
+        outraThread: (linha, thread) => `a linha ${linha} do ledger da thread ${thread} é de outra thread`,
+        /** `tipo` e o tipo do evento quando ele tem a forma de um; `null`, sem tipo conhecido. */
+        naoEDecisao: (linha, thread, tipo, decisoes) => `a linha ${linha} do ledger da thread ${thread} é ${tipo ?? 'sem tipo conhecido'}, não decisão (${decisoes})`,
+        // Fatia 2: a conferencia do id do Brain por `get` (D12) e o `mostrar` de um id sem documento (D13).
+        brainInexistente: 'o Company Brain não tem este id (o get respondeu unknown)',
+        brainRetido: 'o Company Brain tem este id, mas o retém para esta leitura (o get respondeu withheld); a referência não é citável aqui',
+        brainNaoRespondeu: (estado, erro) => `o Company Brain não respondeu ao get (${estado}${erro ? `, ${erro}` : ''}); a referência não foi conferida`,
+        brainForaDoContrato: 'o get do Company Brain respondeu fora do contrato da entidade (orkmind.company-brain-entity/v1); ' +
+            'a referência não foi conferida',
+        brainSemConfiguracao: (codigo) => `a configuração do Company Brain não foi lida (${codigo ?? 'sem código'}); a referência não foi conferida`,
+        brainTeto: (n) => `a consulta passa de ${n} ids do Brain conferidos por get; a referência não foi conferida`,
+        brainPrazo: (s) => `a conferência do Brain passou do prazo de ${s} s da consulta; a referência não foi conferida`,
+        documentoInexistente: (id, semId) => `nenhum documento válido da pasta tem o id ${id}` +
+            (semId ? `; ${semId} arquivo(s) da pasta viraram lacuna antes de o id ser lido (ork conhecimento verificar)` : ''),
+    },
+};
+exports.CONHECIMENTO_EN = {
+    uso: 'usage: ork conhecimento [listar [--colecao C]|mostrar <doc-id>|colecoes|verificar] [--json]',
+    naoLido: 'Knowledge: the folder was not read.',
+    listar: (dir, n, colecao) => `Knowledge in ${dir}${colecao === null ? '' : `, collection ${colecao}`}: ${n} document(s).`,
+    documento: (id, titulo, colecoes) => `  ${id}  ${titulo} (${colecoes})`,
+    nenhumDocumento: '  (no document)',
+    paraLer: 'To read a document: `ork conhecimento mostrar <doc-id>`.',
+    colecoes: (dir, n) => `Collections in ${dir}: ${n}.`,
+    colecao: (nome, documentos) => `  ${nome}  ${documentos}`,
+    nenhumaColecao: '  (no collection)',
+    mostrar: (id, titulo) => `${id}: ${titulo}`,
+    semDocumento: (id) => `${id}: no valid document with this id.`,
+    colecoesDoDocumento: (colecoes) => `  collections  ${colecoes}`,
+    arquivo: (arquivo) => `  file         ${arquivo}`,
+    versao: (sha256, bytes) => `  version      sha256 ${sha256}, ${bytes} bytes`,
+    brain: (id, titulo, kind, versao, fonte) => `  Brain        ${id}: ${titulo} (${kind}, version ${versao}, source ${fonte})`,
+    decisao: (ref, tipo, fonte) => `  decision     ${ref}: ${tipo} (source ${fonte})`,
+    semReferencia: '  references   none',
+    corpo: 'Document body:',
+    verificar: (dir, documentos, brain, decisoes) => `Knowledge in ${dir}: ${documentos} valid document(s), ${brain} Brain id(s) and ${decisoes} decision(s) checked.`,
+    aprovado: 'Check passed: no gap.',
+    reprovado: (n) => `Check failed: ${n} gap(s).`,
+    lacunasTitulo: (n) => `${n} gap(s), what was left out of the answer:`,
+    lacuna: (codigo, onde, detalhe) => `  ${codigo}  ${onde}: ${detalhe}`,
+    pasta: 'the folder',
+    naReferencia: (referencia) => `reference ${referencia}`,
+    lacunas: {
+        naoDeclarado: 'the orkastery.yaml does not declare conhecimento.dir',
+        dirForma: 'conhecimento.dir must be a folder relative to the root, without "..", outside .git and .orkastery, like ' +
+            'docs/conhecimento; nothing was read',
+        dirNaoAbre: 'the conhecimento.dir folder does not exist or does not open',
+        dirForaDaRaiz: 'by the real path (links resolved), conhecimento.dir leaves the project root; the manifest comes with the ' +
+            'repository and does not choose a path outside it; nothing was read',
+        dirReal: 'by the real path, conhecimento.dir is the root itself, falls in .git or .orkastery, or has an invisible character; ' +
+            'nothing was read',
+        dirNaoEPasta: 'conhecimento.dir is not a folder',
+        limiteEntradas: (n) => `the folder has more than ${n} entries; no document was returned`,
+        limiteNiveis: (n) => `the folder has more than ${n} levels; no document was returned`,
+        limiteTotal: (mib) => `the documents add up to more than ${mib} MiB; no document was returned`,
+        link: 'symbolic links are not followed; the document is the versioned file',
+        pastaNaoAbriu: 'the folder did not open for reading; what is in it was not read',
+        nomeInvalido: 'name outside UTF-8 or with an invisible character; not read',
+        entradaNaoAbriu: 'the entry did not open for reading; not read',
+        naoRegular: 'not a regular file; not read',
+        naoAbriuComoArquivo: 'did not open as a regular file, or changed during the read',
+        grandeDemais: (kib) => `the document is larger than ${kib} KiB`,
+        codificacao: 'the file is not UTF-8',
+        semFrontmatter: 'the file does not start with the frontmatter between two --- lines',
+        frontmatterGrande: (kib) => `the frontmatter is larger than ${kib} KiB`,
+        frontmatterYaml: (erro) => `invalid YAML in the frontmatter (${erro})`,
+        frontmatterNaoEMapa: 'the frontmatter must be a map of keys',
+        idInvalido: 'id must be doc- followed by 3 to 48 lowercase letters, digits or hyphens, starting with a letter or digit',
+        chaveDesconhecida: (chaves, doContrato) => `key outside the contract: ${chaves} (the frontmatter only has ${doContrato})`,
+        tituloInvalido: (n) => `titulo must be text of 1 to ${n} characters, without a control character`,
+        colecoesInvalidas: (n) => `colecoes must list 1 to ${n} names of 1 to 48 lowercase letters, digits or hyphens, ` +
+            'without repeating',
+        referenciasInvalidas: (n) => `referencias is a map with only brain and decisoes, each a list of up to ${n} texts`,
+        idRepetido: (n) => `the id appears in ${n} files; none of them counts until only one is left`,
+        brainForma: 'a Brain id is prod-, proj- or init-, by the rule of the portfolio ids',
+        decisaoForma: 'a decision is <thread>#<line>, with the thread id and the ledger line counted from 1',
+        ledgerLinkOuId: 'the thread folder in the project state is a link or breaks the id rule',
+        ledgerNaoAbriu: (thread) => `the ledger of thread ${thread} did not open for reading`,
+        semLedger: (thread) => `thread ${thread} has no ledger in this project`,
+        ledgerNaoRegular: (thread, mib) => `the ledger of thread ${thread} is not a regular file of up to ${mib} MiB`,
+        ledgerNaoUtf8: (thread) => `the ledger of thread ${thread} is not UTF-8`,
+        ledgersDemais: (mib) => `the read goes past ${mib} MiB of ledger read; the decision was not checked`,
+        linhasCompletas: (thread, n) => `the ledger of thread ${thread} has ${n} complete line(s)`,
+        naoEJson: (linha, thread) => `line ${linha} of the ledger of thread ${thread} is not a JSON event`,
+        outraThread: (linha, thread) => `line ${linha} of the ledger of thread ${thread} belongs to another thread`,
+        naoEDecisao: (linha, thread, tipo, decisoes) => `line ${linha} of the ledger of thread ${thread} is ${tipo ?? 'of no known type'}, not a decision (${decisoes})`,
+        brainInexistente: 'the Company Brain does not have this id (get answered unknown)',
+        brainRetido: 'the Company Brain has this id but withholds it from this read (get answered withheld); the reference is not citable here',
+        brainNaoRespondeu: (estado, erro) => `the Company Brain did not answer the get (${estado}${erro ? `, ${erro}` : ''}); the reference was not checked`,
+        brainForaDoContrato: 'the Company Brain get answered outside the entity contract (orkmind.company-brain-entity/v1); ' +
+            'the reference was not checked',
+        brainSemConfiguracao: (codigo) => `the Company Brain configuration was not read (${codigo ?? 'no code'}); the reference was not checked`,
+        brainTeto: (n) => `the query goes past ${n} Brain ids checked by get; the reference was not checked`,
+        brainPrazo: (s) => `the Brain check went past the query deadline of ${s} s; the reference was not checked`,
+        documentoInexistente: (id, semId) => `no valid document in the folder has the id ${id}` +
+            (semId ? `; ${semId} file(s) in the folder became gaps before the id was read (\`ork conhecimento verificar\`)` : ''),
+    },
+};

package/dist/locale-decisao.js

@@ -0,0 +1,205 @@
+"use strict";
+/**
+ * RM-061, fatia F3b: a familia `decisao` do catalogo de mensagens (`ork decisao placar` e o uso do comando). O pt-BR e
+ * a fonte; o ingles e tipado por ele. Sem import do nucleo.
+ *
+ * F3c: as recusas de `ork decisao registrar` (a validacao do pedido HITL v2 em `hitl-contract.ts`, o criterio em
+ * `hitl-gates.ts`, o rastro em `ledger.ts`), no CLI e no `ork_decision_record` do MCP, tambem vem daqui; o resultado
+ * segue JSON, e os codigos e o contrato nao mudam com a lingua. A fase da linha do placar e dado e sai igual.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DECISAO_EN = exports.DECISAO_PT_BR = void 0;
+exports.DECISAO_PT_BR = {
+    uso: 'uso: ork decisao registrar|placar <thread-id>',
+    usoRegistrar: 'uso: ork decisao registrar <thread-id> --decidido D --porque P ...',
+    usoPlacar: 'uso: ork decisao placar <thread-id> [--json]',
+    exigeFlag: (nome) => `decisao registrar exige --${nome}`,
+    criterioUso: 'decisao registrar: --criterio manifesto:CHAVE, ledger:REF ou medicao:COMANDO',
+    linhaFalta: (campo) => `falta ${campo}`,
+    linhaQuebrada: (campo) => `${campo} tem quebra de linha; cada campo é uma linha só`,
+    linhaControle: (campo) => `${campo} tem caractere de controle`,
+    linhaLonga: (campo, tamanho, teto) => `${campo} tem ${tamanho} caracteres; o teto é ${teto}`,
+    contratoCampoDeGate: (campo) => `pedido HITL v2: decisão informada não pode trazer ${campo}`,
+    contratoCamposObrigatorios: (problema) => `pedido HITL v2: decisão informada exige o que foi decidido, o porquê e como mudar (${problema})`,
+    contratoCampoInvalido: (problema) => `pedido HITL v2: decisão informada: ${problema}`,
+    contratoCustoObrigatorio: 'pedido HITL v2: custo de reverter exige agora e depois, os dois presentes',
+    contratoCustoInvalido: (problema) => `pedido HITL v2: custo de reverter: ${problema}`,
+    contratoCriterioObrigatorio: 'pedido HITL v2: decisão informada exige critério citado e resolvível',
+    contratoCriterioInvalido: (problema) => `pedido HITL v2: critério: ${problema}`,
+    contratoIrreversivel: 'pedido HITL v2: ato irreversível nunca é decisão informada',
+    contratoComumInvalido: 'pedido HITL v2: identificação, modo, instante ou profundidade inválidos',
+    contratoAlternativas: 'pedido HITL v2: de 2 a 5 alternativas, rotuladas de a a e',
+    contratoAlternativaSemTexto: 'pedido HITL v2: alternativa sem texto',
+    contratoAlternativaSemAcao: 'pedido HITL v2: alternativa sem ação explícita',
+    contratoAlternativaSemConsequencia: 'pedido HITL v2: alternativa sem consequência em uma linha',
+    contratoPorqueSoRecomendada: 'pedido HITL v2: só a alternativa recomendada diz o porquê',
+    contratoRecomendadaBoolean: 'pedido HITL v2: recomendada só aceita true ou ausência',
+    contratoRecomendadaSemPorque: 'pedido HITL v2: a alternativa recomendada precisa dizer o porquê em uma linha',
+    contratoUmaRecomendada: 'pedido HITL v2: exatamente uma alternativa é recomendada',
+    contratoPerguntaFrase: 'pedido HITL v2: a pergunta é uma frase, sem quebra de linha',
+    contratoMotivoInvalido: 'pedido HITL v2: motivo inválido',
+    contratoCorpoLinhas: 'pedido HITL v2: o corpo é lista de linhas, nunca prosa corrida',
+    contratoTipoRespostaInvalido: 'pedido HITL v2: tipo de resposta inválido',
+    contratoCodigoInvalido: 'pedido HITL v2: código curto inválido',
+    contratoAlvoInvalido: 'pedido HITL v2: alvo inválido',
+    contratoRespostaInvalida: 'pedido HITL v2: resposta aceita inválida',
+    contratoPrazoInvalido: 'pedido HITL v2: prazo ou ação de expiração inválidos',
+    contratoDependenciaInvalida: 'pedido HITL v2: dependência técnica exige o comando exato e o porquê, uma linha cada',
+    contratoIrreversivelAusente: 'pedido HITL v2: irreversível precisa ser declarado',
+    contratoAtoIrreversivelInvalido: 'pedido HITL v2: ato irreversível precisa nomear um da lista congelada',
+    contratoIrreversivelExpira: 'pedido HITL v2: ato irreversível nunca avança por expiração',
+    contratoAtoSoIrreversivel: 'pedido HITL v2: só pedido irreversível nomeia ato',
+    contratoDesconhecido: 'pedido HITL v2: contrato inválido',
+    contratoClasseInvalida: 'pedido HITL v2: classe precisa ser decidido ou pergunta',
+    selecaoVersao: 'o pedido de condução do ork sai em ork.hitl/v2, com alternativas declaradas',
+    selecaoFaixa: (minimo, maximo, atual) => `de ${minimo} a ${maximo} alternativas, este traz ${atual}`,
+    selecaoRecomendada: (atual) => `exatamente uma alternativa com o selo Recomendação, este traz ${atual}`,
+    selecaoTextoLivre: 'resposta em texto só com dependência técnica tipada: o comando exato que o dono roda no terminal e o porquê',
+    threadFechada: 'decisão informada: thread fechada não decide mais nada',
+    criterioNaoResolve: (detalhe) => `decisão informada: critério não resolve (${detalhe})`,
+    criterioMedicao: 'comando citado; quem executa e reprova é o CHECK',
+    criterioManifestoIlegivel: 'manifesto do projeto não pôde ser lido',
+    criterioManifestoSemChave: (referencia) => `o manifesto não tem a chave ${referencia}`,
+    criterioManifestoVazio: (referencia) => `a chave ${referencia} existe mas está vazia`,
+    criterioManifestoLido: (referencia) => `chave ${referencia} lida do manifesto`,
+    criterioLedgerIlegivel: (thread) => `a thread ${thread} não tem ledger legível`,
+    criterioEvento: (evento, thread) => `evento ${evento} de ${thread}`,
+    criterioEventoAusente: (evento, thread) => typeof evento === 'number' ? `${thread} não tem evento ${evento}` : `nenhum evento de ${thread} tem esse identificador`,
+    faseMudou: 'decisão informada: a fase mudou enquanto ela era registrada',
+    revertidaNaoExiste: 'decisão informada: a decisão revertida não existe nesta thread',
+    autorMcp: 'mcp.decision.author: quemDecidiu e a sessao que decidiu, nunca o dono',
+    rastroObrigatorio: (campo) => `decisão autônoma exige ${campo}: quem decidiu, com que evidência e por quê`,
+    colunasDoPlacar: ['FASE', 'DECIDIDAS', 'INFORMADAS', 'PERGUNTAS', 'REVERTIDAS', 'SEM RASTRO', 'LIMIAR'],
+    acimaDoLimiar: (limiar) => `acima de ${limiar}: revisar`,
+    dentroDoLimiar: 'ok',
+    taxaDeReversao: (taxa) => `\ntaxa de reversão das decisões informadas: ${taxa === null ? 'sem decisão informada ainda' : `${Math.round(taxa * 100)}%`}`,
+    curto: {
+        selo: 'Recomendação',
+        atos: {
+            dinheiro: 'gasta dinheiro', 'publicacao-externa': 'publica fora do projeto',
+            'apagar-dado': 'apaga dado', 'push-base-protegida': 'faz push na base protegida',
+        },
+        soPergunta: 'pedido curto: só uma pergunta ork.hitl/v2 tem alternativas declaradas',
+        semRespostaRecomendada: (ate) => `Sem resposta${ate}, sigo com a recomendada.`,
+        semRespostaEscala: (ate) => `Sem resposta${ate}, o pedido é escalado.`,
+        ate: (valor) => ` até ${valor}`,
+        semRespostaSessao: 'Sem resposta, a sessão continua parada.',
+        semRespostaGate: 'Sem resposta, nada avança.',
+        alternativas: 'pedido curto: de 2 a 5 alternativas',
+        umaRecomendada: 'pedido curto: exatamente uma alternativa é recomendada',
+        sessaoParada: (id) => `A sessão ${id} está parada esperando você`,
+        faseParada: (fase) => `${fase ? `A fase ${fase}` : 'A thread'} está parada esperando você`,
+        desde: (valor) => ` desde ${valor}`,
+        semThread: 'sem thread',
+        semVolta: (ato) => `Sem volta depois de feito: ${ato}.`,
+        respostaTexto: 'Responda escrevendo o texto; ele é enviado como está.',
+        respostaTerminal: (recomendada, comando) => `feito o comando, ${recomendada}) é \`${comando}\`.`,
+        respostaDialogo: 'Responda selecionando a opção no diálogo; digitar a letra também vale.',
+        respostaTelegram: (codigo, recomendada) => `↩️ Responda: ${codigo} ${recomendada} (ou outra letra). Evidências: ${codigo} detalhes.`,
+        respostaHost: (codigo, recomendada) => `Responda pelo Telegram: ${codigo} ${recomendada} (ou outra letra); aqui, pelo diálogo do host. Evidências: ${codigo} detalhes.`,
+        // RM-057 (resposta curta): as letras reais da pergunta, e o detalhe a um pedido de distância.
+        listaDeLetras: (letras) => letras.length < 2 ? letras.join('') : `${letras.slice(0, -1).join(', ')} ou ${letras.at(-1)}`,
+        respostaLetras: (letras, codigo) => `Responda ${letras}. Detalhes: ${codigo} detalhes.`,
+        // GO-FIX 2 (D22 da ork-rm057respost): o terminal não grava resposta; o dono responde no Telegram ou na janela do host.
+        respostaLetrasHost: (letras, codigo) => `${letras} no Telegram, ou pela janela de confirmação do host. Detalhes: ${codigo} detalhes.`,
+        contratoInvalido: 'pedido curto: contrato inválido',
+        pergunta: 'Pergunta', situacao: 'Situação', porque: 'porquê', responder: 'Responder',
+        acimaDoTeto: 'pedido curto: acima do teto de linhas',
+    },
+};
+exports.DECISAO_EN = {
+    uso: 'usage: ork decisao registrar|placar <thread-id>',
+    usoRegistrar: 'usage: ork decisao registrar <thread-id> --decidido D --porque P ...',
+    usoPlacar: 'usage: ork decisao placar <thread-id> [--json]',
+    exigeFlag: (nome) => `decisao registrar requires --${nome}`,
+    criterioUso: 'decisao registrar: --criterio manifesto:KEY, ledger:REF or medicao:COMMAND',
+    linhaFalta: (campo) => `missing ${campo}`,
+    linhaQuebrada: (campo) => `${campo} has a line break; each field must be one line`,
+    linhaControle: (campo) => `${campo} has a control character`,
+    linhaLonga: (campo, tamanho, teto) => `${campo} has ${tamanho} characters; the limit is ${teto}`,
+    contratoCampoDeGate: (campo) => `HITL v2 request: an informed decision cannot include ${campo}`,
+    contratoCamposObrigatorios: (problema) => `HITL v2 request: informed decision needs what was decided, why and how to change it (${problema})`,
+    contratoCampoInvalido: (problema) => `HITL v2 request: informed decision: ${problema}`,
+    contratoCustoObrigatorio: 'HITL v2 request: reversal cost requires both now and later',
+    contratoCustoInvalido: (problema) => `HITL v2 request: reversal cost: ${problema}`,
+    contratoCriterioObrigatorio: 'HITL v2 request: informed decision criterion must be cited and resolvable',
+    contratoCriterioInvalido: (problema) => `HITL v2 request: criterion: ${problema}`,
+    contratoIrreversivel: 'HITL v2 request: an irreversible act is never an informed decision',
+    contratoComumInvalido: 'HITL v2 request: invalid identification, mode, timestamp, or depth',
+    contratoAlternativas: 'HITL v2 request: expected 2 to 5 choices labeled a through e',
+    contratoAlternativaSemTexto: 'HITL v2 request: choice has no text',
+    contratoAlternativaSemAcao: 'HITL v2 request: choice has no explicit action',
+    contratoAlternativaSemConsequencia: 'HITL v2 request: choice has no one-line consequence',
+    contratoPorqueSoRecomendada: 'HITL v2 request: only the recommended choice states why',
+    contratoRecomendadaBoolean: 'HITL v2 request: recomendada only accepts true or absence',
+    contratoRecomendadaSemPorque: 'HITL v2 request: the recommended choice must state why in one line',
+    contratoUmaRecomendada: 'HITL v2 request: exactly one choice must be recommended',
+    contratoPerguntaFrase: 'HITL v2 request: the question must be one sentence without a line break',
+    contratoMotivoInvalido: 'HITL v2 request: invalid reason',
+    contratoCorpoLinhas: 'HITL v2 request: the body must be a list of lines, never running prose',
+    contratoTipoRespostaInvalido: 'HITL v2 request: invalid response type',
+    contratoCodigoInvalido: 'HITL v2 request: invalid short code',
+    contratoAlvoInvalido: 'HITL v2 request: invalid target',
+    contratoRespostaInvalida: 'HITL v2 request: invalid accepted response',
+    contratoPrazoInvalido: 'HITL v2 request: invalid deadline or expiration action',
+    contratoDependenciaInvalida: 'HITL v2 request: a technical dependency requires the exact command and why, one line each',
+    contratoIrreversivelAusente: 'HITL v2 request: irreversibility must be declared',
+    contratoAtoIrreversivelInvalido: 'HITL v2 request: an irreversible act must name one from the frozen list',
+    contratoIrreversivelExpira: 'HITL v2 request: an irreversible act never advances on expiration',
+    contratoAtoSoIrreversivel: 'HITL v2 request: only an irreversible request names an act',
+    contratoDesconhecido: 'HITL v2 request: invalid contract',
+    contratoClasseInvalida: 'HITL v2 request: class must be decidido or pergunta',
+    selecaoVersao: 'an Orkastery conduction request uses ork.hitl/v2 with declared choices',
+    selecaoFaixa: (minimo, maximo, atual) => `expected ${minimo} to ${maximo} choices; this request has ${atual}`,
+    selecaoRecomendada: (atual) => `expected exactly one choice with the Recommendation badge; this request has ${atual}`,
+    selecaoTextoLivre: 'free-form text requires a typed technical dependency: the exact command the owner runs in the terminal and why',
+    threadFechada: 'informed decision: a closed thread cannot decide anything else',
+    criterioNaoResolve: (detalhe) => `informed decision: the criterion does not resolve (${detalhe})`,
+    criterioMedicao: 'command cited; CHECK runs it and fails it when needed',
+    criterioManifestoIlegivel: 'the project manifest could not be read',
+    criterioManifestoSemChave: (referencia) => `the manifest has no ${referencia} key`,
+    criterioManifestoVazio: (referencia) => `the ${referencia} key exists but is empty`,
+    criterioManifestoLido: (referencia) => `${referencia} read from the manifest`,
+    criterioLedgerIlegivel: (thread) => `thread ${thread} has no readable ledger`,
+    criterioEvento: (evento, thread) => `event ${evento} from ${thread}`,
+    criterioEventoAusente: (evento, thread) => typeof evento === 'number' ? `${thread} has no event ${evento}` : `no event from ${thread} has that identifier`,
+    faseMudou: 'informed decision: the phase changed while it was being recorded',
+    revertidaNaoExiste: 'informed decision: the reversed decision does not exist in this thread',
+    autorMcp: 'mcp.decision.author: quemDecidiu is the session that decided, never the owner',
+    rastroObrigatorio: (campo) => `an autonomous decision requires ${campo}: who decided, with what evidence and why`,
+    colunasDoPlacar: ['PHASE', 'DECIDED', 'INFORMED', 'QUESTIONS', 'REVERTED', 'NO TRAIL', 'THRESHOLD'],
+    acimaDoLimiar: (limiar) => `above ${limiar}: review`,
+    dentroDoLimiar: 'ok',
+    taxaDeReversao: (taxa) => `\nreversal rate of informed decisions: ${taxa === null ? 'no informed decision yet' : `${Math.round(taxa * 100)}%`}`,
+    curto: {
+        selo: 'Recommendation',
+        atos: {
+            dinheiro: 'spends money', 'publicacao-externa': 'publishes outside the project',
+            'apagar-dado': 'deletes data', 'push-base-protegida': 'pushes to the protected base',
+        },
+        soPergunta: 'short request: only an ork.hitl/v2 question has declared choices',
+        semRespostaRecomendada: (until) => `With no answer${until}, I will follow the recommendation.`,
+        semRespostaEscala: (until) => `With no answer${until}, the request is escalated.`,
+        ate: (value) => ` until ${value}`,
+        semRespostaSessao: 'With no answer, the session remains stopped.',
+        semRespostaGate: 'With no answer, nothing advances.',
+        alternativas: 'short request: expected 2 to 5 choices',
+        umaRecomendada: 'short request: exactly one choice must be recommended',
+        sessaoParada: (id) => `Session ${id} is stopped waiting for you`,
+        faseParada: (phase) => `${phase ? `Phase ${phase}` : 'The thread'} is stopped waiting for you`,
+        desde: (value) => ` since ${value}`,
+        semThread: 'no thread',
+        semVolta: (act) => `No undo after completion: ${act}.`,
+        respostaTexto: 'Write your answer; it is sent as entered.',
+        respostaTerminal: (recommended, command) => `after running the command, ${recommended}) is \`${command}\`.`,
+        respostaDialogo: 'Select the option in the dialog; typing the letter also works.',
+        respostaTelegram: (code, recommended) => `↩️ Reply: ${code} ${recommended} (or another letter). Evidence: ${code} details.`,
+        respostaHost: (code, recommended) => `Reply on Telegram: ${code} ${recommended} (or another letter); here, use the host dialog. Evidence: ${code} details.`,
+        listaDeLetras: (letters) => letters.length < 2 ? letters.join('') : `${letters.slice(0, -1).join(', ')} or ${letters.at(-1)}`,
+        respostaLetras: (letters, code) => `Reply ${letters}. Details: ${code} detalhes.`,
+        respostaLetrasHost: (letters, code) => `${letters} on Telegram, or through the host's confirmation window. Details: ${code} detalhes.`,
+        contratoInvalido: 'short request: invalid contract',
+        pergunta: 'Question', situacao: 'Situation', porque: 'why', responder: 'Answer',
+        acimaDoTeto: 'short request: above the line limit',
+    },
+};

package/dist/locale-docs.js

@@ -0,0 +1,230 @@
+"use strict";
+/**
+ * RM-061, fatia F3b: a familia `docs` do catalogo de mensagens (`ork docs verificar|sincronizar` e o uso), o resumo da
+ * verificacao, os achados e a sincronizacao. O pt-BR e a fonte; o ingles e tipado por ele. Sem import do nucleo.
+ *
+ * O que o `ork docs verificar` le nas paginas (chaves e valores do frontmatter, nomes das secoes, a linha
+ * `> **Em uma frase:**`, marcadores) segue em pt-BR em qualquer lingua: so a mensagem muda. A mensagem e a correcao de
+ * cada achado vao ao `--json` em pt-BR e so a impressao as remonta (G4); a regra (`docs.id.formato`) sai igual. O
+ * travessao longo das frases pt-BR de antes fica como escape: nenhum arquivo do catalogo o traz literal.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOCS_EN = exports.DOCS_PT_BR = void 0;
+const TRAVESSAO = '\u2014';
+const MUDANCAS_EN = { 'tabelas de estado': 'state tables', desatualizadas: 'outdated', regeradas: 'regenerated' };
+exports.DOCS_PT_BR = {
+    // O resumo e a sincronizacao
+    resumo: (paginas, features, itens, contexto) => `Documentação: ${paginas} páginas ${TRAVESSAO} ${features} features, ${itens} itens de roadmap, ${contexto} de contexto`,
+    semErro: (avisos) => `OK: nenhum erro de paridade${avisos ? ` · ${avisos} aviso(s) de leitura` : ''}`,
+    reprovado: (erros, avisos) => `REPROVADO: ${erros} erro(s)${avisos ? ` · ${avisos} aviso(s)` : ''}`,
+    tituloErros: 'Erros',
+    tituloAvisos: 'Avisos',
+    sincronizado: 'Sincronizado: a documentação já bate com o ledger e o git.',
+    aAtualizar: (escreveu, itens, indices) => `${escreveu ? 'Atualizado' : 'A atualizar'}: ${itens} item(ns) de roadmap, ${indices} índice(s).`,
+    /** Uma mudanca da sincronizacao; o campo e os valores sao dado do `--json` e so a impressao os traduz. */
+    linhaDaMudanca: (id, campo, de, para, fonte) => `  ${id.padEnd(7)} ${campo}: ${de || TRAVESSAO} \u2192 ${para}  (${fonte})`,
+    indice: (arquivo) => `  índice  ${arquivo}`,
+    nadaGravado: 'Nada foi gravado. Para gravar: ork docs sincronizar --escrever',
+    escopo: (escopo) => `Escopo: ${escopo}.`,
+    escopoTodos: 'todo item do roadmap',
+    escopoSo: (itens) => `so ${itens} (--so)`,
+    escopoDaThread: (itens, thread) => `so ${itens}, o item da thread ${thread} desta worktree (--todos para todo item)`,
+    usoSoSemItem: 'uso: ork docs sincronizar --so RM-NNN[,RM-MMM] (faltou o item depois de --so)',
+    usoSoInvalido: (recebido) => `uso: ork docs sincronizar --so RM-NNN[,RM-MMM] (recebido: ${recebido})`,
+    uso: 'uso: ork docs verificar [--json] [--pr] | sincronizar [--escrever] [--so RM-NNN] [--todos] | init',
+    // Os achados
+    semFrontmatter: 'página sem frontmatter YAML',
+    semFrontmatterCorrecao: 'comece o arquivo com as chaves do modelo entre duas linhas ---',
+    frontmatterInvalido: (erro) => `frontmatter inválido: ${erro}`,
+    frontmatterNaoMapa: 'o frontmatter precisa ser um mapa de chaves',
+    tipoDesconhecido: (tipo) => `tipo "${tipo}" desconhecido`,
+    useUmDe: (valores) => `use um de: ${valores}`,
+    useUmaDe: (valores) => `use uma de: ${valores}`,
+    idForaDoPadrao: (id, tipo) => `ID "${id}" fora do padrão de ${tipo}`,
+    formatoEsperado: (formato) => `formato esperado: ${formato}`,
+    arquivoSemId: 'o nome do arquivo não começa pelo ID',
+    renomeie: (id) => `renomeie para ${id}-<assunto>.md`,
+    pastaErrada: (tipo, pasta) => `${tipo} mora em ${pasta}`,
+    idRepetido: (arquivo) => `ID repetido: também em ${arquivo}`,
+    idRepetidoCorrecao: 'IDs são estáveis e únicos; renumere o novo, nunca o antigo',
+    baseAusente: (branch) => `branch base "${branch}" não encontrada: a paridade com o git ficou de fora`,
+    baseAusenteCorrecao: 'rode com o histórico do git disponível (fetch-depth: 0 no CI)',
+    faltaChave: (chave) => `falta a chave "${chave}"`,
+    faltaChaveCorrecao: `copie a chave do modelo; lacuna é "A definir ${TRAVESSAO} responsável, prazo"`,
+    estadoForaDoPadrao: (estado) => `estado "${estado}" fora do padrão`,
+    categoriaForaDoPadrao: (categoria) => `categoria "${categoria}" fora do padrão`,
+    estadoNaoMapa: 'estado do roadmap é um mapa de dimensões',
+    dimensoes: (lista) => `dimensões: ${lista}`,
+    faltaDimensao: (dim) => `falta a dimensão estado.${dim}`,
+    faltaDimensaoCorrecao: 'o padrão atualiza cada dimensão separadamente',
+    dimensaoForaDoPadrao: (dim, valor) => `estado.${dim} "${valor}" fora do padrão`,
+    dimensaoDesconhecida: (dim) => `dimensão desconhecida estado.${dim}`,
+    dataSemFuso: (chave, valor) => `${chave} "${valor}" não é ISO 8601 com fuso`,
+    dataExemplo: 'exemplo: 2026-09-24T20:00:00-03:00',
+    valorDoModelo: (onde, valor) => `valor do modelo não preenchido em ${onde}: ${valor}`,
+    faltaTabela: (nome) => `falta ${nome} gerada do frontmatter`,
+    faltaTabelaCorrecao: 'copie os marcadores do modelo e rode ork docs sincronizar --escrever',
+    tabelaDiverge: (nome) => `${nome} diverge do frontmatter`,
+    tabelaDivergeCorrecao: 'o estado se edita no frontmatter; rode ork docs sincronizar --escrever para regerar a tabela',
+    nomeDaRelance: 'a linha de relance',
+    nomeDoEstado: 'a tabela "Estado com evidências"',
+    paiDeOutroNivel: (pai, tipo) => `pai "${pai}" não é do nível acima de ${tipo}`,
+    paiNaoExiste: (pai) => `pai ${pai} não existe`,
+    paiNaoExisteCorrecao: 'crie a página do pai ou corrija o ID',
+    precisaDePai: (tipo) => `${tipo} precisa de pai`,
+    citaInexistente: (chave, alvo, tipo) => `${chave} cita ${alvo}, que não existe como ${tipo}`,
+    naoCitaDeVolta: (alvo, id) => `${alvo} não cita ${id} de volta`,
+    naoCitaDeVoltaCorrecao: (id, chave, alvo) => `acrescente ${id} em ${chave} de ${alvo}`,
+    linkQuebrado: (alvo) => `link quebrado: ${alvo}`,
+    tituloSemId: 'o título (#) não começa pelo ID',
+    tituloSemIdCorrecao: (id) => `# ${id} ${TRAVESSAO} <nome>: humano e agente acham a página pelo mesmo nome`,
+    faltaFrase: 'falta a linha "> **Em uma frase:**" logo abaixo do título',
+    faltaFraseCorrecao: 'escreva o que a página responde, antes de qualquer detalhe',
+    fraseVazia: 'a frase de abertura está vazia',
+    fraseLonga: (n, limite) => `a frase de abertura tem ${n} caracteres (limite ${limite})`,
+    fraseLongaCorrecao: 'corte para uma ideia só; o resto vai em tópicos',
+    faltaSecao: (secao) => `falta a seção "## ${secao}"`,
+    faltaSecaoCorrecao: `se não se aplica, escreva dentro dela: Não aplicável ${TRAVESSAO} motivo`,
+    campoDoModelo: (campo) => `campo do modelo não preenchido: [${campo}]`,
+    campoDoModeloCorrecao: `preencha, ou escreva "A definir ${TRAVESSAO} responsável, prazo" / "Não aplicável ${TRAVESSAO} motivo"`,
+    paragrafoLongo: (n) => `parágrafo com ${n} caracteres`,
+    paragrafoLongoCorrecao: 'quebre em tópicos: uma ideia por linha',
+    fontesNaoMapa: 'fontes é um mapa (codigo, testes, simbolos, contratos, comandos)',
+    caminhoFora: (caminho) => `${caminho}: caminho fora do repositório`,
+    caminhoForaCorrecao: 'use caminho relativo à raiz',
+    caminhoNaoExiste: (caminho) => `${caminho} não existe no repositório`,
+    caminhoNaoExisteCorrecao: 'a doc descreve o código que existe: corrija o caminho ou a página',
+    simboloForaDoFormato: (simbolo) => `símbolo "${simbolo}" fora do formato arquivo#nome`,
+    arquivoDoSimbolo: (arquivo, simbolo) => `${arquivo} não existe (símbolo ${simbolo})`,
+    simboloAusente: (simbolo, arquivo) => `${simbolo} não aparece em ${arquivo}`,
+    simboloAusenteCorrecao: 'o código mudou de nome ou a página ficou para trás',
+    contratoAusente: (contrato) => `o contrato ${contrato} não aparece nos arquivos de fontes.codigo`,
+    comandoAusente: (comando) => `o CLI não declara "${comando}"`,
+    comandoAusenteCorrecao: 'confira `ork --help`: a doc descreve o CLI que existe',
+    concluidoSemMerge: 'ciclo Concluído com código que não está Mesclado',
+    concluidoSemTestes: 'ciclo Concluído com testes que não estão Aprovados',
+    producaoSemMerge: 'deploy em Produção com código que não está Mesclado',
+    bloqueadoSemMapa: 'Bloqueado exige o mapa "bloqueio"',
+    bloqueadoSemMapaCorrecao: 'bloqueio: motivo, dependencia, responsavel, proxima_revisao',
+    mescladoSemCommit: 'código Mesclado sem o commit do merge',
+    mescladoSemCommitCorrecao: 'preencha evidencias.codigo.commit (ork docs sincronizar faz isso a partir do ledger e do git)',
+    commitInexistente: (commit) => `o commit ${commit} não existe neste repositório`,
+    commitForaDaBase: (commit, base) => `o commit ${commit} não está na ${base}: o merge não aconteceu`,
+    commitForaDaBaseCorrecao: 'volte o estado.codigo para "PR aberto" ou "Branch criada" até o merge',
+    mergeDaThread: (thread, base, merge, codigo, pr) => `a thread ${thread} entrou na ${base} pelo merge ${merge} (ship(${thread})), e o estado.codigo diz "${codigo || 'vazio'}"` +
+        (pr ? ' (no PR, aviso: o push da main reprova)' : ''),
+    mergeDaThreadCorrecao: (base, id) => `abra um PR de docs sobre a ${base} atualizada com ork docs sincronizar --escrever --so ${id} (o item e os índices); ` +
+        'se o item tem outra fatia em curso, aponte sdlc.thread para a thread dela',
+    indiceNaoGerado: 'o índice ainda não foi gerado',
+    indiceNaoGeradoCorrecao: 'rode ork docs sincronizar --escrever',
+    indiceDiverge: (pr) => `o índice diverge do frontmatter das páginas${pr ? ' (no PR, aviso: o push da main reprova)' : ''}`,
+    indiceDivergeCorrecao: 'o índice é gerado do frontmatter: rode ork docs sincronizar --escrever e commite o índice',
+};
+exports.DOCS_EN = {
+    resumo: (paginas, features, itens, contexto) => `Documentation: ${paginas} pages (${features} feature(s), ${itens} roadmap item(s), ${contexto} context page(s))`,
+    semErro: (avisos) => `OK: no parity error${avisos ? ` · ${avisos} reading warning(s)` : ''}`,
+    reprovado: (erros, avisos) => `FAILED: ${erros} error(s)${avisos ? ` · ${avisos} warning(s)` : ''}`,
+    tituloErros: 'Errors',
+    tituloAvisos: 'Warnings',
+    sincronizado: 'In sync: the documentation already matches the ledger and git.',
+    aAtualizar: (escreveu, itens, indices) => `${escreveu ? 'Updated' : 'To update'}: ${itens} roadmap item(s), ${indices} index(es).`,
+    linhaDaMudanca: (id, campo, de, para, fonte) => {
+        const v = (x) => MUDANCAS_EN[x] ?? x;
+        return `  ${id.padEnd(7)} ${v(campo)}: ${v(de) || '-'} \u2192 ${v(para)}  (${fonte})`;
+    },
+    indice: (arquivo) => `  index   ${arquivo}`,
+    nadaGravado: 'Nothing was written. To write: `ork docs sincronizar --escrever`',
+    escopo: (escopo) => `Scope: ${escopo}.`,
+    escopoTodos: 'every roadmap item',
+    escopoSo: (itens) => `only ${itens} (\`--so\`)`,
+    escopoDaThread: (itens, thread) => `only ${itens}, the item of thread ${thread} in this worktree (\`--todos\` for every item)`,
+    usoSoSemItem: 'usage: ork docs sincronizar --so RM-NNN[,RM-MMM] (the item after `--so` is missing)',
+    usoSoInvalido: (recebido) => `usage: ork docs sincronizar --so RM-NNN[,RM-MMM] (got: ${recebido})`,
+    uso: 'usage: ork docs verificar [--json] [--pr] | sincronizar [--escrever] [--so RM-NNN] [--todos] | init',
+    semFrontmatter: 'page without YAML frontmatter',
+    semFrontmatterCorrecao: 'start the file with the template keys between two `---` lines',
+    frontmatterInvalido: (erro) => `invalid frontmatter: ${erro}`,
+    frontmatterNaoMapa: 'the frontmatter must be a map of keys',
+    tipoDesconhecido: (tipo) => `unknown type "${tipo}"`,
+    useUmDe: (valores) => `use one of: ${valores}`,
+    useUmaDe: (valores) => `use one of: ${valores}`,
+    idForaDoPadrao: (id, tipo) => `ID "${id}" does not follow the ${tipo} pattern`,
+    formatoEsperado: (formato) => `expected format: ${formato}`,
+    arquivoSemId: 'the file name does not start with the ID',
+    renomeie: (id) => `rename it to ${id}-<subject>.md`,
+    pastaErrada: (tipo, pasta) => `a ${tipo} lives in ${pasta}`,
+    idRepetido: (arquivo) => `repeated ID: also in ${arquivo}`,
+    idRepetidoCorrecao: 'IDs are stable and unique; renumber the new one, never the old one',
+    baseAusente: (branch) => `base branch "${branch}" not found: git parity was left out`,
+    baseAusenteCorrecao: 'run with the git history available (`fetch-depth: 0` in CI)',
+    faltaChave: (chave) => `missing key "${chave}"`,
+    faltaChaveCorrecao: 'copy the key from the template; a gap is written as `To be defined` with an owner and a deadline',
+    estadoForaDoPadrao: (estado) => `state "${estado}" outside the standard`,
+    categoriaForaDoPadrao: (categoria) => `category "${categoria}" outside the standard`,
+    estadoNaoMapa: 'the roadmap state is a map of dimensions',
+    dimensoes: (lista) => `dimensions: ${lista}`,
+    faltaDimensao: (dim) => `missing dimension estado.${dim}`,
+    faltaDimensaoCorrecao: 'the standard updates each dimension separately',
+    dimensaoForaDoPadrao: (dim, valor) => `estado.${dim} "${valor}" outside the standard`,
+    dimensaoDesconhecida: (dim) => `unknown dimension estado.${dim}`,
+    dataSemFuso: (chave, valor) => `${chave} "${valor}" is not ISO 8601 with a timezone`,
+    dataExemplo: 'example: 2026-09-24T20:00:00-03:00',
+    valorDoModelo: (onde, valor) => `template value not filled in at ${onde}: ${valor}`,
+    faltaTabela: (nome) => `missing ${nome} generated from the frontmatter`,
+    faltaTabelaCorrecao: 'copy the markers from the template and run `ork docs sincronizar --escrever`',
+    tabelaDiverge: (nome) => `${nome} differs from the frontmatter`,
+    tabelaDivergeCorrecao: 'the state is edited in the frontmatter; run `ork docs sincronizar --escrever` to regenerate the table',
+    nomeDaRelance: 'the summary row',
+    nomeDoEstado: 'the "Estado com evidências" table',
+    paiDeOutroNivel: (pai, tipo) => `parent "${pai}" is not from the level above ${tipo}`,
+    paiNaoExiste: (pai) => `parent ${pai} does not exist`,
+    paiNaoExisteCorrecao: 'create the parent page or fix the ID',
+    precisaDePai: (tipo) => `a ${tipo} needs a parent`,
+    citaInexistente: (chave, alvo, tipo) => `${chave} cites ${alvo}, which does not exist as a ${tipo}`,
+    naoCitaDeVolta: (alvo, id) => `${alvo} does not cite ${id} back`,
+    naoCitaDeVoltaCorrecao: (id, chave, alvo) => `add ${id} to ${chave} of ${alvo}`,
+    linkQuebrado: (alvo) => `broken link: ${alvo}`,
+    tituloSemId: 'the title (#) does not start with the ID',
+    tituloSemIdCorrecao: (id) => `\`# ${id}\` followed by the name: people and agents find the page by the same name`,
+    faltaFrase: 'missing the "> **Em uma frase:**" line right below the title',
+    faltaFraseCorrecao: 'write what the page answers, before any detail',
+    fraseVazia: 'the opening sentence is empty',
+    fraseLonga: (n, limite) => `the opening sentence has ${n} characters (limit ${limite})`,
+    fraseLongaCorrecao: 'cut it down to one idea; the rest goes into bullets',
+    faltaSecao: (secao) => `missing section "## ${secao}"`,
+    faltaSecaoCorrecao: 'if it does not apply, write inside it: `Not applicable: reason`',
+    campoDoModelo: (campo) => `template field not filled in: [${campo}]`,
+    campoDoModeloCorrecao: 'fill it in, or write `To be defined: owner, deadline` or `Not applicable: reason`',
+    paragrafoLongo: (n) => `paragraph with ${n} characters`,
+    paragrafoLongoCorrecao: 'break it into bullets: one idea per line',
+    fontesNaoMapa: 'fontes is a map (codigo, testes, simbolos, contratos, comandos)',
+    caminhoFora: (caminho) => `${caminho}: path outside the repository`,
+    caminhoForaCorrecao: 'use a path relative to the root',
+    caminhoNaoExiste: (caminho) => `${caminho} does not exist in the repository`,
+    caminhoNaoExisteCorrecao: 'the doc describes the code that exists: fix the path or the page',
+    simboloForaDoFormato: (simbolo) => `symbol "${simbolo}" is not in the file#name format`,
+    arquivoDoSimbolo: (arquivo, simbolo) => `${arquivo} does not exist (symbol ${simbolo})`,
+    simboloAusente: (simbolo, arquivo) => `${simbolo} does not appear in ${arquivo}`,
+    simboloAusenteCorrecao: 'the code changed its name or the page fell behind',
+    contratoAusente: (contrato) => `the contract ${contrato} does not appear in the fontes.codigo files`,
+    comandoAusente: (comando) => `the CLI does not declare "${comando}"`,
+    comandoAusenteCorrecao: 'check `ork --help`: the doc describes the CLI that exists',
+    concluidoSemMerge: 'cycle Concluído with code that is not Mesclado',
+    concluidoSemTestes: 'cycle Concluído with tests that are not Aprovados',
+    producaoSemMerge: 'deploy in Produção with code that is not Mesclado',
+    bloqueadoSemMapa: 'Bloqueado needs the "bloqueio" map',
+    bloqueadoSemMapaCorrecao: 'add the `bloqueio` map with motivo, dependencia, responsavel and proxima_revisao',
+    mescladoSemCommit: 'code Mesclado without the merge commit',
+    mescladoSemCommitCorrecao: 'fill in evidencias.codigo.commit (`ork docs sincronizar` does it from the ledger and git)',
+    commitInexistente: (commit) => `commit ${commit} does not exist in this repository`,
+    commitForaDaBase: (commit, base) => `commit ${commit} is not in ${base}: the merge did not happen`,
+    commitForaDaBaseCorrecao: 'set estado.codigo back to "PR aberto" or "Branch criada" until the merge',
+    mergeDaThread: (thread, base, merge, codigo, pr) => `thread ${thread} entered ${base} through merge ${merge} (ship(${thread})), and estado.codigo says "${codigo || 'empty'}"` +
+        (pr ? ' (in the PR, a warning: the push to main fails)' : ''),
+    mergeDaThreadCorrecao: (base, id) => `open a docs PR on the updated ${base} with \`ork docs sincronizar --escrever --so ${id}\` (the item and the indexes); ` +
+        'if the item has another slice in progress, point `sdlc.thread` to its thread',
+    indiceNaoGerado: 'the index was not generated yet',
+    indiceNaoGeradoCorrecao: 'run `ork docs sincronizar --escrever`',
+    indiceDiverge: (pr) => `the index differs from the frontmatter of the pages${pr ? ' (in the PR, a warning: the push to main fails)' : ''}`,
+    indiceDivergeCorrecao: 'the index is generated from the frontmatter: run `ork docs sincronizar --escrever` and commit the index',
+};