@orkastery/cli 0.4.3 → 0.5.0

package/dist/hitl-curto.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEXTO_DO_ATO = exports.TETO_DE_LINHAS_DO_CORPO = exports.TETO_DE_LINHAS_DO_PEDIDO = exports.CONTRATO_PEDIDO_CURTO = void 0;
+exports.entradaDoPedido = entradaDoPedido;
+exports.montarPedidoCurto = montarPedidoCurto;
+exports.linhaDeResposta = linhaDeResposta;
+exports.textoDoPedidoCurto = textoDoPedidoCurto;
+exports.desdeDoPedido = desdeDoPedido;
+/**
+ * RM-048 (itens 1, 4 e 5): o contrato UNICO de apresentacao de um pedido ao dono.
+ *
+ * Ate aqui o mesmo pedido saia com tres textos diferentes: o dialogo do host (`apresentarDecisao`),
+ * o lote do Telegram (`textoDoLote`) e o item do pulse, que levava um comando com o identificador
+ * longo. Cada um gastava de tres a quatro linhas por alternativa, e o dono, que conduz dezenas de
+ * frentes ao mesmo tempo, tinha de reler a mensagem para achar a pergunta. O pedido do dono foi
+ * este: pergunta curta, alternativas de uma linha, sempre uma recomendada, e uma linha que diz
+ * como responder.
+ *
+ * O contrato tem sete partes e um teto, e o teto e garantido por construcao, nao por revisao:
+ *
+ *   titulo       de onde vem (thread e fase), em uma linha;
+ *   pergunta     o que se decide, em uma frase;
+ *   trava        o que esta parado, desde quando, e o que acontece sem resposta;
+ *   sem volta    so quando responder autoriza um ato da lista congelada;
+ *   corpo        no maximo `TETO_DE_LINHAS_DO_CORPO` linhas de evidencia;
+ *   alternativas de 2 a 4, uma linha cada, com a consequencia, e UMA recomendada com o porque;
+ *   responder    a ultima linha, dizendo exatamente o que digitar.
+ *
+ * O detalhe profundo (artefato, claims, riscos, diff) fica a um pedido de distancia: a ultima
+ * linha diz como pedir, e o nucleo responde com o bloco de evidencia (`<codigo> detalhes`).
+ *
+ * Telegram e terminal carregam o MESMO conteudo; muda o marcador (icone no Telegram, texto no
+ * terminal). OpenClaw transporta o texto do Telegram. Quem monta e o nucleo; o host so transporta.
+ */
+const hitl_1 = require("./hitl");
+const hitl_contract_1 = require("./hitl-contract");
+const horario_1 = require("./horario");
+exports.CONTRATO_PEDIDO_CURTO = 'ork.hitl-curto/v1';
+/** Nenhum pedido passa disto por padrao (RM-048, criterio c). */
+exports.TETO_DE_LINHAS_DO_PEDIDO = 15;
+/** Evidencia que cabe na pergunta curta; o resto vai no detalhe. */
+exports.TETO_DE_LINHAS_DO_CORPO = 2;
+/** Teto de uma linha logica: alternativa com consequencia ainda e leitura rapida. */
+const TETO_DA_LINHA = 200;
+/** O texto de cada ato congelado, como o dono o le. */
+exports.TEXTO_DO_ATO = Object.freeze({
+    dinheiro: 'gasta dinheiro',
+    'publicacao-externa': 'publica fora do projeto',
+    'apagar-dado': 'apaga dado',
+    'push-base-protegida': 'faz push na base protegida',
+});
+const linha = (texto, teto = TETO_DA_LINHA) => {
+    const limpo = (0, hitl_1.redigirSegredos)(String(texto ?? '')).replace(/\s+/g, ' ').trim();
+    return limpo.length > teto ? `${limpo.slice(0, teto - 3)}...` : limpo;
+};
+/** A entrada de um pedido v2 `pergunta`. Um v1 chega pelo lote, que ja o traduziu. */
+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');
+    }
+    const alvo = (0, hitl_contract_1.alvoDoPedido)(pedido);
+    return {
+        thread: pedido.thread, fase: pedido.fase, pergunta: (0, hitl_contract_1.textoDoPedido)(pedido),
+        alternativas: pedido.alternativas.map(a => ({ chave: a.letra, texto: a.texto, consequencia: a.consequencia,
+            ...(a.recomendada ? { recomendada: { porque: a.porque ?? '' } } : {}) })),
+        alvo: alvo?.tipo === 'session' ? { tipo: 'session', sessionId: alvo.sessionId } : { tipo: 'gate' },
+        corpo: pedido.corpo, ...(pedido.ato ? { ato: pedido.ato } : {}),
+        expiracao: (0, hitl_contract_1.expiracaoDoPedido)(pedido), prazo: (0, hitl_contract_1.prazoDoPedido)(pedido) ?? null, desde: desde ?? null,
+    };
+}
+/** 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 })}` : '';
+    if (e.expiracao === 'seguir-recomendada')
+        return `Sem resposta${ate}, sigo com a recomendada.`;
+    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.';
+}
+/**
+ * Monta o pedido curto. Recusa, em vez de cortar em silencio, o que o contrato nao aceita: menos
+ * de duas alternativas, mais de quatro, ou recomendada diferente de exatamente uma.
+ */
+function montarPedidoCurto(e, opcoes) {
+    if (e.alternativas.length < 2 || e.alternativas.length > 4)
+        throw new Error('pedido curto: de 2 a 4 alternativas');
+    if (e.alternativas.filter(a => a.recomendada).length !== 1)
+        throw new Error('pedido curto: exatamente uma alternativa é recomendada');
+    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 })}` : '';
+    return {
+        contrato: exports.CONTRATO_PEDIDO_CURTO,
+        titulo: linha([e.thread, e.fase].filter(Boolean).join(' · ') || 'sem thread'),
+        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]}.` } : {}),
+        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) } } : {}) })),
+        responder: opcoes.responder,
+    };
+}
+/** 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;
+    if (r.tipo === 'numero')
+        return null;
+    if (r.tipo === 'texto')
+        return `${canal === 'telegram' ? '↩️ ' : ''}Responda escrevendo o texto; ele é enviado como está.`;
+    if (r.tipo === 'dialogo')
+        return `${canal === 'telegram' ? '↩️ ' : ''}Responda selecionando a opção no diálogo; digitar a letra também vale.`;
+    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.`;
+}
+/**
+ * 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) {
+    if (p.contrato !== exports.CONTRATO_PEDIDO_CURTO)
+        throw new Error('pedido curto: contrato inválido');
+    const tg = canal === 'telegram';
+    const numero = p.responder.tipo === 'numero' ? `${p.responder.numero}. ` : '';
+    const linhas = [
+        `${tg && !numero ? '🔔 ' : ''}${numero}${tg || numero ? '' : 'Orkastery · '}${p.titulo}`,
+        `${tg ? '❓ ' : 'Pergunta: '}${p.pergunta}`,
+        `${tg ? '⏳ ' : 'Situação: '}${p.trava}`,
+        ...(p.semVolta ? [`${tg ? '🔒 ' : '! '}${p.semVolta}`] : []),
+        ...p.corpo.map(l => `${tg ? '• ' : '- '}${l}`),
+        ...p.alternativas.flatMap(a => [
+            `${a.chave}) ${a.texto}${a.recomendada ? (tg ? ' ✅ recomendada' : ' [recomendada]') : ''}: ${a.consequencia}`,
+            ...(a.recomendada ? [`   porquê: ${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');
+    return linhas.join('\n');
+}
+/**
+ * Desde quando o dono e esperado nesta pergunta: o primeiro pedido do ledger com o mesmo codigo
+ * no mesmo contexto. Com o codigo estavel (D4), renovar o pedido nao zera o relogio que o dono ve.
+ */
+function desdeDoPedido(eventos, pedido) {
+    const codigo = pedido.codigo;
+    const doPedido = eventos.find(e => e.tipo === 'hitl_requested' && e.pedido?.id === pedido.id);
+    if (typeof codigo !== 'string' || !doPedido)
+        return pedido.criadoEm;
+    const primeiro = eventos.find(e => e.tipo === 'hitl_requested' && e.contexto === doPedido.contexto &&
+        e.pedido?.codigo === codigo);
+    return primeiro?.pedido?.criadoEm ?? pedido.criadoEm;
+}

package/dist/hitl-gates.js

@@ -45,6 +45,8 @@ exports.resolverCriterio = resolverCriterio;
 exports.registrarPedidoHitl = registrarPedidoHitl;
 exports.abrirPedidoGate = abrirPedidoGate;
 exports.prepararPedidoGate = prepararPedidoGate;
+exports.essenciaDoPedido = essenciaDoPedido;
+exports.renovarPedidoDoGate = renovarPedidoDoGate;
 exports.conferirResposta = conferirResposta;
 exports.dadosDaResposta = dadosDaResposta;
 exports.receberResposta = receberResposta;
@@ -330,7 +332,13 @@ function prepararPedidoGate(raiz, id, motivo = 'human.pending', quando = new Dat
     const ato = (0, hitl_contract_1.atoDaPausa)(motivo, bloco.pausaSobre);
     // O codigo curto e unico contra os que ja estao no ledger desta thread. T11 acrescenta o
     // comando que o resolve; a unicidade precisa nascer com o primeiro pedido que o carrega.
-    const codigo = (0, pulse_consentimento_1.gerarCodigo)(eventos.flatMap(e => {
+    // RM-048 (D4): o gate reaberto no MESMO contexto e pelo mesmo motivo reaproveita o codigo do
+    // pedido anterior. Era a troca de codigo a cada hora que fazia a linha recebida virar po.
+    // A2 do CHECK: gate ja respondido de forma definitiva (aprovado ou recusado) neste contexto nao
+    // empresta o codigo: o que renasce depois dele e outra pergunta, com outro codigo.
+    const definitivo = gateRespondidoDeVez(eventos, contexto, motivo);
+    const anterior = definitivo ? undefined : pedidoAtual?.codigo;
+    const codigo = typeof anterior === 'string' ? anterior : (0, pulse_consentimento_1.gerarCodigo)(eventos.flatMap(e => {
         const c = e.pedido?.codigo;
         return typeof c === 'string' ? [c] : [];
     }));
@@ -353,8 +361,66 @@ function prepararPedidoGate(raiz, id, motivo = 'human.pending', quando = new Dat
         tipoDeResposta: 'objetiva', irreversivel: ato !== undefined, ...(ato ? { ato } : {}), codigo,
         prazo: new Date(Date.parse(quando) + 60 * 60 * 1000).toISOString(), acaoPadraoAoExpirar: 'esperar',
         respostaAceita: { tipo: 'opcao', maxCaracteres: 100 } };
+    // RM-048 (D4): um codigo quer dizer UMA pergunta. Se o que sairia agora nao e o que o dono leu
+    // com este codigo (a recomendada mudou, o diagnostico mudou), o codigo e outro: "DE6H a" nunca
+    // se aplica a uma pergunta que o dono nao viu.
+    if (typeof anterior === 'string' && pedidoAtual && essenciaDoPedido(pedido) !== essenciaDoPedido(pedidoAtual)) {
+        pedido.codigo = (0, pulse_consentimento_1.gerarCodigo)(eventos.flatMap(e => {
+            const c = e.pedido?.codigo;
+            return typeof c === 'string' ? [c] : [];
+        }));
+    }
     return { novo: pedido };
 }
+/** Algum pedido deste gate (contexto e motivo) ja recebeu veredito definitivo (nao `aguardando`). */
+function gateRespondidoDeVez(eventos, contexto, motivo) {
+    const ids = new Set(eventos.filter(e => e.tipo === 'hitl_requested' && e.contexto === contexto &&
+        (0, hitl_contract_1.alvoDoPedido)(e.pedido)?.tipo === 'gate' && (0, hitl_contract_1.motivoDoPedido)(e.pedido) === motivo)
+        .map(e => e.pedido.id));
+    return eventos.some(e => e.tipo === 'human_gate' && ids.has(String(e.pedidoId)) && e.estado !== 'aguardando');
+}
+/**
+ * RM-048 (D4): o que faz dois pedidos de gate serem a MESMA pergunta para o dono. O identificador,
+ * o instante e o prazo mudam a cada renovacao; o que o dono leu e respondeu nao pode mudar.
+ */
+function essenciaDoPedido(p) {
+    if (!(0, hitl_contract_1.ehV2)(p) || p.classe !== 'pergunta')
+        return JSON.stringify(['v1', p.id]);
+    return JSON.stringify([p.thread, p.fase, p.modo, p.alvo, p.motivo, p.pergunta, p.alternativas, p.corpo,
+        p.tipoDeResposta, p.irreversivel, p.ato ?? null, p.codigo]);
+}
+/**
+ * RM-048 (D4): a resposta a um pedido de gate vencido vai para o pedido RENOVADO, e so quando a
+ * pergunta e a mesma.
+ *
+ * O prazo de uma hora existe para que uma aprovacao velha nao se aplique a um mundo novo. Aqui o
+ * mundo e conferido de novo, e nao presumido: o contexto da thread (modo, fase, status, base,
+ * despacho) tem de ser o do pedido original, o gate tem de continuar esperando o dono agora
+ * (`prepararPedidoGate`, com as mesmas recusas de sempre), e a essencia do pedido que sairia
+ * agora tem de ser identica a do que o dono leu. Qualquer diferenca e recusa com "pedido antigo":
+ * a letra que o dono digitou nunca e aplicada a uma pergunta que ele nao viu.
+ *
+ * Nao escolhe resposta, nao aprova nada e nao toca a prova: quem registra e `responderGate`, com
+ * o envelope assinado pelo ingresso, contra o pedido que esta funcao devolve.
+ */
+function renovarPedidoDoGate(raiz, original, quando) {
+    (0, hitl_contract_1.validarPedidoHitl)(original);
+    if ((0, hitl_contract_1.alvoDoPedido)(original)?.tipo !== 'gate')
+        throw new Error('pedido antigo: só pedido de gate é renovado');
+    const t = (0, thread_1.lerThread)(raiz, original.thread), eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, original.thread));
+    const evento = eventos.find(e => e.tipo === 'hitl_requested' && e.pedido?.id === original.id);
+    if (!evento || evento.contexto !== contextoHitlDosEventos(t, eventos))
+        throw new Error('pedido antigo: fase, modo ou sessão mudou');
+    // A2 do CHECK: a linha velha nao desfaz um veredito definitivo dado por outra linha.
+    if (gateRespondidoDeVez(eventos, evento.contexto, (0, hitl_contract_1.motivoDoPedido)(original))) {
+        throw new Error('pedido antigo: o gate já foi respondido');
+    }
+    const preparado = prepararPedidoGate(raiz, original.thread, (0, hitl_contract_1.motivoDoPedido)(original), quando);
+    const candidato = 'aberto' in preparado ? preparado.aberto : preparado.novo;
+    if (essenciaDoPedido(candidato) !== essenciaDoPedido(original))
+        throw new Error('pedido antigo: a pergunta mudou desde que saiu');
+    return 'aberto' in preparado ? preparado.aberto : registrarPedidoHitl(raiz, preparado.novo);
+}
 const LETRAS_DO_GATE = ['a', 'b', 'c'];
 /** Corta uma linha de evidencia no teto do corpo, sem deixar o pedido inteiro ser recusado. */
 const linhaDoCorpo = (texto) => texto.slice(0, hitl_contract_1.TETOS_HITL_V2.corpoLinha);

package/dist/hitl-lote.js

@@ -30,6 +30,7 @@ exports.textoDoLote = textoDoLote;
  */
 const hitl_contract_1 = require("./hitl-contract");
 const hitl_1 = require("./hitl");
+const hitl_curto_1 = require("./hitl-curto");
 exports.CONTRATO_LOTE = 'ork.hitl-lote/v1';
 /** De cinco em cinco, como o dono pediu. As que sobram continuam guardadas, nao somem. */
 exports.TETO_DE_PERGUNTAS_POR_LOTE = 5;
@@ -86,6 +87,16 @@ function alternativaRecomendada(pedido) {
         .filter(o => o.achou);
     return citadas.length === 1 ? citadas[0].i : -1;
 }
+/** O que o contrato curto le do pedido alem das alternativas: alvo, corpo, ato e expiracao. */
+function contextoDaPergunta(pedido) {
+    const alvo = (0, hitl_contract_1.alvoDoPedido)(pedido);
+    const v2 = (0, hitl_contract_1.ehV2)(pedido) && pedido.classe === 'pergunta' ? pedido : undefined;
+    return {
+        alvo: alvo?.tipo === 'session' ? { tipo: 'session', sessionId: alvo.sessionId } : { tipo: 'gate' },
+        ...(v2 ? { corpo: [...v2.corpo] } : {}), ...(v2?.ato ? { ato: v2.ato } : {}),
+        expiracao: (0, hitl_contract_1.expiracaoDoPedido)(pedido), prazo: (0, hitl_contract_1.prazoDoPedido)(pedido) ?? null,
+    };
+}
 /**
  * Traduz um pedido em pergunta do lote, ou diz por que ele nao virou uma.
  *
@@ -105,7 +116,8 @@ function perguntaDoPedido(pedido, numero) {
         return recusa('pergunta vazia');
     const declaradas = alternativasDeclaradas(pedido);
     if (declaradas) {
-        return { numero, thread: pedido.thread ?? null, fase: pedido.fase ?? null, pergunta, alternativas: declaradas, pedidoId: pedido.id };
+        return { numero, thread: pedido.thread ?? null, fase: pedido.fase ?? null, pergunta, alternativas: declaradas, pedidoId: pedido.id,
+            ...contextoDaPergunta(pedido) };
     }
     // I-41 (T4c): o parser da recomendacao e exclusivo do v1, e a porta se fecha aqui.
     //
@@ -125,7 +137,7 @@ function perguntaDoPedido(pedido, numero) {
     if (recomendada < 0)
         return recusa('a recomendação não nomeia exatamente uma alternativa');
     return {
-        numero, thread: pedido.thread ?? null, fase: pedido.fase ?? null, pergunta, pedidoId: pedido.id,
+        numero, thread: pedido.thread ?? null, fase: pedido.fase ?? null, pergunta, pedidoId: pedido.id, ...contextoDaPergunta(pedido),
         alternativas: opcoes.map((o, i) => ({
             letra: exports.LETRAS[i], texto: linha(o.texto), consequencia: exports.CONSEQUENCIA_DA_ACAO[o.acao],
             ...(i === recomendada ? { recomendada: { porque: linha((0, hitl_contract_1.recomendacaoDoPedido)(pedido)) } } : {}),
@@ -172,17 +184,18 @@ function montarLote(pedidos, opcoes = {}) {
 function guardadasDepoisDoLote(lote) {
     return lote.restantes;
 }
-function corpoDaPergunta(p, marca) {
-    const cabecalho = [p.thread, p.fase].filter(Boolean).join(' · ');
-    return [
-        `${p.numero}. ${cabecalho || 'sem thread'}`,
-        `   ${p.pergunta}`,
-        ...p.alternativas.flatMap(a => [
-            `   ${a.letra}) ${a.texto}${a.recomendada ? `  ${marca}recomendada` : ''}`,
-            `      → ${a.consequencia}`,
-            ...(a.recomendada ? [`      porquê: ${a.recomendada.porque}`] : []),
-        ]),
-    ];
+/**
+ * RM-048 (D1): cada pergunta do lote sai pelo contrato curto, com o numero no titulo. A linha de
+ * como responder e uma so, no fim do lote, porque o dono responde todas numa mensagem: "1a 2c".
+ */
+function corpoDaPergunta(p, canal, quando) {
+    const curto = (0, hitl_curto_1.montarPedidoCurto)({
+        thread: p.thread, fase: p.fase, pergunta: p.pergunta, alvo: p.alvo, corpo: p.corpo, ato: p.ato,
+        expiracao: p.expiracao, prazo: p.prazo, desde: p.desde,
+        alternativas: p.alternativas.map(a => ({ chave: a.letra, texto: a.texto, consequencia: a.consequencia,
+            ...(a.recomendada ? { recomendada: { porque: a.recomendada.porque } } : {}) })),
+    }, { quando, responder: { tipo: 'numero', numero: p.numero } });
+    return (0, hitl_curto_1.textoDoPedidoCurto)(curto, canal).split('\n');
 }
 /** A5: a frase dos pedidos que nao viraram pergunta, com a concordancia certa para o dono ler. */
 function linhaDasRecusas(n) {
@@ -200,15 +213,17 @@ function textoDoLote(lote, opcoes) {
     if (lote.contrato !== exports.CONTRATO_LOTE)
         throw new Error('lote HITL: contrato inválido');
     const telegram = opcoes.canal === 'telegram';
+    const quando = opcoes.quando ?? new Date().toISOString();
     const n = lote.perguntas.length;
     const exemplo = lote.perguntas.map(p => `${p.numero}${p.alternativas[0].letra}`).join(' ');
     const faltam = opcoes.proximo?.faltam ?? lote.restantes;
     return [
         `${telegram ? '📋 ' : ''}Orkastery, ${n === 1 ? '1 pergunta' : `${n} perguntas`}`,
         '',
-        ...lote.perguntas.flatMap((p, i) => [...corpoDaPergunta(p, telegram ? '✅ ' : '← '), ...(i < n - 1 ? [''] : [])]),
+        ...lote.perguntas.flatMap((p, i) => [...corpoDaPergunta(p, opcoes.canal, quando), ...(i < n - 1 ? [''] : [])]),
         '',
-        ...(n ? [`Responda com o número e a letra, por exemplo: ${exemplo}.`] : ['Nenhuma pergunta em formato respondível agora.']),
+        ...(n ? [`${telegram ? '↩️ ' : ''}Responda com o número e a letra, por exemplo: ${exemplo}. Evidências: ${lote.perguntas[0].numero} detalhes.`]
+            : ['Nenhuma pergunta em formato respondível agora.']),
         ...(opcoes.proximo && faltam
             ? [`Falta${faltam === 1 ? '' : 'm'} ${faltam}. Para receber as próximas, responda ${opcoes.proximo.codigo} a.`]
             : faltam ? [`Sobra${faltam === 1 ? '' : 'm'} ${faltam} para o próximo lote.`] : []),

package/dist/hitl-presentation.js

@@ -51,6 +51,7 @@ const hitl_contract_1 = require("./hitl-contract");
 const hitl_canais_1 = require("./hitl-canais");
 const hitl_native_offer_1 = require("./hitl-native-offer");
 const horario_1 = require("./horario");
+const hitl_curto_1 = require("./hitl-curto");
 /**
  * I-35: prazo do pedido no fuso do dono, absoluto e rotulado, para JSON de exibição
  * (`ork gate context` e `ork_hitl_pending`). `pedido.prazo` continua o ISO assinado.
@@ -66,25 +67,27 @@ function prazoLocalDoPedido(pedido, agora) {
  * e o que ele troca é o número pela letra. Um `decidido` não passa por aqui de propósito: ele
  * não tem escolha a oferecer, e montar um diálogo para um fato consumado é pedir ação por engano.
  */
-function apresentarDecisao(pedido, agora) {
+function apresentarDecisao(pedido, agora, desde) {
     (0, hitl_contract_1.validarPedidoHitl)(pedido);
     const aceita = (0, hitl_contract_1.respostaAceitaDoPedido)(pedido);
     if (!aceita)
         throw new Error('decisão informada não tem diálogo: ela não pede nada');
     const livre = aceita.tipo === 'texto';
     const escolhas = (0, hitl_contract_1.escolhasDoPedido)(pedido).map(o => ({ const: (0, hitl_contract_1.chaveDaEscolha)(pedido, o.numero), title: (0, hitl_1.redigirSegredos)(o.texto) }));
-    const v2 = (0, hitl_contract_1.ehV2)(pedido) && pedido.classe === 'pergunta' ? pedido : undefined;
+    // RM-048 (D1): a pergunta v2 sai pelo contrato curto, o mesmo do Telegram e do lote. O v1 fica
+    // byte a byte abaixo: recibo antigo continua batendo com o texto que o dono viu.
+    if ((0, hitl_contract_1.ehV2)(pedido) && pedido.classe === 'pergunta') {
+        const curto = (0, hitl_curto_1.montarPedidoCurto)((0, hitl_curto_1.entradaDoPedido)(pedido, desde ?? pedido.criadoEm), { quando: agora ?? new Date().toISOString(), responder: livre ? { tipo: 'texto' } : { tipo: 'dialogo' } });
+        return { mensagem: (0, hitl_curto_1.textoDoPedidoCurto)(curto, 'terminal'), escolhas };
+    }
     const expiracao = (0, hitl_contract_1.expiracaoDoPedido)(pedido);
     const linhas = [
         `Orkastery · ${pedido.fase}`,
         `• Decisão: ${(0, hitl_1.redigirSegredos)((0, hitl_contract_1.textoDoPedido)(pedido))}`,
         `• Recomendo: ${(0, hitl_1.redigirSegredos)((0, hitl_contract_1.recomendacaoDoPedido)(pedido))}`,
-        ...escolhas.flatMap((o, i) => [
-            `  ${o.const}. ${o.title}`,
-            ...(v2 ? [`     → ${(0, hitl_1.redigirSegredos)(v2.alternativas[i].consequencia)}`] : []),
-        ]),
+        ...escolhas.map(o => `  ${o.const}. ${o.title}`),
         livre ? '• Resposta: escreva sua resposta; o texto será enviado literalmente.'
-            : `• Resposta: selecione uma opção no diálogo. Se necessário, digite ${v2 ? 'a letra' : 'o número'}.`,
+            : '• Resposta: selecione uma opção no diálogo. Se necessário, digite o número.',
         ...(livre && escolhas.length ? ['  Exemplo: digitar “2” envia o texto “2”, sem selecionar a segunda opção.'] : []),
         `• Prazo: ${(0, horario_1.formatarPrazo)((0, hitl_contract_1.prazoDoPedido)(pedido), { rotulo: true, agora })}. Sem resposta, ${expiracao === 'esperar' ? 'aguardamos' : expiracao === 'seguir-recomendada' ? 'sigo com a recomendada' : 'o pedido será escalado'}.`,
     ];

package/dist/hitl-resumo.js

@@ -2,6 +2,7 @@
 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_THREADS_NOMEADAS = exports.PERGUNTA_DO_RESUMO = exports.CONTRATO_RESUMO = void 0;
 exports.resumirHitl = resumirHitl;
+exports.linhaDosTecnicos = linhaDosTecnicos;
 exports.linhasDasOutrasMaquinas = linhasDasOutrasMaquinas;
 exports.linhasDasDecisoes = linhasDasDecisoes;
 exports.linhaDasPerguntas = linhaDasPerguntas;
@@ -41,7 +42,10 @@ exports.PERGUNTA_DO_RESUMO = 'Posso te mandar as perguntas agora?';
 exports.TETO_DE_THREADS_NOMEADAS = 5;
 function resumirHitl(itens, opcoes) {
     const janelaMin = opcoes.janelaMin ?? hitl_classificacao_1.JANELA_PADRAO_MIN;
-    const contagem = (0, hitl_classificacao_1.contarClassificacoes)(itens, { quando: opcoes.quando, janelaMin, atoDoItem: opcoes.atoDoItem });
+    // RM-048 (D6): o que e do dono e contado para ele; o que e tecnico e dito a parte.
+    const doDono = itens.filter(i => (0, hitl_classificacao_1.quemDecide)(i.motivo) === 'dono');
+    const tecnicos = itens.filter(i => (0, hitl_classificacao_1.quemDecide)(i.motivo) === 'orquestrador');
+    const contagem = (0, hitl_classificacao_1.contarClassificacoes)(doDono, { quando: opcoes.quando, janelaMin, atoDoItem: opcoes.atoDoItem });
     const prontas = opcoes.prontas ?? 0;
     return {
         contrato: exports.CONTRATO_RESUMO, consultadoEm: opcoes.quando, janelaMin, ...contagem,
@@ -49,8 +53,15 @@ function resumirHitl(itens, opcoes) {
         pergunta: prontas > 0 ? exports.PERGUNTA_DO_RESUMO : null,
         decisoes: [...(opcoes.decisoes ?? [])], acimaDoLimiar: [...(opcoes.acimaDoLimiar ?? [])],
         ...(opcoes.outrasMaquinas?.length ? { outrasMaquinas: opcoes.outrasMaquinas.map(m => ({ ...m, esperando: [...m.esperando] })) } : {}),
+        tecnicos: tecnicos.length,
+        threadsTecnicas: [...new Set(tecnicos.map(i => i.thread).filter((t) => !!t))].sort(),
     };
 }
+/** RM-048 (D6): a linha do que e tecnico, igual nos dois canais. Nao pede nada ao dono. */
+function linhaDosTecnicos(r) {
+    const nomes = r.threadsTecnicas.length ? ` (${nomearThreads(r.threadsTecnicas)})` : '';
+    return `Conosco, impedimento técnico: ${r.tecnicos}${nomes}. Não precisa de você.`;
+}
 /** Quantas threads de outra maquina o resumo nomeia antes de contar o resto. */
 exports.TETO_DE_ESPERAS_POR_MAQUINA = 3;
 /**
@@ -91,10 +102,11 @@ function linhasDasDecisoes(r, marcador, recuo) {
     const mostradas = r.decisoes.slice(-exports.TETO_DE_DECISOES_DETALHADAS), sobra = r.decisoes.length - mostradas.length;
     return [
         ...(r.decisoes.length ? [`${marcador}Decidi sem te perguntar: ${r.decisoes.length}`] : []),
+        // RM-048 (item 4): duas linhas por decisao, efeito primeiro; o resto do detalhe esta no placar.
         ...mostradas.flatMap(d => [
             `${recuo}• ${d.thread} ${d.fase}: ${uma(d.decidido)}`,
-            `${recuo}  porquê: ${uma(d.porque, 120)}. Para mudar: ${uma(d.comoMudar, 120)}.`,
-            `${recuo}  reverter agora: ${uma(d.custoDeReverter.agora, 80)}; depois: ${uma(d.custoDeReverter.depois, 80)}.`,
+            `${recuo}  porquê: ${uma(d.porque, 120)}. Para mudar: ${uma(d.comoMudar, 120)}; ` +
+                `reverter agora: ${uma(d.custoDeReverter.agora, 80)}; depois: ${uma(d.custoDeReverter.depois, 80)}.`,
         ]),
         ...(sobra > 0 ? [`${recuo}e mais ${sobra}: ork decisao placar <thread>`] : []),
         ...r.acimaDoLimiar.map(f => `${recuo}${marcador ? '⚠️ ' : '! '}${f.thread} ${f.fase} já tomou ${f.decididas} decisões sozinha, ` +
@@ -143,27 +155,35 @@ function linhaDeResposta(codigo) {
         ? [`Responda com ${codigo} a (sim) ou ${codigo} b (agora não).`]
         : ['Responda: a (sim) ou b (agora não).'];
 }
-/** O fecho do resumo: a pergunta do dono quando ha o que mandar, e a frase honesta quando nao ha. */
-function fecho(r, codigo) {
-    return r.pergunta ? [r.pergunta, ...linhaDeResposta(codigo)] : [exports.SEM_PERGUNTA_NO_RESUMO];
+/**
+ * RM-048 (item 4): a pergunta sai no ALTO, logo depois do titulo, com a linha de como responder.
+ * Em 27/09 ela ficou escondida no fim, depois de tres blocos de decisoes informadas. Sem pergunta,
+ * a frase honesta continua sendo a ultima linha.
+ */
+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];
 }
 function textoTelegram(r, codigo) {
     const quando = (0, horario_1.formatarDataHoraRotulada)(r.consultadoEm, { agora: r.consultadoEm });
     const linhas = [
         `🔔 Orkastery, resumo de ${quando}`,
-        '',
+        ...abertura(r, codigo, '❓ ', '↩️ '),
+        ...(r.pergunta ? [] : ['']),
         `Esperando você: ${r.total}`,
         `⏱ Urgentes: ${r.urgentes}`,
         `⛔ Travando o avanço: ${r.bloqueantes}${r.threadsBloqueadas.length ? `, em ${r.threadsBloqueadas.length} threads` : ''}`,
         ...(r.threadsBloqueadas.length ? [`   ${nomearThreads(r.threadsBloqueadas)}`] : []),
         `🔒 Sem volta depois de feito: ${r.criticos}`,
         `❓ ${linhaDasPerguntas(r.prontas)}`,
+        ...(r.tecnicos ? [`🔧 ${linhaDosTecnicos(r)}`] : []),
         ...(r.consertos ? [`🔧 ${linhaDosConsertos(r.consertos)}`] : []),
         ...(r.acumuladas ? ['', `📥 ${linhaDoLoteGuardado(r.acumuladas)}`] : []),
         ...(r.decisoes.length || r.acimaDoLimiar.length ? ['', ...linhasDasDecisoes(r, '🧭 ', '   ')] : []),
         ...(r.outrasMaquinas?.length ? ['', ...linhasDasOutrasMaquinas(r, '🖥️ ', '   ')] : []),
-        '',
-        ...fecho(r, codigo),
+        ...fecho(r),
     ];
     return linhas.join('\n');
 }
@@ -181,18 +201,19 @@ function textoTerminal(r, codigo) {
     const regua = `  ${'-'.repeat(largura)}  ${'-'.repeat(numero)}`;
     const linhas = [
         `Orkastery, resumo de ${quando}`,
-        '',
+        ...abertura(r, codigo, '', ''),
+        ...(r.pergunta ? [] : ['']),
         `  ${'o que'.padEnd(largura)}  ${'quantos'.padStart(numero)}`,
         regua,
         ...celulas.map(([nome, n]) => `  ${nome.padEnd(largura)}  ${String(n).padStart(numero)}`),
         ...(r.threadsBloqueadas.length
             ? ['', `  threads travadas (${r.threadsBloqueadas.length}): ${nomearThreads(r.threadsBloqueadas)}`] : []),
+        ...(r.tecnicos ? ['', `  ${linhaDosTecnicos(r)}`] : []),
         ...(r.consertos ? ['', `  ${linhaDosConsertos(r.consertos)}`] : []),
         ...(r.acumuladas ? ['', `  ${linhaDoLoteGuardado(r.acumuladas)}`] : []),
         ...(r.decisoes.length || r.acimaDoLimiar.length ? ['', ...linhasDasDecisoes(r, '', '  ').map(l => l.startsWith('  ') ? l : `  ${l}`)] : []),
         ...(r.outrasMaquinas?.length ? ['', ...linhasDasOutrasMaquinas(r, '', '  ').map(l => l.startsWith('  ') ? l : `  ${l}`)] : []),
-        '',
-        ...fecho(r, codigo),
+        ...fecho(r),
     ];
     return linhas.join('\n');
 }