@orkastery/cli 0.5.6 → 0.6.0

package/dist/hitl-contract.js

@@ -29,6 +29,7 @@ exports.motivoDoPedido = motivoDoPedido;
 /** D1: contrato de pedido, independente do host. Expiração nunca autoriza. */
 const modos_1 = require("./modos");
 const types_1 = require("./types");
+const locale_1 = require("./locale");
 exports.CONTRATO_HITL = 'ork.hitl/v1';
 /**
  * D5: a lista FECHADA de atos que nao se desfazem. Ela mora no nucleo, congelada, e nao no
@@ -216,7 +217,7 @@ function validarComumV2(v) {
     if (!identificador(v.id) || !identificador(v.thread) || !types_1.FASES.includes(v.fase) ||
         !modos_1.MODOS_LEGADOS.includes(v.modo) || !iso(v.criadoEm) ||
         !['resumo', 'detalhada', 'profunda'].includes(v.profundidade)) {
-        throw new Error('pedido HITL v2: identificação, modo, instante ou profundidade inválidos');
+        throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoComumInvalido);
     }
 }
 /**
@@ -225,14 +226,15 @@ function validarComumV2(v) {
  * mandou os tres campos nao tinha como saber que o problema era o tamanho.
  */
 function problemaDaLinha(campo, v, teto) {
+    const m = (0, locale_1.msg)().decisao;
     if (typeof v !== 'string' || !v.trim())
-        return { ausente: true, texto: `falta ${campo}` };
+        return { ausente: true, texto: m.linhaFalta(campo) };
     if (/[\r\n]/.test(v))
-        return { ausente: false, texto: `${campo} tem quebra de linha; cada campo é uma linha só` };
+        return { ausente: false, texto: m.linhaQuebrada(campo) };
     if (/[\x00-\x08\x0b-\x1f\x7f]/.test(v))
-        return { ausente: false, texto: `${campo} tem caractere de controle` };
+        return { ausente: false, texto: m.linhaControle(campo) };
     if (v.length > teto)
-        return { ausente: false, texto: `${campo} tem ${v.length} caracteres; o teto é ${teto}` };
+        return { ausente: false, texto: m.linhaLonga(campo, v.length, teto) };
     return null;
 }
 /**
@@ -249,121 +251,121 @@ exports.CAMPOS_DA_DECISAO_NO_MCP = Object.freeze({
 });
 /** Troca o nome interno do campo, onde a recusa o cita, pelo nome da superficie. */
 function recusaNaSuperficie(mensagem, nomes) {
-    return mensagem.replace(/(falta |: )(decidido|porque|comoMudar|custoDeReverter\.agora|custoDeReverter\.depois|criterio\.referencia)(?=\)| tem )/g, (_, antes, campo) => `${antes}${nomes[campo] ?? campo}`);
+    return mensagem.replace(/(falta |missing |: )(decidido|porque|comoMudar|custoDeReverter\.agora|custoDeReverter\.depois|criterio\.referencia)(?=\)| tem | has )/g, (_, antes, campo) => `${antes}${nomes[campo] ?? campo}`);
 }
 function validarDecidido(v) {
     for (const campo of exports.CAMPOS_DE_GATE) {
         if (v[campo] !== undefined)
-            throw new Error(`pedido HITL v2: decisão informada não pode trazer ${campo}`);
+            throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoCampoDeGate(campo));
     }
     for (const campo of ['decidido', 'porque', 'comoMudar']) {
         const problema = problemaDaLinha(campo, v[campo], exports.TETOS_HITL_V2.campoDaDecisao);
         if (problema?.ausente)
-            throw new Error(`pedido HITL v2: decisão informada exige o que foi decidido, o porquê e como mudar (${problema.texto})`);
+            throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoCamposObrigatorios(problema.texto));
         if (problema)
-            throw new Error(`pedido HITL v2: decisão informada: ${problema.texto}`);
+            throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoCampoInvalido(problema.texto));
     }
     const custo = v.custoDeReverter;
     const problemasDoCusto = ['agora', 'depois']
         .map(lado => problemaDaLinha(`custoDeReverter.${lado}`, objeto(custo) ? custo[lado] : undefined, exports.TETOS_HITL_V2.custo));
     if (problemasDoCusto.some(p => p?.ausente)) {
-        throw new Error('pedido HITL v2: custo de reverter exige agora e depois, os dois presentes');
+        throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoCustoObrigatorio);
     }
     const doCusto = problemasDoCusto.find(p => p !== null);
     if (doCusto)
-        throw new Error(`pedido HITL v2: custo de reverter: ${doCusto.texto}`);
+        throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoCustoInvalido(doCusto.texto));
     const criterio = v.criterio;
     const daReferencia = objeto(criterio) ? problemaDaLinha('criterio.referencia', criterio.referencia, 300) : null;
     if (!objeto(criterio) || !['manifesto', 'ledger', 'medicao'].includes(criterio.tipo) || daReferencia?.ausente) {
-        throw new Error('pedido HITL v2: decisão informada exige critério citado e resolvível');
+        throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoCriterioObrigatorio);
     }
     if (daReferencia)
-        throw new Error(`pedido HITL v2: critério: ${daReferencia.texto}`);
+        throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoCriterioInvalido(daReferencia.texto));
     // R1, porta fechada: ato irreversivel nunca se qualifica como decisao informada.
     if (v.irreversivel === true)
-        throw new Error('pedido HITL v2: ato irreversível nunca é decisão informada');
+        throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoIrreversivel);
 }
 function validarAlternativas(v) {
     const alternativas = v.alternativas;
     if (!Array.isArray(alternativas) || alternativas.length < 2 || alternativas.length > exports.LETRAS_DE_ALTERNATIVA.length) {
-        throw new Error('pedido HITL v2: de 2 a 5 alternativas, rotuladas de a a e');
+        throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoAlternativas);
     }
     let recomendadas = 0;
     alternativas.forEach((bruta, i) => {
         if (!objeto(bruta) || bruta.letra !== exports.LETRAS_DE_ALTERNATIVA[i]) {
-            throw new Error('pedido HITL v2: de 2 a 5 alternativas, rotuladas de a a e');
+            throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoAlternativas);
         }
         if (!linhaUnica(bruta.texto, exports.TETOS_HITL_V2.alternativaTexto))
-            throw new Error('pedido HITL v2: alternativa sem texto');
+            throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoAlternativaSemTexto);
         if (!['aprovar', 'recusar', 'responder', 'esperar'].includes(bruta.acao)) {
-            throw new Error('pedido HITL v2: alternativa sem ação explícita');
+            throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoAlternativaSemAcao);
         }
         if (!linhaUnica(bruta.consequencia, exports.TETOS_HITL_V2.consequencia)) {
-            throw new Error('pedido HITL v2: alternativa sem consequência em uma linha');
+            throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoAlternativaSemConsequencia);
         }
         if (bruta.recomendada === undefined) {
             if (bruta.porque !== undefined)
-                throw new Error('pedido HITL v2: só a alternativa recomendada diz o porquê');
+                throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoPorqueSoRecomendada);
             return;
         }
         if (bruta.recomendada !== true)
-            throw new Error('pedido HITL v2: recomendada só aceita true ou ausência');
+            throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoRecomendadaBoolean);
         if (!linhaUnica(bruta.porque, exports.TETOS_HITL_V2.porque)) {
-            throw new Error('pedido HITL v2: a alternativa recomendada precisa dizer o porquê em uma linha');
+            throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoRecomendadaSemPorque);
         }
         recomendadas++;
     });
     if (recomendadas !== 1)
-        throw new Error('pedido HITL v2: exatamente uma alternativa é recomendada');
+        throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoUmaRecomendada);
 }
 function validarPergunta(v) {
     if (!linhaUnica(v.pergunta, exports.TETOS_HITL_V2.pergunta)) {
-        throw new Error('pedido HITL v2: a pergunta é uma frase, sem quebra de linha');
+        throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoPerguntaFrase);
     }
     if (!texto(v.motivo, 100))
-        throw new Error('pedido HITL v2: motivo inválido');
+        throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoMotivoInvalido);
     validarAlternativas(v);
     if (!Array.isArray(v.corpo) || v.corpo.length > exports.TETOS_HITL_V2.corpoLinhas ||
         v.corpo.some(l => !linhaUnica(l, exports.TETOS_HITL_V2.corpoLinha))) {
-        throw new Error('pedido HITL v2: o corpo é lista de linhas, nunca prosa corrida');
+        throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoCorpoLinhas);
     }
     if (!['objetiva', 'aberta'].includes(v.tipoDeResposta))
-        throw new Error('pedido HITL v2: tipo de resposta inválido');
+        throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoTipoRespostaInvalido);
     if (!/^[0-9A-Za-z]{3,8}$/.test(String(v.codigo ?? '')))
-        throw new Error('pedido HITL v2: código curto inválido');
+        throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoCodigoInvalido);
     const alvo = v.alvo;
     if (!objeto(alvo) || !(alvo.tipo === 'gate' && texto(alvo.sobre, 100) ||
         alvo.tipo === 'session' && identificador(alvo.sessionId) && ['claude-bg', 'codex'].includes(alvo.runtime))) {
-        throw new Error('pedido HITL v2: alvo inválido');
+        throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoAlvoInvalido);
     }
     const aceita = v.respostaAceita;
     if (!objeto(aceita) || !['opcao', 'texto'].includes(aceita.tipo) ||
         !Number.isInteger(aceita.maxCaracteres) || Number(aceita.maxCaracteres) < 1 || Number(aceita.maxCaracteres) > 4096) {
-        throw new Error('pedido HITL v2: resposta aceita inválida');
+        throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoRespostaInvalida);
     }
     if (!iso(v.prazo) || Date.parse(v.prazo) <= Date.parse(v.criadoEm) ||
         !['esperar', 'escalar', 'seguir-recomendada'].includes(v.acaoPadraoAoExpirar)) {
-        throw new Error('pedido HITL v2: prazo ou ação de expiração inválidos');
+        throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoPrazoInvalido);
     }
     if (v.dependenciaTecnica !== undefined) {
         const d = v.dependenciaTecnica;
         if (!objeto(d) || !linhaUnica(d.comando, exports.TETOS_HITL_V2.campoDaDecisao) || !linhaUnica(d.porque, exports.TETOS_HITL_V2.porque)) {
-            throw new Error('pedido HITL v2: dependência técnica exige o comando exato e o porquê, uma linha cada');
+            throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoDependenciaInvalida);
         }
     }
     if (typeof v.irreversivel !== 'boolean')
-        throw new Error('pedido HITL v2: irreversível precisa ser declarado');
+        throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoIrreversivelAusente);
     if (v.irreversivel) {
         if (!exports.ATOS_IRREVERSIVEIS.includes(String(v.ato))) {
-            throw new Error('pedido HITL v2: ato irreversível precisa nomear um da lista congelada');
+            throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoAtoIrreversivelInvalido);
         }
         // D5, primeira das quatro barreiras: a combinacao nao chega a existir.
         if (v.acaoPadraoAoExpirar === 'seguir-recomendada') {
-            throw new Error('pedido HITL v2: ato irreversível nunca avança por expiração');
+            throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoIrreversivelExpira);
         }
     }
     else if (v.ato !== undefined) {
-        throw new Error('pedido HITL v2: só pedido irreversível nomeia ato');
+        throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoAtoSoIrreversivel);
     }
 }
 // ---------------------------------------------------------------------------
@@ -396,33 +398,33 @@ exports.SelecaoRecusada = SelecaoRecusada;
  */
 function exigirSelecaoDeConducao(pedido) {
     if (!ehV2(pedido)) {
-        throw new SelecaoRecusada('hitl.selecao.versao', 'o pedido de condução do ork sai em ork.hitl/v2, com alternativas declaradas');
+        throw new SelecaoRecusada('hitl.selecao.versao', (0, locale_1.msg)().decisao.selecaoVersao);
     }
     if (pedido.classe === 'decidido')
         return;
     const n = pedido.alternativas.length;
     if (n < exports.MINIMO_DE_ALTERNATIVAS_DE_CONDUCAO || n > exports.MAXIMO_DE_ALTERNATIVAS_DE_CONDUCAO) {
-        throw new SelecaoRecusada('hitl.selecao.fora-da-faixa', `de ${exports.MINIMO_DE_ALTERNATIVAS_DE_CONDUCAO} a ${exports.MAXIMO_DE_ALTERNATIVAS_DE_CONDUCAO} alternativas, este traz ${n}`);
+        throw new SelecaoRecusada('hitl.selecao.fora-da-faixa', (0, locale_1.msg)().decisao.selecaoFaixa(exports.MINIMO_DE_ALTERNATIVAS_DE_CONDUCAO, exports.MAXIMO_DE_ALTERNATIVAS_DE_CONDUCAO, n));
     }
     const recomendadas = pedido.alternativas.filter(a => a.recomendada).length;
     if (recomendadas !== 1) {
-        throw new SelecaoRecusada('hitl.selecao.recomendada', `exatamente uma alternativa com o selo Recomendação, este traz ${recomendadas}`);
+        throw new SelecaoRecusada('hitl.selecao.recomendada', (0, locale_1.msg)().decisao.selecaoRecomendada(recomendadas));
     }
     const pedeTexto = pedido.tipoDeResposta === 'aberta' || pedido.respostaAceita.tipo === 'texto';
     if (pedeTexto && !pedido.dependenciaTecnica) {
-        throw new SelecaoRecusada('hitl.selecao.texto-livre', 'resposta em texto só com dependência técnica tipada: o comando exato que o dono roda no terminal e o porquê');
+        throw new SelecaoRecusada('hitl.selecao.texto-livre', (0, locale_1.msg)().decisao.selecaoTextoLivre);
     }
 }
 /** Valida `ork.hitl/v2`. Nunca aceita um v1: quem julga v1 e o validador congelado. */
 function validarPedidoHitlV2(v) {
     if (!objeto(v) || v.contrato !== exports.CONTRATO_HITL_V2)
-        throw new Error('pedido HITL v2: contrato inválido');
+        throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoDesconhecido);
     validarComumV2(v);
     if (v.classe === 'decidido')
         return validarDecidido(v);
     if (v.classe === 'pergunta')
         return validarPergunta(v);
-    throw new Error('pedido HITL v2: classe precisa ser decidido ou pergunta');
+    throw new locale_1.ErroDoCatalogo((m) => m.decisao.contratoClasseInvalida);
 }
 /**
  * O leitor das duas versoes. Despacha por contrato: v1 pelo validador congelado, v2 pelo novo.
@@ -473,7 +475,8 @@ function classificarDecisao(sinais) {
  * `hitl.formato` para tudo tornaria o motivo tao generico quanto a string que ele substitui.
  */
 function motivoDaRecusaDeFormato(erro) {
-    const mensagem = erro instanceof Error ? erro.message : String(erro);
+    // RM-061 F3c: a recusa do catalogo e classificada pelo texto pt-BR, a fonte, em qualquer lingua de quem a leu.
+    const mensagem = erro instanceof locale_1.ErroDoCatalogo ? erro.montar((0, locale_1.msg)('pt-BR')) : erro instanceof Error ? erro.message : String(erro);
     return mensagem.startsWith('pedido HITL v2: ') && !mensagem.includes('contrato inválido')
         ? 'hitl.formato' : null;
 }

package/dist/hitl-curto.js

@@ -36,6 +36,7 @@ exports.desdeDoPedido = desdeDoPedido;
 const hitl_1 = require("./hitl");
 const hitl_contract_1 = require("./hitl-contract");
 const horario_1 = require("./horario");
+const locale_1 = require("./locale");
 exports.CONTRATO_PEDIDO_CURTO = 'ork.hitl-curto/v1';
 /** RM-057: o selo que o dono procura na lista, igual em todo canal. */
 exports.SELO_DA_RECOMENDADA = 'Recomendação';
@@ -60,7 +61,7 @@ const linha = (texto, teto = TETO_DA_LINHA) => {
 function entradaDoPedido(pedido, desde) {
     (0, hitl_contract_1.validarPedidoHitl)(pedido);
     if (!(0, hitl_contract_1.ehV2)(pedido) || pedido.classe !== 'pergunta') {
-        throw new Error('pedido curto: só uma pergunta ork.hitl/v2 tem alternativas declaradas');
+        throw new Error((0, locale_1.msg)().decisao.curto.soPergunta);
     }
     const alvo = (0, hitl_contract_1.alvoDoPedido)(pedido);
     return {
@@ -74,32 +75,34 @@ function entradaDoPedido(pedido, desde) {
 }
 /** O que acontece sem resposta, em meia linha. Expirar nunca autoriza. */
 function semResposta(e, agora) {
-    const ate = e.prazo ? ` até ${(0, horario_1.formatarHora)(e.prazo, { agora })}` : '';
+    const m = (0, locale_1.msg)().decisao.curto;
+    const ate = e.prazo ? m.ate((0, horario_1.formatarHora)(e.prazo, { agora })) : '';
     if (e.expiracao === 'seguir-recomendada')
-        return `Sem resposta${ate}, sigo com a recomendada.`;
+        return m.semRespostaRecomendada(ate);
     if (e.expiracao === 'escalar')
-        return `Sem resposta${ate}, o pedido é escalado.`;
-    return e.alvo?.tipo === 'session' ? 'Sem resposta, a sessão continua parada.' : 'Sem resposta, nada avança.';
+        return m.semRespostaEscala(ate);
+    return e.alvo?.tipo === 'session' ? m.semRespostaSessao : m.semRespostaGate;
 }
 /**
  * Monta o pedido curto. Recusa, em vez de cortar em silencio, o que o contrato nao aceita: menos
  * de duas alternativas, mais de cinco, ou recomendada diferente de exatamente uma.
  */
 function montarPedidoCurto(e, opcoes) {
+    const m = (0, locale_1.msg)().decisao.curto;
     if (e.alternativas.length < 2 || e.alternativas.length > 5)
-        throw new Error('pedido curto: de 2 a 5 alternativas');
+        throw new Error(m.alternativas);
     if (e.alternativas.filter(a => a.recomendada).length !== 1)
-        throw new Error('pedido curto: exatamente uma alternativa é recomendada');
+        throw new Error(m.umaRecomendada);
     const onde = e.alvo?.tipo === 'session'
-        ? `A sessão ${e.alvo.sessionId.slice(0, 8)} está parada esperando você`
-        : `${e.fase ? `A fase ${e.fase}` : 'A thread'} está parada esperando você`;
-    const desde = e.desde ? ` desde ${(0, horario_1.formatarDesde)(e.desde, { agora: opcoes.quando })}` : '';
+        ? m.sessaoParada(e.alvo.sessionId.slice(0, 8))
+        : m.faseParada(e.fase);
+    const desde = e.desde ? m.desde((0, horario_1.formatarDesde)(e.desde, { agora: opcoes.quando })) : '';
     return {
         contrato: exports.CONTRATO_PEDIDO_CURTO,
-        titulo: linha([e.thread, e.fase].filter(Boolean).join(' · ') || 'sem thread'),
+        titulo: linha(e.titulo ?? ([e.thread, e.fase].filter(Boolean).join(' · ') || m.semThread)),
         pergunta: linha(e.pergunta),
-        trava: linha(`${onde}${desde}. ${semResposta(e, opcoes.quando)}`),
-        ...(e.ato ? { semVolta: `Sem volta depois de feito: ${exports.TEXTO_DO_ATO[e.ato]}.` } : {}),
+        trava: linha(e.trava ?? `${onde}${desde}. ${semResposta(e, opcoes.quando)}`),
+        ...(e.ato ? { semVolta: m.semVolta(m.atos[e.ato]) } : {}),
         corpo: (e.corpo ?? []).slice(0, exports.TETO_DE_LINHAS_DO_CORPO).map(l => linha(l)).filter(Boolean),
         alternativas: e.alternativas.map(a => ({ chave: a.chave, texto: linha(a.texto, 140), consequencia: linha(a.consequencia, 140),
             ...(a.recomendada ? { recomendada: { porque: linha(a.recomendada.porque, 140) } } : {}) })),
@@ -109,43 +112,52 @@ function montarPedidoCurto(e, opcoes) {
 /** A ultima linha: exatamente o que digitar, sem identificador longo. */
 function linhaDeResposta(p, canal) {
     const r = p.responder, recomendada = p.alternativas.find(a => a.recomendada).chave;
+    const m = (0, locale_1.msg)().decisao.curto;
     if (r.tipo === 'numero')
         return null;
     if (r.tipo === 'texto')
-        return `${canal === 'telegram' ? '↩️ ' : ''}Responda escrevendo o texto; ele é enviado como está.`;
+        return `${canal === 'telegram' ? '↩️ ' : ''}${m.respostaTexto}`;
     if (r.tipo === 'terminal')
-        return `${canal === 'telegram' ? '↩️ ' : 'Responder: '}feito o comando, ${recomendada}) é \`${r.comando}\`.`;
+        return `${canal === 'telegram' ? '↩️ ' : `${m.responder}: `}${m.respostaTerminal(recomendada, r.comando)}`;
     if (r.tipo === 'dialogo')
-        return `${canal === 'telegram' ? '↩️ ' : ''}Responda selecionando a opção no diálogo; digitar a letra também vale.`;
+        return `${canal === 'telegram' ? '↩️ ' : ''}${m.respostaDialogo}`;
+    if (r.tipo === 'letras') {
+        // RM-057: as letras reais da pergunta, nunca uma linha para copiar; o detalhe fica a um pedido de distancia.
+        const letras = m.listaDeLetras(p.alternativas.map(a => a.chave));
+        return canal === 'telegram' ? `↩️ ${m.respostaLetras(letras, r.codigo)}` : `${m.responder}: ${m.respostaLetrasHost(letras, r.codigo)}`;
+    }
     return canal === 'telegram'
-        ? `↩️ Responda: ${r.codigo} ${recomendada} (ou outra letra). Evidências: ${r.codigo} detalhes.`
-        : `Responda pelo Telegram: ${r.codigo} ${recomendada} (ou outra letra); aqui, pelo diálogo do host. Evidências: ${r.codigo} detalhes.`;
+        ? m.respostaTelegram(r.codigo, recomendada)
+        : m.respostaHost(r.codigo, recomendada);
 }
 /**
  * O texto do pedido no canal. Telegram e terminal dizem a mesma coisa com marcadores diferentes;
  * nenhum dos dois passa de `TETO_DE_LINHAS_DO_PEDIDO` linhas.
  */
 function textoDoPedidoCurto(p, canal) {
+    const m = (0, locale_1.msg)().decisao.curto;
     if (p.contrato !== exports.CONTRATO_PEDIDO_CURTO)
-        throw new Error('pedido curto: contrato inválido');
+        throw new Error(m.contratoInvalido);
     const tg = canal === 'telegram';
     const numero = p.responder.tipo === 'numero' ? `${p.responder.numero}. ` : '';
+    // RM-057 (resposta curta): a pergunta servida sozinha leva o numero do lote, para "1a" tambem valer.
+    const servida = p.responder.tipo === 'letras' && p.responder.numero ? `${p.responder.numero}. ` : '';
     const linhas = [
-        `${tg && !numero ? '🔔 ' : ''}${numero}${tg || numero ? '' : 'Orkastery · '}${p.titulo}`,
-        `${tg ? '❓ ' : 'Pergunta: '}${p.pergunta}`,
-        `${tg ? '⏳ ' : 'Situação: '}${p.trava}`,
+        `${tg && !numero ? '🔔 ' : ''}${numero || servida}${tg || numero ? '' : 'Orkastery · '}${p.titulo}`,
+        `${tg ? '❓ ' : `${m.pergunta}: `}${p.pergunta}`,
+        `${tg ? '⏳ ' : `${m.situacao}: `}${p.trava}`,
         ...(p.semVolta ? [`${tg ? '🔒 ' : '! '}${p.semVolta}`] : []),
         ...p.corpo.map(l => `${tg ? '• ' : '- '}${l}`),
         ...p.alternativas.flatMap(a => [
-            `${a.chave}) ${a.texto}${a.recomendada ? (tg ? ` ✅ ${exports.SELO_DA_RECOMENDADA}` : ` [${exports.SELO_DA_RECOMENDADA}]`) : ''}: ${a.consequencia}`,
-            ...(a.recomendada ? [`   porquê: ${a.recomendada.porque}`] : []),
+            `${a.chave}) ${a.texto}${a.recomendada ? (tg ? ` ✅ ${m.selo}` : ` [${m.selo}]`) : ''}: ${a.consequencia}`,
+            ...(a.recomendada ? [`   ${m.porque}: ${a.recomendada.porque}`] : []),
         ]),
     ];
     const resposta = linhaDeResposta(p, canal);
     if (resposta)
         linhas.push(resposta);
     if (linhas.length > exports.TETO_DE_LINHAS_DO_PEDIDO)
-        throw new Error('pedido curto: acima do teto de linhas');
+        throw new Error(m.acimaDoTeto);
     return linhas.join('\n');
 }
 /**

package/dist/hitl-gates.js

@@ -78,6 +78,7 @@ const memoria_humana_1 = require("./memoria-humana");
 const hitl_canais_1 = require("./hitl-canais");
 const hitl_native_1 = require("./hitl-native");
 const modos_1 = require("./modos");
+const locale_1 = require("./locale");
 /**
  * D12: o canal entra no corpo assinado, e é isso que o torna recibo em vez de rótulo.
  * Hermes e OpenClaw compartilham transporte, mas usam chaves próprias e identidades
@@ -170,8 +171,9 @@ function autenticarResposta(thread, pedido, r, quando = new Date().toISOString()
  */
 function resolverCriterio(raiz, pedido) {
     const { tipo, referencia } = pedido.criterio;
+    const m = (0, locale_1.msg)().decisao;
     if (tipo === 'medicao') {
-        return { resolve: true, detalhe: 'comando citado; quem executa e reprova é o CHECK' };
+        return { resolve: true, detalhe: m.criterioMedicao };
     }
     if (tipo === 'manifesto') {
         let alvo;
@@ -179,19 +181,19 @@ function resolverCriterio(raiz, pedido) {
             alvo = (0, manifest_1.exigirManifesto)(raiz).manifesto;
         }
         catch {
-            return { resolve: false, detalhe: 'manifesto do projeto não pôde ser lido' };
+            return { resolve: false, detalhe: m.criterioManifestoIlegivel };
         }
         for (const parte of referencia.split('.')) {
             if (!alvo || typeof alvo !== 'object' || !(parte in alvo)) {
-                return { resolve: false, detalhe: `o manifesto não tem a chave ${referencia}` };
+                return { resolve: false, detalhe: m.criterioManifestoSemChave(referencia) };
             }
             alvo = alvo[parte];
         }
         const vazio = alvo === undefined || alvo === null || alvo === '' ||
             (Array.isArray(alvo) && alvo.length === 0);
         return vazio
-            ? { resolve: false, detalhe: `a chave ${referencia} existe mas está vazia` }
-            : { resolve: true, detalhe: `chave ${referencia} lida do manifesto` };
+            ? { resolve: false, detalhe: m.criterioManifestoVazio(referencia) }
+            : { resolve: true, detalhe: m.criterioManifestoLido(referencia) };
     }
     // `ledger`: `<thread>#evento:<n>` (1-based) ou o `eventId` do proprio evento.
     const comIndice = /^([a-zA-Z0-9][a-zA-Z0-9._-]{0,79})#evento:(\d+)$/.exec(referencia);
@@ -201,17 +203,17 @@ function resolverCriterio(raiz, pedido) {
         eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, thread));
     }
     catch {
-        return { resolve: false, detalhe: `a thread ${thread} não tem ledger legível` };
+        return { resolve: false, detalhe: m.criterioLedgerIlegivel(thread) };
     }
     if (comIndice) {
         const n = Number(comIndice[2]);
         return n >= 1 && n <= eventos.length
-            ? { resolve: true, detalhe: `evento ${n} de ${thread}` }
-            : { resolve: false, detalhe: `${thread} não tem evento ${n}` };
+            ? { resolve: true, detalhe: m.criterioEvento(n, thread) }
+            : { resolve: false, detalhe: m.criterioEventoAusente(n, thread) };
     }
     return eventos.some(e => e.eventId === referencia)
-        ? { resolve: true, detalhe: `evento ${referencia} de ${thread}` }
-        : { resolve: false, detalhe: `nenhum evento de ${thread} tem esse identificador` };
+        ? { resolve: true, detalhe: m.criterioEvento(referencia, thread) }
+        : { resolve: false, detalhe: m.criterioEventoAusente(referencia, thread) };
 }
 function registrarPedidoHitl(raiz, pedido) {
     (0, hitl_contract_1.validarPedidoHitl)(pedido);
@@ -224,7 +226,7 @@ function registrarPedidoHitl(raiz, pedido) {
     if ((0, hitl_contract_1.ehV2)(pedido) && pedido.classe === 'decidido') {
         const { resolve, detalhe } = resolverCriterio(raiz, pedido);
         if (!resolve)
-            throw new Error(`decisão informada: critério não resolve (${detalhe})`);
+            throw new locale_1.ErroDoCatalogo((m) => m.decisao.criterioNaoResolve(detalhe));
     }
     return comLockHitl(raiz, pedido.thread, () => {
         const t = (0, thread_1.lerThread)(raiz, pedido.thread), dir = (0, thread_1.dirThread)(raiz, t.id);

package/dist/hitl-local-receipt.js

@@ -33,8 +33,11 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.IDENTIDADE_DA_NOTA_NATIVA = exports.CONTRATO_RECIBO_DA_NOTA = void 0;
 exports.chaveLocal = chaveLocal;
 exports.gravarEvidenciaLocal = gravarEvidenciaLocal;
+exports.gravarEvidenciaLocalNota = gravarEvidenciaLocalNota;
+exports.conferirReciboLocalNota = conferirReciboLocalNota;
 exports.gravarEvidenciaLocalSessao = gravarEvidenciaLocalSessao;
 exports.validarEvidenciaLocalSessao = validarEvidenciaLocalSessao;
 exports.validarEvidenciaLocal = validarEvidenciaLocal;
@@ -47,6 +50,16 @@ const thread_1 = require("./thread");
 const ledger_1 = require("./ledger");
 const hitl_contract_1 = require("./hitl-contract");
 const hitl_local_atestado_1 = require("./hitl-local-atestado");
+/**
+ * RM-059 (T8.1, D3 e D12 da thread ork-rm059ritual): o recibo da nota do MASTER pelo dialogo nativo. Mesmo cofre e mesma
+ * chave do gate; guarda o hash do porque, nunca o texto (o texto vai ao MASTER log da thread).
+ */
+exports.CONTRATO_RECIBO_DA_NOTA = 'ork.hitl-local-master-note/v1';
+/**
+ * RM-059 (D12 da thread ork-rm059ritual): o `avaliadoPor` da nota pelo dialogo nativo. O host da conexao fica no
+ * `canal` e no recibo; a identidade e uma so, aceita pelo `autoriaHumana` de qualquer versao do `ork`.
+ */
+exports.IDENTIDADE_DA_NOTA_NATIVA = 'dono (dialogo nativo)';
 const sha = (v) => (0, node_crypto_1.createHash)('sha256').update(v).digest('hex');
 const uid = () => {
     const atual = process.getuid?.();
@@ -222,6 +235,44 @@ function gravarEvidenciaLocal(atestado, veredito) {
         recebidoEm: atestado.recebidoEm, ...veredito };
     return gravarRecibo(atestado.raiz, atestado.thread, nomeDoRecibo(atestado), dados);
 }
+/** RM-059 (T8.1): grava o recibo assinado da nota; o nome sai da conexao e da solicitacao, como no gate. */
+function gravarEvidenciaLocalNota(raiz, dados) {
+    const completos = { contrato: exports.CONTRATO_RECIBO_DA_NOTA, ...dados };
+    return gravarRecibo(raiz, dados.thread, sha(JSON.stringify([dados.connectionId, dados.requestId])) + '.json', completos);
+}
+/**
+ * RM-059 (T8.1, D12): confere o recibo da nota contra a prova do `preflightMaster` (escrita: sem ele a identidade da
+ * nota nativa nao se grava) ou contra um `master_done` ja gravado (auditoria: a prova do caminho, que nao decide se a
+ * nota vale). Recibo ausente, adulterado, de outra thread, de outra conexao, de outro host ou com outra nota nao confere.
+ */
+function conferirReciboLocalNota(raiz, thread, campos) {
+    try {
+        if (campos.por !== exports.IDENTIDADE_DA_NOTA_NATIVA || campos.origem !== 'mcp-local' ||
+            (campos.canal !== 'claude-code' && campos.canal !== 'codex'))
+            return false;
+        const host = campos.canal;
+        const pedidoId = campos.notaPedida?.pedidoId;
+        if (campos.contratoResposta !== exports.CONTRATO_RECIBO_DA_NOTA || typeof pedidoId !== 'string' ||
+            typeof campos.conexao !== 'string' || typeof campos.solicitacao !== 'string' || typeof campos.recebidoEm !== 'string' ||
+            !Number.isInteger(campos.score) || typeof campos.justificativa !== 'string' || typeof campos.evidencia !== 'string' ||
+            !/^[a-f0-9]{64}$/.test(String(campos.evidenciaSha256 ?? '')) || !/^[a-f0-9]{64}$/.test(String(campos.recibo ?? '')))
+            return false;
+        const nome = sha(JSON.stringify([campos.conexao, campos.solicitacao])) + '.json';
+        if (campos.evidencia !== referencia(thread, nome))
+            return false;
+        const lido = lerRecibo(raiz, thread, nome);
+        const esperado = { contrato: exports.CONTRATO_RECIBO_DA_NOTA, thread, pedidoId, host,
+            connectionId: campos.conexao, requestId: campos.solicitacao, recebidoEm: campos.recebidoEm,
+            score: campos.score, justificativaSha256: sha(campos.justificativa) };
+        const sig = assinatura(chaveLocal(raiz, false), esperado);
+        return JSON.stringify(lido.dados) === JSON.stringify(esperado) &&
+            (0, node_crypto_1.timingSafeEqual)(Buffer.from(lido.assinatura, 'hex'), Buffer.from(sig, 'hex')) &&
+            campos.evidenciaSha256 === sha(lido.bytes) && campos.recibo === sha(lido.assinatura);
+    }
+    catch {
+        return false;
+    }
+}
 function gravarEvidenciaLocalSessao(atestado, entrega) {
     const dados = { contrato: 'ork.hitl-local-session/v1', thread: atestado.thread,
         pedidoId: atestado.pedidoId, contexto: atestado.contexto, pedidoSha256: atestado.pedidoSha256,

package/dist/hitl-local.js

@@ -23,7 +23,9 @@ const idValido = (s) => typeof s === 'string' && /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,7
 /** O callback é fornecido pelo servidor, nunca pelos argumentos de tools/call. */
 function criarIngressoLocal(raiz, origem, elicitar, 
 /** Vinculo do adapter para resposta de SESSAO, fornecido pelo servidor. E o mesmo ponto
- *  de injecao que `responderSessao` ja tem; ausente, vale o controle nativo do runtime. */
+ *  de injecao que `responderSessao` ja tem; ausente, vale o controle nativo do runtime.
+ *  RM-059 (F9): a `caixa` de saida do servidor do dono, por onde a resposta a uma sessao
+ *  `claude-bg` sai para o Mensageiro de Sessoes; sem ela, essa resposta e recusada antes do dialogo. */
 opcoes = {}) {
     if (!['claude-code', 'codex'].includes(origem.host) || !idValido(origem.connectionId))
         throw new Error('hitl.local.origem-invalida');
@@ -64,6 +66,13 @@ opcoes = {}) {
                 throw new Error('hitl.local.pedido-antigo');
             if ((0, hitl_contract_1.estadoDoPedido)(pedido) !== 'aberto')
                 throw new Error('hitl.local.pedido-expirado');
+            // RM-059 (F9, D4): a resposta que nao vai sair (sessao claude-bg sem Mensageiro vivo) recusa antes do dialogo,
+            // para o dono nao digitar uma resposta que ficaria sem quem a leve. Com o envio ja reservado, vale a recusa de
+            // sempre (`hitl.channel.delivery-uncertain`), logo abaixo.
+            const emEnvio = eventos.some(e => e.tipo === 'session_answer_sending' && e.pedidoId === pedidoId);
+            const impedimento = alvo === 'session' && !emEnvio ? (0, hitl_sessions_1.impedimentoDaEntrega)(raiz, threadId, pedido, opcoes.controle, opcoes.caixa) : null;
+            if (impedimento)
+                throw new Error(impedimento);
             const pedidoSha256 = (0, hitl_local_atestado_1.hashPedidoLocal)(pedido), requestId = (0, node_crypto_1.randomUUID)(), controller = new AbortController();
             let liberarReserva;
             (0, hitl_gates_1.comLockHitl)(raiz, threadId, () => {
@@ -117,7 +126,7 @@ opcoes = {}) {
                 try {
                     return alvo === 'gate'
                         ? (0, hitl_gates_1.responderGateLocal)(raiz, threadId, pedidoId, token)
-                        : (0, hitl_sessions_1.responderSessaoLocal)(raiz, threadId, pedidoId, token, opcoes.controle);
+                        : (0, hitl_sessions_1.responderSessaoLocal)(raiz, threadId, pedidoId, token, opcoes.controle, opcoes.caixa);
                 }
                 finally {
                     (0, hitl_local_atestado_1.descartarAtestadoLocal)(token);

package/dist/hitl-lock.js

@@ -85,16 +85,10 @@ function comLockInspecionavel(dir, operacao, executar) {
         throw new Error('runtime.unavailable: lock HITL exige flock Linux');
     // Mesmo inode/nome do protocolo legado: writer wx antigo também recusa enquanto existir.
     const file = path.join(dir, '.hitl.lock');
-    let fd, criado = false;
-    try {
-        fd = fs.openSync(file, fs.constants.O_RDWR | fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_NOFOLLOW, 0o600);
-        criado = true;
-    }
-    catch (e) {
-        if (e.code !== 'EEXIST')
-            throw e;
-        fd = fs.openSync(file, fs.constants.O_RDWR | fs.constants.O_NOFOLLOW);
-    }
+    // `O_EXCL` abria uma janela no primeiro uso: o criador já tinha publicado o inode, mas ainda não o havia travado
+    // nem inicializado; um concorrente podia abrir o arquivo vazio e classificá-lo como legado. Todos abrem o mesmo
+    // inode e só interpretam os bytes depois do `flock`, que serializa criação, recuperação e uso normal.
+    const fd = fs.openSync(file, fs.constants.O_RDWR | fs.constants.O_CREAT | fs.constants.O_NOFOLLOW, 0o600);
     try {
         const st = fs.fstatSync(fd);
         if (!st.isFile() || st.uid !== process.getuid?.() || st.mode & 0o077 || st.nlink !== 1)
@@ -108,7 +102,7 @@ function comLockInspecionavel(dir, operacao, executar) {
             throw new Error('HITL lock mudou durante aquisição');
         let anterior = null;
         const raw = fs.readFileSync(fd, 'utf8');
-        if (!criado) {
+        if (raw !== '') {
             let v;
             try {
                 v = JSON.parse(raw);

package/dist/hitl-public-receipt.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ENV_HITL_VERIFIERS = void 0;
 exports.publicHitlVerifiers = publicHitlVerifiers;
+exports.canVerifyPublicReceipt = canVerifyPublicReceipt;
 exports.publicReceiptAuthority = publicReceiptAuthority;
 exports.publicBindingMatches = publicBindingMatches;
 exports.signPublicReceipt = signPublicReceipt;
@@ -108,6 +109,16 @@ function publicHitlVerifiers(env = process.env) {
     }
     return Object.keys(verifiers).length ? JSON.stringify({ schema: 'ork.hitl-verifiers/v1', verifiers }) : undefined;
 }
+/** O processo consegue reconferir este slot com a chave local ou com o material público herdado, sem expor nenhum dos dois. */
+function canVerifyPublicReceipt(canal, native, env = process.env) {
+    try {
+        const bundle = publicHitlVerifiers(env);
+        return !!bundleSchema.parse(JSON.parse(bundle ?? '{}')).verifiers[slotFor(canal, native)];
+    }
+    catch {
+        return false;
+    }
+}
 function publicReceiptAuthority(canal, native) {
     return inherited(process.env)[slotFor(canal, native)];
 }