@orkastery/cli 0.5.3 → 0.6.0

package/dist/hitl-resumo.js

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SEM_PERGUNTA_NO_RESUMO = exports.TETO_DE_DECISOES_DETALHADAS = exports.TETO_DE_ESPERAS_POR_MAQUINA = exports.TETO_DE_PARADOS_NO_CONDUTOR = exports.TETO_DE_THREADS_NOMEADAS = exports.PERGUNTA_DO_RESUMO = exports.CONTRATO_RESUMO = void 0;
+exports.SEM_PERGUNTA_COM_IMPEDIMENTO = exports.SEM_PERGUNTA_NO_RESUMO = exports.TETO_DE_DECISOES_DETALHADAS = exports.TETO_DE_ESPERAS_POR_MAQUINA = exports.TETO_DE_IMPEDIMENTOS = exports.TETO_DE_PARADOS_NO_CONDUTOR = exports.TETO_DA_VARREDURA = exports.TETO_DE_THREADS_NOMEADAS = exports.PERGUNTA_DO_RESUMO = exports.CONTRATO_RESUMO = void 0;
 exports.resumirHitl = resumirHitl;
+exports.linhasDaOciosidade = linhasDaOciosidade;
+exports.linhasDaVarredura = linhasDaVarredura;
 exports.linhaDoParadoNoCondutor = linhaDoParadoNoCondutor;
 exports.linhasDoCondutor = linhasDoCondutor;
+exports.linhasDosImpedimentos = linhasDosImpedimentos;
 exports.linhaDosTecnicos = linhaDosTecnicos;
 exports.linhasDasOutrasMaquinas = linhasDasOutrasMaquinas;
 exports.linhasDasDecisoes = linhasDasDecisoes;
@@ -29,6 +32,7 @@ exports.textoDoResumo = textoDoResumo;
  * mensagem do canal. Quem entrega chama a segunda.
  */
 const horario_1 = require("./horario");
+const locale_1 = require("./locale");
 const hitl_tempo_parado_1 = require("./hitl-tempo-parado");
 const decisao_autonoma_1 = require("./decisao-autonoma");
 const hitl_classificacao_1 = require("./hitl-classificacao");
@@ -60,9 +64,48 @@ function resumirHitl(itens, opcoes) {
         threadsTecnicas: [...new Set(tecnicos.map(i => i.thread).filter((t) => !!t))].sort(),
         ...(opcoes.paradosNoCondutor?.length ? { paradosNoCondutor: opcoes.paradosNoCondutor.map(p => ({ thread: p.thread, caso: p.caso,
                 desdeEm: p.desdeEm, proximoPasso: p.proximoPasso })) } : {}),
+        ...(opcoes.impedimentosDoDono?.length ? { impedimentosDoDono: opcoes.impedimentosDoDono.map(i => ({ thread: i.thread,
+                fase: i.fase, comando: i.comando, retry: i.retry })) } : {}),
+        ...(opcoes.acoesDaVarredura?.length ? { acoesDaVarredura: opcoes.acoesDaVarredura.map(a => ({ ...a })) } : {}),
+        ...(opcoes.feitasPelaVarredura?.length ? { feitasPelaVarredura: opcoes.feitasPelaVarredura.map(a => ({ ...a })) } : {}),
+        ...(opcoes.maquinaOciosa ? { maquinaOciosa: { ...opcoes.maquinaOciosa, sugeridas: opcoes.maquinaOciosa.sugeridas.map(x => ({ ...x })) } } : {}),
         ...(opcoes.hitlDeConducao?.acimaDaMeta ? { hitlDeConducao: opcoes.hitlDeConducao } : {}),
     };
 }
+/**
+ * RM-063 (F6): a maquina ociosa no resumo, igual nos dois canais: as vagas livres, o trabalho reservado parado e as
+ * proximas threads sugeridas, cada uma com o comando.
+ */
+function linhasDaOciosidade(r, marcador, recuo) {
+    const o = r.maquinaOciosa;
+    if (!o)
+        return [];
+    return [`${marcador}Máquina ociosa: ${semQuebra(o.maquina)}, com ${o.livres} de ${o.limite} vagas livres e ${o.reservados} ` +
+            `${o.reservados === 1 ? 'item reservado parado' : 'itens reservados parados'}. Próximas sugeridas:`,
+        ...o.sugeridas.map(x => `${recuo}• ${semQuebra(x.item)}${x.thread ? ` (${semQuebra(x.thread)})` : ''}: ${uma(x.passo, 120)} ` +
+            `(\`${semQuebra(x.comando)}\`)`)];
+}
+/** Quantas acoes da varredura o resumo detalha antes de contar o resto. */
+exports.TETO_DA_VARREDURA = 5;
+/**
+ * RM-063 (F5): as acoes da varredura no resumo, iguais nos dois canais: as que esperam o dono, com o comando (o
+ * incidente do PR #112, mesclado e dois dias sem registro sem nenhum canal avisar), e as que ela fez sozinha.
+ */
+function linhasDaVarredura(r, marcadores, recuo) {
+    const linhas = [];
+    const bloco = (lista, titulo) => {
+        if (!lista.length)
+            return;
+        const mostradas = lista.slice(0, exports.TETO_DA_VARREDURA), sobra = lista.length - mostradas.length;
+        if (linhas.length)
+            linhas.push('');
+        linhas.push(titulo, ...mostradas.map(a => `${recuo}• ${semQuebra(a.thread)}: ${uma(a.texto, 140)}` +
+            (a.comando ? ` (\`${semQuebra(a.comando)}\`)` : '')), ...(sobra > 0 ? [`${recuo}e mais ${sobra}: ork pulse`] : []));
+    };
+    bloco(r.acoesDaVarredura ?? [], `${marcadores.dono}Arrumação que a varredura faria com a sua autorização: ${(r.acoesDaVarredura ?? []).length}`);
+    bloco(r.feitasPelaVarredura ?? [], `${marcadores.feitas}A varredura fez sozinha, pela sua autorização: ${(r.feitasPelaVarredura ?? []).length}`);
+    return linhas;
+}
 /** Quantas linhas do condutor o resumo mostra antes de contar o resto. */
 exports.TETO_DE_PARADOS_NO_CONDUTOR = 5;
 /**
@@ -71,7 +114,7 @@ exports.TETO_DE_PARADOS_NO_CONDUTOR = 5;
  */
 function linhaDoParadoNoCondutor(p, opcoes) {
     const { desdeEm: desde } = p;
-    return `${p.thread} parado no condutor desde ${(0, horario_1.formatarHora)(desde, opcoes)}: ${p.proximoPasso}`;
+    return (0, locale_1.msg)().pulse.linhaDoCondutor(p.thread, (0, horario_1.formatarHora)(desde, opcoes), p.proximoPasso);
 }
 /** As linhas do condutor no resumo, uma por thread, com o resto contado. */
 function linhasDoCondutor(r, marcador, recuo) {
@@ -80,6 +123,24 @@ function linhasDoCondutor(r, marcador, recuo) {
     return [...mostradas.map(p => `${marcador}${linhaDoParadoNoCondutor(p, { agora: r.consultadoEm })}`),
         ...(sobra > 0 ? [`${recuo}e mais ${sobra}: ork pulse`] : [])];
 }
+/** Quantos impedimentos do dono o resumo detalha antes de contar o resto. */
+exports.TETO_DE_IMPEDIMENTOS = 5;
+/** Uma linha so, sem caractere de controle e sem corte: o comando precisa chegar inteiro para ser copiado. */
+const semQuebra = (texto) => String(texto).replace(/\p{Cc}/gu, ' ').replace(/\s+/g, ' ').trim();
+/**
+ * RM-055 (continuacao, D3): o titulo e uma linha por impedimento do dono, iguais nos dois canais (so o
+ * marcador e o recuo mudam). Cada linha diz a thread, a fase, o comando exato e o retry que vem depois.
+ */
+function linhasDosImpedimentos(r, marcador, recuo) {
+    const impedimentos = r.impedimentosDoDono ?? [];
+    if (!impedimentos.length)
+        return [];
+    const mostrados = impedimentos.slice(0, exports.TETO_DE_IMPEDIMENTOS), sobra = impedimentos.length - mostrados.length;
+    return [`${marcador}Só você destrava, no terminal: ${impedimentos.length}`,
+        ...mostrados.map(i => `${recuo}• ${semQuebra(i.thread)}${i.fase ? ` ${semQuebra(i.fase)}` : ''}: ` +
+            `rode \`${semQuebra(i.comando)}\`; depois \`${semQuebra(i.retry)}\``),
+        ...(sobra > 0 ? [`${recuo}e mais ${sobra}: ork pulse`] : [])];
+}
 /** RM-057 (fatia 3): a linha do tempo parado por HITL de conducao, a mesma nos dois canais. */
 function linhaDoHitlParado(r) {
     const linha = (0, hitl_tempo_parado_1.linhaDoHitlAcimaDaMeta)(r.hitlDeConducao, { agora: r.consultadoEm });
@@ -143,6 +204,8 @@ function linhasDasDecisoes(r, marcador, recuo) {
 }
 /** Quando nao ha pergunta, o resumo diz isso em vez de pedir licenca para mandar nada. */
 exports.SEM_PERGUNTA_NO_RESUMO = 'Nada aqui pede resposta sua por este canal agora.';
+/** RM-055 (continuacao, D3): sem pergunta, mas com impedimento do dono: o que fazer esta no bloco acima. */
+exports.SEM_PERGUNTA_COM_IMPEDIMENTO = 'Nada aqui pede resposta sua por este canal agora; o que só você destrava está acima, no terminal.';
 /** A linha das perguntas prontas, uma so para os dois canais, pelo mesmo motivo da de baixo. */
 function linhaDasPerguntas(n) {
     return `Perguntas para você: ${n}`;
@@ -192,7 +255,7 @@ function abertura(r, codigo, marca, resposta) {
     return r.pergunta ? [`${marca}${r.pergunta}`, ...linhaDeResposta(codigo).map(l => `${resposta}${l}`), ''] : [];
 }
 function fecho(r) {
-    return r.pergunta ? [] : ['', exports.SEM_PERGUNTA_NO_RESUMO];
+    return r.pergunta ? [] : ['', r.impedimentosDoDono?.length ? exports.SEM_PERGUNTA_COM_IMPEDIMENTO : exports.SEM_PERGUNTA_NO_RESUMO];
 }
 function textoTelegram(r, codigo) {
     const quando = (0, horario_1.formatarDataHoraRotulada)(r.consultadoEm, { agora: r.consultadoEm });
@@ -209,6 +272,9 @@ function textoTelegram(r, codigo) {
         ...(r.tecnicos ? [`🔧 ${linhaDosTecnicos(r)}`] : []),
         ...(r.consertos ? [`🔧 ${linhaDosConsertos(r.consertos)}`] : []),
         ...linhaDoHitlParado(r).map(l => `⏳ ${l}`),
+        ...(r.maquinaOciosa ? ['', ...linhasDaOciosidade(r, '💤 ', '   ')] : []),
+        ...(r.impedimentosDoDono?.length ? ['', ...linhasDosImpedimentos(r, '🔑 ', '   ')] : []),
+        ...(r.acoesDaVarredura?.length || r.feitasPelaVarredura?.length ? ['', ...linhasDaVarredura(r, { dono: '🧹 ', feitas: '🤖 ' }, '   ')] : []),
         ...(r.paradosNoCondutor?.length ? ['', ...linhasDoCondutor(r, '🚧 ', '   ')] : []),
         ...(r.acumuladas ? ['', `📥 ${linhaDoLoteGuardado(r.acumuladas)}`] : []),
         ...(r.decisoes.length || r.acimaDoLimiar.length ? ['', ...linhasDasDecisoes(r, '🧭 ', '   ')] : []),
@@ -241,6 +307,9 @@ function textoTerminal(r, codigo) {
         ...(r.tecnicos ? ['', `  ${linhaDosTecnicos(r)}`] : []),
         ...(r.consertos ? ['', `  ${linhaDosConsertos(r.consertos)}`] : []),
         ...linhaDoHitlParado(r).flatMap(l => ['', `  ${l}`]),
+        ...(r.maquinaOciosa ? ['', ...linhasDaOciosidade(r, '  ', '    ')] : []),
+        ...(r.impedimentosDoDono?.length ? ['', ...linhasDosImpedimentos(r, '  ', '  ')] : []),
+        ...(r.acoesDaVarredura?.length || r.feitasPelaVarredura?.length ? ['', ...linhasDaVarredura(r, { dono: '  ', feitas: '  ' }, '    ')] : []),
         ...(r.paradosNoCondutor?.length ? ['', ...linhasDoCondutor(r, '  ', '  ')] : []),
         ...(r.acumuladas ? ['', `  ${linhaDoLoteGuardado(r.acumuladas)}`] : []),
         ...(r.decisoes.length || r.acimaDoLimiar.length ? ['', ...linhasDasDecisoes(r, '', '  ').map(l => l.startsWith('  ') ? l : `  ${l}`)] : []),

package/dist/hitl-sessions.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.impedimentoDaEntrega = impedimentoDaEntrega;
 exports.abrirPedidoSessao = abrirPedidoSessao;
 exports.responderSessao = responderSessao;
 exports.responderSessaoLocal = responderSessaoLocal;
@@ -56,15 +57,37 @@ const hitl_ingress_receipt_1 = require("./hitl-ingress-receipt");
 const hitl_1 = require("./hitl");
 const hitl_canais_1 = require("./hitl-canais");
 const codex_question_1 = require("./adapters/codex-question");
+const entrega_por_mod_1 = require("./entrega-por-mod");
 const uuidCompleto = (s) => /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i.test(s);
 const reciboDaProva = (r) => (0, node_crypto_1.createHash)('sha256').update(r.prova).digest('hex');
 const mesmaInstancia = (a, b) => a.sessionId === b.sessionId && a.runtime === b.runtime && a.cwd === b.cwd && a.instancia === b.instancia;
-function controleDeResposta(raiz, id, sessionId, runtime, controle) {
-    const ctl = controle ?? controleNativo(runtime, raiz, id, sessionId);
+/**
+ * O controle que responde a sessao. RM-059 (F9, D2): para `claude-bg`, o controle por mod do Mensageiro de Sessoes,
+ * com a caixa de saida do servidor do dono quando a resposta entrou por ele; o `controleNativo` dos outros
+ * chamadores (conducao, superacao, maestro), que so consultam e param, segue igual.
+ */
+function controleDeResposta(raiz, id, sessionId, runtime, controle, caixa) {
+    const ctl = controle ?? (runtime === 'claude-bg' ? (0, entrega_por_mod_1.controleClaudeBgPorMod)(raiz, id, sessionId, caixa)
+        : controleNativo(runtime, raiz, id, sessionId));
     if (!ctl.enviar || !ctl.confirmar)
         throw new Error('runtime.unavailable: adapter não comprova entrada e recibo na mesma sessão; attach/resume não são fallback');
     return ctl;
 }
+/**
+ * RM-059 (F9, D4): o que impede de levar agora a resposta de um pedido de sessao `claude-bg` (sem caixa de saida no
+ * processo, ou sem Mensageiro vivo nela), conferido antes do dialogo e antes de gravar o ingresso. `null` para os
+ * outros alvos e runtimes, que seguem o caminho de antes.
+ */
+function impedimentoDaEntrega(raiz, id, pedido, controle, caixa) {
+    if (pedido.alvo.tipo !== 'session' || pedido.alvo.runtime !== 'claude-bg')
+        return null;
+    try {
+        return controleDeResposta(raiz, id, pedido.alvo.sessionId, pedido.alvo.runtime, controle, caixa).impedimentoDoEnvio?.() ?? null;
+    }
+    catch (e) {
+        return e.message;
+    }
+}
 function observarBloqueio(ctl, sessionId, runtime, cwd) {
     const consulta = ctl.consultar();
     if (!consulta.ok)
@@ -73,7 +96,8 @@ function observarBloqueio(ctl, sessionId, runtime, cwd) {
     const s = matches[0];
     if (matches.length !== 1 || !s || s.runtime !== runtime || s.cwd !== cwd || s.estado !== 'blocked' ||
         !s.instancia || !s.bloqueio)
-        throw new Error('runtime.unavailable: identidade, cwd e prompt bloqueado exatos não comprovados');
+        throw new Error('runtime.unavailable: identidade, cwd e prompt bloqueado exatos não comprovados' +
+            (matches.length === 1 && s?.limitacao ? ` (${s.limitacao.codigo})` : ''));
     return { sessionId: s.sessionId, runtime: s.runtime, cwd: s.cwd, estado: s.estado, instancia: s.instancia, bloqueio: s.bloqueio, perguntaNativa: s.perguntaNativa };
 }
 /** Cria somente um pedido vinculado ao despacho corrente e ao prompt nativo observado. */
@@ -94,7 +118,18 @@ function abrirPedidoSessao(raiz, id, sessionId, opcoes, controle) {
         if (!mesmaInstancia(sessao, revalidada) || sessao.bloqueio !== revalidada.bloqueio)
             throw new Error('prompt ou instância mudou durante o pedido');
         const nativa = sessao.perguntaNativa;
-        if (!nativa || JSON.stringify(nativa) !== JSON.stringify(revalidada.perguntaNativa) ||
+        if (!nativa) {
+            // RM-059 (F9): o codigo da limitacao (turno ausente, pergunta longa) diz ao operador por que nao abriu.
+            let codigo;
+            try {
+                codigo = ctl.consultar().sessoes.find(s => s.sessionId === sessionId)?.limitacao?.codigo;
+            }
+            catch {
+                codigo = undefined;
+            }
+            throw new Error('runtime.unavailable: conteúdo nativo da pergunta não comprovado' + (codigo ? ` (${codigo})` : ''));
+        }
+        if (JSON.stringify(nativa) !== JSON.stringify(revalidada.perguntaNativa) ||
             (0, codex_question_1.projetarPergunta)({ isBlocking: true, questions: [nativa] }).sha256 !== nativa.sha256)
             throw new Error('runtime.unavailable: conteúdo nativo da pergunta não comprovado');
         if (opcoes.pergunta !== undefined && opcoes.pergunta !== nativa.question)
@@ -156,7 +191,7 @@ function orientacaoDaResposta(tipo, quantasOpcoes) {
  * O núcleo da entrega, comum aos quatro canais: conferência do vínculo nativo, reserva
  * durável, envio único e confirmação correlacionada. Nenhum canal ganha atalho aqui.
  */
-function entregarNaSessao(raiz, id, pedido, prov, controle) {
+function entregarNaSessao(raiz, id, pedido, prov, controle, caixa) {
     if (pedido.alvo.tipo !== 'session')
         throw new Error('pedido destina-se ao gate, não à sessão');
     const pedidoId = pedido.id;
@@ -169,7 +204,7 @@ function entregarNaSessao(raiz, id, pedido, prov, controle) {
         !sessao.instancia || !sessao.bloqueio || sessao.cwd !== path.resolve((0, thread_1.lerThread)(raiz, id).worktree ?? raiz)) {
         throw new Error('runtime.unavailable: pedido sem vínculo nativo exato');
     }
-    const ctl = controleDeResposta(raiz, id, sessionId, runtime, controle);
+    const ctl = controleDeResposta(raiz, id, sessionId, runtime, controle, caixa);
     const pendente = eventos.find(e => e.tipo === 'session_answer_sending' && e.pedidoId === pedidoId);
     if (pendente && (pendente.recibo !== prov.recibo || pendente.mensagem !== prov.mensagem || pendente.autorizadoPor !== prov.autorizadoPor)) {
         throw new Error('envio já iniciado; resposta divergente recusada');
@@ -180,12 +215,18 @@ function entregarNaSessao(raiz, id, pedido, prov, controle) {
     const entrega = { contrato: 'ork.session-answer/v1',
         envioId: pendente ? String(pendente.envioId) : (0, node_crypto_1.randomUUID)(), pedidoId, thread: id, fase: pedido.fase, sessao, recibo: prov.recibo };
     if (!pendente) {
+        // RM-059 (F9, D4): sem quem leve a mensagem (sem caixa de saida, sem Mensageiro vivo), nada se reserva.
+        const impedimento = ctl.impedimentoDoEnvio?.() ?? null;
+        if (impedimento)
+            throw new Error(impedimento);
         for (let i = 0; i < 2; i++) {
             const atual = observarBloqueio(ctl, sessionId, runtime, sessao.cwd);
             if (!mesmaInstancia(atual, sessao) || atual.bloqueio !== sessao.bloqueio || JSON.stringify(atual.perguntaNativa) !== JSON.stringify(sessao.perguntaNativa))
                 throw new Error('prompt ou instância mudou antes do envio');
         }
-        (0, ledger_1.registrar)(dir, id, 'session_answer_sending', { ...prov.dados, sessionId, runtime,
+        // RM-059 (F9, D3): no envio por mod, a reconciliacao fecha pelo recibo do receptor, que confere o `recibo` deste
+        // evento; o ingresso local nao o levava aqui (so o `reciboEntrega`), e o Telegram ja leva o mesmo valor.
+        (0, ledger_1.registrar)(dir, id, 'session_answer_sending', { ...(ctl.assincrono ? { recibo: prov.recibo } : {}), ...prov.dados, sessionId, runtime,
             instancia: sessao.instancia, bloqueio: sessao.bloqueio, envioId: entrega.envioId });
         // O número só vira rótulo nativo quando o pedido aceita OPÇÃO. Em texto livre a
         // resposta humana chega literal ao receptor, inclusive quando é "1" ou "12".
@@ -206,6 +247,9 @@ function entregarNaSessao(raiz, id, pedido, prov, controle) {
     catch {
         throw new Error('runtime.unavailable: consulta do recibo falhou; envio não será repetido');
     }
+    // RM-059 (F9, D3): o envio por mod ainda sem recibo do receptor nao e falha; a reconciliacao fecha depois.
+    if (!ack && ctl.assincrono)
+        return { ...resultado, estado: 'aguardando-receptor', repetida: !!pendente };
     if (!ack || ack.estado !== 'recebida' || ack.contrato !== entrega.contrato || ack.envioId !== entrega.envioId ||
         ack.pedidoId !== pedidoId || ack.thread !== id || ack.fase !== pedido.fase || ack.recibo !== entrega.recibo ||
         !ack.sessao || !mesmaInstancia(ack.sessao, sessao) || ack.sessao.bloqueio !== sessao.bloqueio) {
@@ -221,6 +265,15 @@ function entregarNaSessao(raiz, id, pedido, prov, controle) {
 }
 /** Uma intenção durável impede reenvio após crash, timeout ou confirmação divergente. */
 function responderSessao(raiz, id, pedidoId, r, controle, quando) {
+    // RM-059 (F9, D4): a sessao `claude-bg` so recebe pelo Mensageiro, e este caminho (o `ork sessions answer` do
+    // Telegram) nao tem caixa de saida: recusa antes de gravar o ingresso, e o pedido segue aberto. Resposta ja
+    // entregue ou envio ja reservado seguem o caminho de antes (a repeticao e idempotente e nada reserva de novo).
+    const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, id));
+    const solicitado = eventos.find(e => e.tipo === 'hitl_requested' && e.pedido?.id === pedidoId);
+    const andamento = eventos.some(e => ['session_answered', 'session_answer_sending'].includes(e.tipo) && e.pedidoId === pedidoId);
+    const impedimento = solicitado?.pedido && !andamento ? impedimentoDaEntrega(raiz, id, solicitado.pedido, controle) : null;
+    if (impedimento)
+        throw new Error(impedimento);
     (0, hitl_gates_1.receberResposta)(raiz, id, pedidoId, r, quando);
     return (0, hitl_gates_1.comLockHitl)(raiz, id, () => {
         const { pedido, anterior } = (0, hitl_gates_1.conferirResposta)(raiz, id, pedidoId, r, quando);
@@ -248,7 +301,7 @@ function responderSessao(raiz, id, pedidoId, r, controle, quando) {
  * Aceita texto livre quando a pergunta nativa aceita, porque uma pergunta aberta respondida
  * por menu vira outra pergunta.
  */
-function responderSessaoLocal(raiz, id, pedidoId, token, controle) {
+function responderSessaoLocal(raiz, id, pedidoId, token, controle, caixa) {
     const atestado = (0, hitl_local_atestado_1.consumirAtestadoLocal)(token, raiz, id, pedidoId);
     return (0, hitl_gates_1.comLockHitl)(raiz, id, () => {
         const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, id));
@@ -284,7 +337,7 @@ function responderSessaoLocal(raiz, id, pedidoId, token, controle) {
             evidenciar: (entrega) => (0, hitl_local_receipt_1.gravarEvidenciaLocalSessao)(atestado, { fase: String(pedido.fase),
                 sessionId: entrega.sessao.sessionId, runtime: entrega.sessao.runtime,
                 instancia: entrega.sessao.instancia, bloqueio: String(entrega.sessao.bloqueio), envioId: entrega.envioId }),
-        }, controle);
+        }, controle, caixa);
     });
 }
 /**

package/dist/hitl-tempo-parado.js

@@ -42,6 +42,7 @@ const hitl_contract_1 = require("./hitl-contract");
 const horario_1 = require("./horario");
 const ledger_1 = require("./ledger");
 const thread_1 = require("./thread");
+const locale_1 = require("./locale");
 /** A meta da RM-057: mediana de resposta abaixo de 5 minutos. */
 exports.META_DA_MEDIANA_DE_RESPOSTA_MS = 5 * 60_000;
 const RESPOSTAS = ['human_gate', 'session_answered'];
@@ -178,13 +179,12 @@ const emMinutos = (ms) => `${(ms / 60_000).toFixed(1)} min`;
 function textoDaMediana(h) {
     const s = h.seteDias;
     if (s.medianaRespostaMs === null)
-        return 'mediana de 7 dias sem resposta medida';
-    return `mediana de 7 dias ${emMinutos(s.medianaRespostaMs)} (${s.dentroDaMeta ? 'dentro' : 'acima'} da meta de 5 min, ` +
-        `${s.respondidos} resposta(s))`;
+        return (0, locale_1.msg)().pulse.medianaSemResposta;
+    return (0, locale_1.msg)().pulse.mediana(emMinutos(s.medianaRespostaMs), s.dentroDaMeta, s.respondidos);
 }
 /** "<thread> (<fase>) parada ha 12min, desde 01:02": a hora no fuso do dono (RM-035). */
 function linhaDaPerguntaParada(p, opcoes) {
-    return `${p.thread} (${p.fase}) parada há ${(0, horario_1.duracaoRelativa)(p.paradaHaMin)}, desde ${(0, horario_1.formatarHora)(p.desdeEm, opcoes)}`;
+    return (0, locale_1.msg)().pulse.perguntaParada(p.thread, p.fase, (0, horario_1.duracaoRelativa)(p.paradaHaMin), (0, horario_1.formatarHora)(p.desdeEm, opcoes));
 }
 /**
  * A linha unica do resumo do pulse, so quando passou da meta: quantas abertas, a mais antiga e a

package/dist/hitl-texto-livre.js

@@ -34,11 +34,13 @@ exports.consentimentoDoTrecho = consentimentoDoTrecho;
  * com teste, e nunca efeito colateral de alguem achar que "entendeu" o dono.
  */
 exports.VOCABULARIO_LIVRE = Object.freeze({
+    // RM-057 (resposta curta, D8 da ork-rm057respost): "autorizo" e as variações, que o dono usa para o arco #Noctum.
     afirmar: ['sim', 's', 'ok', 'pode', 'pode seguir', 'pode ir', 'segue', 'siga', 'seguir', 'manda', 'aprovo', 'aprovado',
-        'aprovada', 'aprovar', 'aprova', 'confirmo', 'confirmado', 'de acordo'],
+        'aprovada', 'aprovar', 'aprova', 'confirmo', 'confirmado', 'de acordo', 'autorizo', 'autorizado', 'autorizada', 'autorizar',
+        'autoriza'],
     negar: ['nao', 'n'],
     revisar: ['recuso', 'recusado', 'recusar', 'reprovo', 'reprovado', 'revisar', 'revisao', 'refazer', 'volta', 'voltar'],
-    esperar: ['esperar', 'espera', 'aguardar', 'aguarda', 'aguarde', 'depois', 'mais tarde', 'agora nao'],
+    esperar: ['esperar', 'espera', 'aguardar', 'aguarda', 'aguarde', 'depois', 'mais tarde', 'agora nao', 'adiar', 'adia', 'adio'],
     detalhe: ['detalhe', 'detalhes', 'evidencia', 'evidencias'],
 });
 /** Que acoes de alternativa cada intencao casa. `negar` casa duas de proposito: e ambigua num gate. */
@@ -59,8 +61,9 @@ exports.JANELA_DO_TEXTO_LIVRE_MIN = 60;
  * formas `lista` e `livre` de `GRAMATICA_DO_PULSE`, que os adaptadores copiam texto a texto.
  */
 const PALAVRAS_DA_FORMA = 'pode seguir|pode ir|pode|sim|s|ok|aprovo|aprovado|aprovada|aprovar|aprova|segue|siga|seguir|manda|' +
-    'confirmo|confirmado|de acordo|agora n[aã]o|n[aã]o|n|recuso|recusado|recusar|reprovo|reprovado|revisar|revis[aã]o|refazer|' +
-    'volta|voltar|esperar|espera|aguardar|aguarda|aguarde|depois|mais tarde|detalhes?|evid[eê]ncias?';
+    'confirmo|confirmado|de acordo|autorizo|autorizado|autorizada|autorizar|autoriza|agora n[aã]o|n[aã]o|n|recuso|recusado|recusar|' +
+    'reprovo|reprovado|revisar|revis[aã]o|refazer|volta|voltar|esperar|espera|aguardar|aguarda|aguarde|depois|mais tarde|adiar|adia|' +
+    'adio|detalhes?|evid[eê]ncias?';
 /** Uma resposta: letra, ou palavra do vocabulario. */
 const RESPOSTA_DA_FORMA = `(?:[a-e]|${PALAVRAS_DA_FORMA})`;
 /**

package/dist/hitl.js

@@ -88,6 +88,8 @@ const horario_1 = require("./horario");
 Object.defineProperty(exports, "duracaoCurta", { enumerable: true, get: function () { return horario_1.duracaoCurta; } });
 const hitl_estado_1 = require("./hitl-estado");
 const redacao_url_1 = require("./redacao-url");
+const locale_1 = require("./locale");
+const locale_pulse_1 = require("./locale-pulse");
 /** Limite de atencao padrao, em minutos, igual ao do monitor de orquestracao. */
 exports.ATENCAO_PADRAO_MIN = 30;
 function redigirSegredos(texto) {
@@ -110,28 +112,34 @@ function contextoSeguro(texto, linhas = 20) {
  * `stopped` NAO pede humano: a sessao foi parada por decisao de alguem. `failed` pede,
  * porque alguem precisa decidir entre retomar, corrigir ou abandonar.
  */
+// RM-061 (F2b): o detalhe de cada estado tem a fonte no catalogo pt-BR (`locale-pulse.ts`), com o ingles ao lado.
 const REGRA_POR_ESTADO = {
     blocked: {
         classe: 'hitl',
         precisaDeHumano: true,
-        detalhe: 'sessao parada esperando acao humana (prompt, permissao ou credencial)',
+        detalhe: locale_pulse_1.PULSE_PT_BR.sessao.blocked,
     },
     failed: {
         classe: 'falha',
         precisaDeHumano: true,
-        detalhe: 'sessao terminou em erro: alguem decide entre retomar, corrigir ou abandonar',
+        detalhe: locale_pulse_1.PULSE_PT_BR.sessao.failed,
     },
-    working: { classe: 'trabalhando', precisaDeHumano: false, detalhe: 'sessao em execucao' },
-    done: { classe: 'concluida', precisaDeHumano: false, detalhe: 'sessao concluiu' },
+    working: { classe: 'trabalhando', precisaDeHumano: false, detalhe: locale_pulse_1.PULSE_PT_BR.sessao.working },
+    // RM-063 (fatia 3, achado a): a sessao interativa do Claude Code aparece `busy` enquanto executa um turno, e o
+    // runtime tambem diz `running`. Fora do catalogo elas viravam "possivel parada" no pulse e em "O que precisa de
+    // voce": e trabalho, como o observador (`session-watcher-claude.ts`) e a capacidade do #Noctum ja as liam.
+    busy: { classe: 'trabalhando', precisaDeHumano: false, detalhe: locale_pulse_1.PULSE_PT_BR.sessao.busy },
+    running: { classe: 'trabalhando', precisaDeHumano: false, detalhe: locale_pulse_1.PULSE_PT_BR.sessao.running },
+    done: { classe: 'concluida', precisaDeHumano: false, detalhe: locale_pulse_1.PULSE_PT_BR.sessao.done },
     stopped: {
         classe: 'interrompida',
         precisaDeHumano: false,
-        detalhe: 'sessao parada por decisao humana (`claude stop`)',
+        detalhe: locale_pulse_1.PULSE_PT_BR.sessao.stopped,
     },
     idle: {
         classe: 'interativa',
         precisaDeHumano: false,
-        detalhe: 'sessao interativa ociosa, conduzida por um humano no terminal',
+        detalhe: locale_pulse_1.PULSE_PT_BR.sessao.idle,
     },
 };
 /** Estado cru da sessao: `state` manda, `status` e o fallback historico. */
@@ -142,14 +150,13 @@ function estadoBruto(s) {
 /** Classifica o estado cru do runtime. Estado que nao esta no mapa avisa a mais. */
 function classificarEstado(estado) {
     const regra = REGRA_POR_ESTADO[estado];
+    // RM-061 (F2b, G2): o detalhe vem do catalogo (o mesmo pt-BR da tabela) e o pulse o remonta no locale.
     if (regra)
-        return regra;
+        return { ...regra, detalhe: (0, locale_1.textoDoCatalogo)((m) => m.pulse.sessao[estado] ?? regra.detalhe) };
     return {
         classe: 'desconhecida',
         precisaDeHumano: true,
-        detalhe: estado === ''
-            ? 'runtime nao informou estado desta sessao: tratada como possivel parada'
-            : `estado "${estado}" nao esta no catalogo do ork: tratado como possivel parada`,
+        detalhe: (0, locale_1.textoDoCatalogo)((m) => estado === '' ? m.pulse.sessaoSemEstado : m.pulse.sessaoEstadoForaDoCatalogo(estado)),
     };
 }
 /** Resposta do `claude logs` quando o job da sessao ja saiu do runtime. */
@@ -279,28 +286,22 @@ function lerPerguntaDaTela(textoLimpo) {
  * inventa opcao que a sessao nao deu.
  */
 function recomendarPara(classe, tipo, id) {
-    if (classe === 'abandonada') {
-        return ('nao responda: o job ja saiu. Confira o que ficou na worktree da sessao e ' +
-            'redespache so o resto do trabalho.');
-    }
-    if (classe === 'falha') {
-        return `leia \`ork sessions logs ${id}\` e decida entre retomar, corrigir a causa ou abandonar a sessao.`;
-    }
-    if (classe === 'desconhecida') {
-        return `estado fora do catalogo: confirme no \`ork sessions logs ${id}\` se a sessao esta mesmo parada.`;
-    }
-    switch (tipo) {
-        case 'hitl.credencial':
-            return (`entregue o segredo agora (\`claude attach ${id}\`) para nao segurar a entrega; ` +
-                'se este mesmo bloqueio ja se repetiu, troque por credencial de automacao e ele nao volta.');
-        case 'hitl.permissao':
-            return (`responda o prompt (\`claude attach ${id}\`); se o comando e rotineiro nesse projeto, ` +
-                'coloque-o na allowlist de permissoes para nao parar de novo pelo mesmo motivo.');
-        case 'hitl.pergunta':
-            return `abra a sessao (\`claude attach ${id}\`) e escolha entre as opcoes que ela listou.`;
-        default:
-            return `veja o que a sessao pede com \`ork sessions logs ${id}\` antes de responder.`;
-    }
+    // RM-061 (F2b, G2): nasce em pt-BR pelo catalogo (o --json guarda) e o pulse a remonta no locale.
+    return (0, locale_1.textoDoCatalogo)((m) => {
+        const r = m.pulse.recomendacaoDoRadar;
+        if (classe === 'abandonada')
+            return r.abandonada;
+        if (classe === 'falha')
+            return r.falha(id);
+        if (classe === 'desconhecida')
+            return r.desconhecida(id);
+        switch (tipo) {
+            case 'hitl.credencial': return r.credencial(id);
+            case 'hitl.permissao': return r.permissao(id);
+            case 'hitl.pergunta': return r.pergunta(id);
+            default: return r.outra(id);
+        }
+    });
 }
 /** Minutos inteiros entre um epoch em ms e um carimbo ISO (nunca negativo). */
 function idadeEmMinutos(inicioMs, ateEm) {
@@ -440,7 +441,7 @@ function varrerSessoes(opcoes = {}) {
     }
     const consultaClaude = opcoes.consulta ?? (adapter.disponivel()
         ? adapter.consultarSessoes(opcoes.soDaRaiz && raiz ? raiz : undefined, true)
-        : { ok: false, sessoes: [], detalhe: 'runtime adapter indisponivel nesta maquina (`claude` fora do PATH)' });
+        : { ok: false, sessoes: [], detalhe: (0, locale_1.textoDoCatalogo)((m) => m.pulse.adapterIndisponivel) });
     const consulta = { ...consultaClaude, ok: consultaClaude.ok || nativas.size > 0,
         sessoes: [...consultaClaude.sessoes, ...nativas.values()] };
     if (!consulta.ok) {
@@ -637,74 +638,72 @@ function dirCurto(cwd) {
 }
 /** Texto de `ork sessions hitl`. */
 function textoDoRadar(r) {
+    const m = (0, locale_1.msg)().operacao.restante.sessions.radar;
     const L = [];
-    L.push(`Radar de sessoes do runtime (${r.resumo.total} sessao(oes) na maquina)`);
-    L.push(`  precisam de humano: ${r.resumo.precisamDeHumano} (HITL vivo ${r.resumo.hitl}, ` +
-        `abandonada ${r.resumo.abandonadas}, falha ${r.resumo.falhas}, ` +
-        `estado desconhecido ${r.resumo.desconhecidas}) | ` +
-        `trabalhando: ${r.resumo.trabalhando} | fora do ork: ${r.resumo.foraDoOrk}`);
-    L.push(`  limite de atencao: ${r.atencaoMin} min (${r.resumo.acimaDoLimite} parada(s) acima, marcadas com !)`);
+    L.push(m.titulo(r.resumo.total));
+    L.push(m.resumo(r.resumo.precisamDeHumano, r.resumo.hitl, r.resumo.abandonadas, r.resumo.falhas, r.resumo.desconhecidas, r.resumo.trabalhando, r.resumo.foraDoOrk));
+    L.push(m.limite(r.atencaoMin, r.resumo.acimaDoLimite));
     if (!r.runtimeConsultado) {
-        L.push(`  [fail] ${r.runtimeDetalhe}: NAO da para saber quem esta parado`);
+        L.push(m.falha(r.runtimeDetalhe));
         return L.join('\n');
     }
     if (!r.logsLidos) {
-        L.push('  [warn] --sem-logs: o radar diz QUEM esta parado, mas nao O QUE cada sessao pergunta');
+        L.push(m.semLogs);
     }
     L.push('');
     if (r.sessoes.length === 0) {
-        L.push('  Nenhuma sessao na varredura.');
+        L.push(m.nenhuma);
         return L.join('\n');
     }
-    L.push((0, util_1.tabela)(['ID', 'NOME', 'CLASSE', 'ESTADO', 'TIPO', 'DIRETORIO', 'THREAD', 'IDADE'], r.sessoes.map((s) => [
+    L.push((0, util_1.tabela)([...m.colunas], r.sessoes.map((s) => [
         s.id,
         s.nome,
         s.classe,
-        s.estadoBruto || '(vazio)',
+        s.estadoBruto || m.vazio,
         s.tipoDeHitl ?? '-',
         dirCurto(s.cwd),
-        s.thread ? `${s.thread.id}/${s.thread.fase}` : 'fora do ork',
+        s.thread ? `${s.thread.id}/${s.thread.fase}` : m.fora,
         `${(0, horario_1.duracaoRelativa)(s.idadeMin)}${s.precisaDeHumano && s.acimaDoLimite ? ' !' : ''}`,
     ])));
     const travadas = r.sessoes.filter((s) => s.precisaDeHumano);
     if (travadas.length === 0) {
         L.push('');
-        L.push('  Nenhuma sessao esperando o humano.');
+        L.push(m.nenhumaEsperando);
         return L.join('\n');
     }
     const vivas = travadas.filter((s) => s.classe !== 'abandonada');
     if (vivas.length > 0) {
         L.push('');
-        L.push('Esperando o HUMANO agora, com o job VIVO (responder destrava na hora):');
+        L.push(m.vivas);
         for (const s of vivas) {
             L.push(`  ${s.id}  ${s.nome}  [${s.classe}${s.tipoDeHitl ? '/' + s.tipoDeHitl : ''}]`);
-            L.push(`      onde     : ${s.cwd}` +
-                (s.thread ? ` (thread ${s.thread.id}, fase ${s.thread.fase})` : ' (sessao fora do ork)'));
-            L.push(`      por que  : ${s.detalhe}`);
+            L.push(`      ${m.onde.padEnd(9)}: ${s.cwd}` +
+                ` (${s.thread ? m.thread(s.thread.id, s.thread.fase) : m.sessaoFora})`);
+            L.push(`      ${m.porque.padEnd(9)}: ${s.detalhe}`);
             if (s.pergunta)
-                L.push(`      pergunta : ${s.pergunta}`);
+                L.push(`      ${m.pergunta.padEnd(9)}: ${s.pergunta}`);
             for (const linha of s.contextoLogs ?? [])
-                L.push(`      log      : ${linha}`);
+                L.push(`      ${m.log.padEnd(9)}: ${linha}`);
             for (const a of s.alternativas)
-                L.push(`      opcao    : ${a}`);
-            L.push(`      parada ha: ${s.paradaHaMin == null ? 'desconhecido; registre com --registrar' : (0, horario_1.duracaoRelativa)(s.paradaHaMin) + ' (desde a primeira observação)'}`);
-            L.push(`      viva ha  : ${(0, horario_1.duracaoRelativa)(s.idadeMin)} (idade da sessao)`);
-            L.push(`      ver      : ${s.comandos.logs}`);
-            L.push(`      responder: ${s.comandos.attach}`);
-            L.push(`      recomendo: ${s.recomendacao}`);
+                L.push(`      ${m.opcao.padEnd(9)}: ${a}`);
+            L.push(`      ${m.parada.padEnd(9)}: ${s.paradaHaMin == null ? m.paradaDesconhecida : (0, horario_1.duracaoRelativa)(s.paradaHaMin) + ` (${m.desdeObservacao})`}`);
+            L.push(`      ${m.viva.padEnd(9)}: ${(0, horario_1.duracaoRelativa)(s.idadeMin)} (${m.idade})`);
+            L.push(`      ${m.ver.padEnd(9)}: ${s.comandos.logs}`);
+            L.push(`      ${m.responder.padEnd(9)}: ${s.comandos.attach}`);
+            L.push(`      ${m.recomendo.padEnd(9)}: ${s.recomendacao}`);
         }
     }
     const abandonadas = travadas.filter((s) => s.classe === 'abandonada');
     if (abandonadas.length > 0) {
         L.push('');
-        L.push('MORRERAM esperando resposta (job ja saiu: nao adianta responder, o trabalho parou):');
+        L.push(m.mortas);
         for (const s of abandonadas) {
             L.push(`  ${s.id}  ${s.nome}`);
-            L.push(`      onde     : ${s.cwd}` +
-                (s.thread ? ` (thread ${s.thread.id}, fase ${s.thread.fase})` : ' (sessao fora do ork)'));
-            L.push(`      por que  : ${s.detalhe}`);
-            L.push(`      viva ha  : ${(0, horario_1.duracaoRelativa)(s.idadeMin)} desde que a sessao comecou`);
-            L.push(`      recomendo: ${s.recomendacao}`);
+            L.push(`      ${m.onde.padEnd(9)}: ${s.cwd}` +
+                ` (${s.thread ? m.thread(s.thread.id, s.thread.fase) : m.sessaoFora})`);
+            L.push(`      ${m.porque.padEnd(9)}: ${s.detalhe}`);
+            L.push(`      ${m.viva.padEnd(9)}: ${(0, horario_1.duracaoRelativa)(s.idadeMin)} ${m.desdeInicio}`);
+            L.push(`      ${m.recomendo.padEnd(9)}: ${s.recomendacao}`);
         }
     }
     return L.join('\n');