@orkastery/cli 0.5.6 → 0.6.0

package/dist/hitl-resumo.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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_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;
@@ -64,9 +66,46 @@ function resumirHitl(itens, opcoes) {
                 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;
 /**
@@ -233,7 +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, '🧭 ', '   ')] : []),
@@ -266,7 +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-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

@@ -125,6 +125,11 @@ const REGRA_POR_ESTADO = {
         detalhe: locale_pulse_1.PULSE_PT_BR.sessao.failed,
     },
     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',
@@ -633,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');

package/dist/horario.js

@@ -22,6 +22,7 @@ exports.definirFusoDoDono = definirFusoDoDono;
 exports.fusoDoDono = fusoDoDono;
 exports.partesLocais = partesLocais;
 exports.dataLocal = dataLocal;
+exports.isoComFuso = isoComFuso;
 exports.instanteNoFuso = instanteNoFuso;
 exports.duracaoCurta = duracaoCurta;
 exports.duracaoRelativa = duracaoRelativa;
@@ -161,6 +162,21 @@ function desvioDoFuso(ms, fuso) {
     return Date.UTC(Number(p.ano), Number(p.mes) - 1, Number(p.dia), Number(p.hora), Number(p.minuto), Number(p.segundo)) -
         Math.floor(ms / 1000) * 1000;
 }
+/**
+ * RM-063 (F7): o instante em ISO com o deslocamento do fuso escrito (`2026-10-18T23:59:00-03:00`, ou `Z` no UTC). O
+ * prazo da autorização durável é gravado assim: quem o lê em outro fuso chega ao mesmo instante.
+ */
+function isoComFuso(quando, fuso = fusoDoDono().fuso) {
+    const ms = instante(quando);
+    if (!Number.isFinite(ms))
+        throw new Error('data inválida');
+    const p = partesLocais(ms, fuso);
+    const desvio = Math.round(desvioDoFuso(ms, fuso) / 60000);
+    const abs = Math.abs(desvio);
+    const deslocamento = desvio === 0 ? 'Z'
+        : `${desvio < 0 ? '-' : '+'}${String(Math.floor(abs / 60)).padStart(2, '0')}:${String(abs % 60).padStart(2, '0')}`;
+    return `${p.ano}-${p.mes}-${p.dia}T${p.hora}:${p.minuto}:${p.segundo}${deslocamento}`;
+}
 /**
  * RM-037 (fatia 5): o instante de um relógio num fuso IANA (mês de 1 a 12). O runtime diz a hora de
  * volta da cota no fuso dele (`resets 4:40am (<fuso>)`), e lê-la no relógio desta máquina errava o