@orkastery/cli 0.4.2 → 0.5.0

package/dist/pulse-resposta.js

@@ -33,15 +33,26 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.chaveDoGate = exports.GRAMATICA_DO_PULSE = exports.CONTRATO_LOTE_SERVIDO = exports.CONTRATO_RESPOSTA_DO_PULSE = void 0;
+exports.CONTRATO_ESCUTA = exports.chaveDoGate = exports.GUARDA_DA_PERGUNTA_MS = exports.GRAMATICA_DO_PULSE = exports.CONTRATO_LOTE_SERVIDO = exports.CONTRATO_RESPOSTA_DO_PULSE = void 0;
 exports.interpretarRespostaDoPulse = interpretarRespostaDoPulse;
 exports.arquivoDoLoteServido = arquivoDoLoteServido;
 exports.lerLoteServido = lerLoteServido;
 exports.perguntaViva = perguntaViva;
+exports.perguntaEmAberto = perguntaEmAberto;
 exports.threadsComPerguntaViva = threadsComPerguntaViva;
 exports.gatesJaServidos = gatesJaServidos;
 exports.avaliarFila = avaliarFila;
 exports.servirLote = servirLote;
+exports.pedidoParaResponder = pedidoParaResponder;
+exports.pedidosComCodigo = pedidosComCodigo;
+exports.codigosEmUso = codigosEmUso;
+exports.textoDoDetalhe = textoDoDetalhe;
+exports.opcoesReais = opcoesReais;
+exports.registrarPorCodigo = registrarPorCodigo;
+exports.pedidosAbertosDaThread = pedidosAbertosDaThread;
+exports.abertosDoDono = abertosDoDono;
+exports.arquivoDaEscuta = arquivoDaEscuta;
+exports.atualizarEscuta = atualizarEscuta;
 exports.responderPeloPulse = responderPeloPulse;
 /**
  * I-41 (GO-FIX 1, B1 e B2): o caminho de volta.
@@ -73,6 +84,15 @@ const hitl_gates_1 = require("./hitl-gates");
 const hitl_contract_1 = require("./hitl-contract");
 const monitor_lock_1 = require("./monitor-lock");
 const hitl_lote_1 = require("./hitl-lote");
+const hitl_curto_1 = require("./hitl-curto");
+const hitl_texto_livre_1 = require("./hitl-texto-livre");
+const hitl_presentation_1 = require("./hitl-presentation");
+const roadmap_status_1 = require("./roadmap-status");
+const master_nota_1 = require("./master-nota");
+const master_1 = require("./master");
+const master_batch_1 = require("./master-batch");
+const master_digest_1 = require("./master-digest");
+const hitl_classificacao_1 = require("./hitl-classificacao");
 const pulse_cadencia_1 = require("./pulse-cadencia");
 const ledger_1 = require("./ledger");
 const thread_1 = require("./thread");
@@ -95,31 +115,60 @@ exports.CONTRATO_LOTE_SERVIDO = 'ork.pulse-lote-servido/v1';
  * Tag no meio de uma frase continua sendo conversa com o assistente.
  */
 exports.GRAMATICA_DO_PULSE = Object.freeze({
-    consentimento: '^[ \\t]*(?=[A-HJKMNP-TV-Z][2-9A-HJKMNP-TV-Z]{0,2}[2-9])[A-HJKMNP-TV-Z][2-9A-HJKMNP-TV-Z]{3}[ \\t]+[^\\r\\n]{1,40}$',
+    // RM-048 (D9): o texto depois do codigo vai a 200 caracteres, para caber o porque da nota.
+    consentimento: '^[ \\t]*(?=[A-HJKMNP-TV-Z][2-9A-HJKMNP-TV-Z]{0,2}[2-9])[A-HJKMNP-TV-Z][2-9A-HJKMNP-TV-Z]{3}[ \\t]+[^\\r\\n]{1,200}$',
     lote: '^[ \\t]*[0-9]{1,2}[ \\t]*[a-zA-Z](?:[ \\t,;]*[0-9]{1,2}[ \\t]*[a-zA-Z])*[ \\t]*[.!]?[ \\t]*$',
     cadencia: '^[ \\t]*#OrkPulse(?:On(?:-(?:15|30|60)m)?|Off)[ \\t]*[.!]?[ \\t]*$',
+    // RM-048 (D2 e D3): as formas do texto livre, geradas do vocabulario fechado. `lista` e
+    // interceptada sempre; `livre` so dentro da janela de escuta (`pulse-escuta.json`).
+    lista: hitl_texto_livre_1.FORMAS_DO_TEXTO_LIVRE.lista,
+    livre: hitl_texto_livre_1.FORMAS_DO_TEXTO_LIVRE.livre,
+    // RM-048 (item 8): o teclado do digest semanal ("ratificar <thread> <assinatura> <classe>" e
+    // "ratificar-lote <semana> <assinatura>") passa pelo mesmo endereco assinado, e nao pelo agente.
+    ratificacao: '^[ \\t]*ratificar(?:-lote)?(?:[ \\t]+[A-Za-z0-9._-]{1,80}){2,3}[ \\t]*$',
 });
+const RATIFICACAO = new RegExp(exports.GRAMATICA_DO_PULSE.ratificacao, 'i');
 const CONSENTIMENTO = new RegExp(exports.GRAMATICA_DO_PULSE.consentimento, 'i');
 const LOTE = new RegExp(exports.GRAMATICA_DO_PULSE.lote);
 const CADENCIA = new RegExp(exports.GRAMATICA_DO_PULSE.cadencia, 'i');
 /** O que o dono quis dizer, pela forma. Nada aqui le intencao: ou a forma bate, ou nao. */
 function interpretarRespostaDoPulse(texto) {
-    if (typeof texto !== 'string' || texto.length > 200)
+    if (typeof texto !== 'string' || texto.length > hitl_texto_livre_1.TETO_DA_FORMA)
         return { forma: 'desconhecida' };
+    // S2 do CHECK: a lista vem antes, porque "1 s" e "1 n" sao palavras do vocabulario e nao letras.
+    // "1a 2c" casa as duas e sai igual pelas duas; o lote segue para letra fora de a-d ("1e").
+    const lista = (0, hitl_texto_livre_1.lerLista)(texto);
+    if (lista && lista.some(i => i.trecho.tipo !== 'letra'))
+        return { forma: 'lista', itens: lista };
     if (LOTE.test(texto)) {
         const escolhas = [...texto.matchAll(/([0-9]{1,2})[ \t]*([a-zA-Z])/g)]
             .map(m => ({ numero: Number(m[1]), letra: m[2].toLowerCase() }));
         return { forma: 'lote', escolhas };
     }
+    if (lista)
+        return { forma: 'lista', itens: lista };
+    if (RATIFICACAO.test(texto))
+        return { forma: 'ratificacao', texto: texto.trim() };
     if (CONSENTIMENTO.test(texto))
         return { forma: 'consentimento', codigo: texto.trim().slice(0, 4).toUpperCase() };
     const tag = CADENCIA.test(texto) ? (0, pulse_cadencia_1.extrairTagDoPulse)(texto) : null;
     if (tag)
         return { forma: 'cadencia', tag };
+    const solta = (0, hitl_texto_livre_1.lerSolta)(texto);
+    if (solta)
+        return { forma: 'livre', trecho: solta };
     return { forma: 'desconhecida' };
 }
 /** Quanto tempo uma pergunta respondida continua no registro, para "ja estava registrada". */
 const GUARDA_DO_RESPONDIDO_MS = 24 * 60 * 60 * 1000;
+/**
+ * RM-048 (D4): quanto tempo o NUMERO de uma pergunta nao respondida continua valendo depois de
+ * servido. O prazo do pedido e de uma hora; o numero que o dono recebeu nao pode vencer junto:
+ * respondido depois, ele vai ao pedido renovado quando a pergunta e a mesma.
+ */
+exports.GUARDA_DA_PERGUNTA_MS = 24 * 60 * 60 * 1000;
+/** O maior numero que a gramatica do ingresso le (dois digitos). */
+const MAIOR_NUMERO = 99;
 const sha = (s) => (0, node_crypto_1.createHash)('sha256').update(s).digest('hex');
 function arquivoDoLoteServido(raiz, estadoDir) {
     return path.join(estadoDir ?? path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'monitor'), 'pulse-lote.json');
@@ -145,16 +194,39 @@ function gravarLoteServido(raiz, lote, estadoDir) {
 function perguntaViva(p, quando) {
     return !p.respondida && (p.prazo === null || Date.parse(quando) < Date.parse(p.prazo));
 }
+/**
+ * RM-048 (D4): a pergunta que o dono ainda pode responder pelo numero. Sem resposta e dentro da
+ * guarda de 24 h desde que saiu: depois do prazo do pedido ela vai ao pedido renovado.
+ */
+function perguntaEmAberto(p, quando) {
+    return !p.respondida && (perguntaViva(p, quando) || Date.parse(quando) - Date.parse(p.servidaEm) < exports.GUARDA_DA_PERGUNTA_MS);
+}
 /** O que sai do registro: vencida sem resposta, ou respondida ha mais de um dia. */
 function podar(lote, quando) {
     const agora = Date.parse(quando);
     const perguntas = lote.perguntas.filter(p => perguntaViva(p, quando) ||
+        (!p.respondida && agora - Date.parse(p.servidaEm) < exports.GUARDA_DA_PERGUNTA_MS) ||
         (p.respondida && agora - Date.parse(p.respondida.em) < GUARDA_DO_RESPONDIDO_MS));
     const numeros = new Set(perguntas.map(p => p.numero));
     const porCodigo = Object.fromEntries(Object.entries(lote.porCodigo)
         .map(([codigo, ns]) => [codigo, ns.filter(n => numeros.has(n))]).filter(([, ns]) => ns.length));
     return { ...lote, perguntas, porCodigo };
 }
+/**
+ * O primeiro numero do proximo lote. Continua os do registro, para "1a" nunca querer dizer duas
+ * perguntas; quando passaria de 99, que a gramatica nao le, volta ao menor bloco livre.
+ */
+function numeroInicialLivre(servido) {
+    const usados = new Set(servido.perguntas.map(p => p.numero));
+    const seguinte = Math.max(0, ...usados) + 1;
+    if (seguinte + hitl_lote_1.TETO_DE_PERGUNTAS_POR_LOTE - 1 <= MAIOR_NUMERO)
+        return seguinte;
+    for (let n = 1; n + hitl_lote_1.TETO_DE_PERGUNTAS_POR_LOTE - 1 <= MAIOR_NUMERO; n++) {
+        if (Array.from({ length: hitl_lote_1.TETO_DE_PERGUNTAS_POR_LOTE }, (_, i) => n + i).every(k => !usados.has(k)))
+            return n;
+    }
+    return 1;
+}
 /** Threads com pergunta servida esperando resposta: elas nao entram de novo no resumo. */
 function threadsComPerguntaViva(raiz, quando, estadoDir) {
     return new Set(lerLoteServido(raiz, estadoDir).perguntas.filter(p => perguntaViva(p, quando)).map(p => p.thread));
@@ -189,7 +261,9 @@ function avaliarFila(raiz, itens, quando, opcoes = {}) {
     const candidatos = [], atos = new Map();
     let consertos = 0;
     for (const [thread, doThread] of porThread) {
-        const escalacoes = doThread.map(i => i.motivo).filter(m => hitl_gates_1.MOTIVOS_DE_ESCALACAO_HUMANA.includes(m));
+        // RM-048 (D6): escalacao tecnica nao vira pergunta ao dono; o resumo a mostra como "Conosco".
+        const escalacoes = doThread.map(i => i.motivo).filter(m => hitl_gates_1.MOTIVOS_DE_ESCALACAO_HUMANA.includes(m) &&
+            (0, hitl_classificacao_1.quemDecide)(m) === 'dono');
         let achado;
         for (const motivo of [...new Set([...escalacoes, 'human.pending'])]) {
             try {
@@ -214,7 +288,7 @@ function avaliarFila(raiz, itens, quando, opcoes = {}) {
         // Sem gate que espere, um pedido aberto ainda e pergunta se for respondivel agora; senao, e
         // conserto quando o formato e o problema, e historia quando o prazo ja passou.
         const pedido = doThread.map(i => i.pedido).find((p) => !!p);
-        if (!pedido)
+        if (!pedido || (0, hitl_classificacao_1.quemDecide)((0, hitl_contract_1.motivoDoPedido)(pedido)) !== 'dono')
             continue;
         let aberto = false;
         try {
@@ -261,7 +335,7 @@ function servirLote(raiz, entrada) {
     const { quando } = entrada;
     let servido = podar(lerLoteServido(raiz, entrada.estadoDir), quando);
     const vivas = new Set(servido.perguntas.filter(p => perguntaViva(p, quando)).map(p => p.thread));
-    const inicio = servido.perguntas.reduce((max, p) => Math.max(max, p.numero), 0) + 1;
+    const inicio = numeroInicialLivre(servido);
     const abertos = [];
     // Thread ocupada agora (despacho ou outra resposta segurando o lock) nao e thread que deixou de
     // esperar: ela vai para o proximo lote, e nao some do que o dono pediu.
@@ -289,12 +363,25 @@ function servirLote(raiz, entrada) {
     }
     const lote = (0, hitl_lote_1.montarLote)(abertos.map(a => a.pedido), { numeroInicial: inicio });
     const restantes = [...ocupadas, ...candidatos.slice(i)];
+    // RM-048 (D1): "desde" sai do ledger, do primeiro pedido com o mesmo codigo; renovar nao zera.
+    for (const p of lote.perguntas) {
+        const pedido = abertos.find(a => a.pedido.id === p.pedidoId).pedido;
+        try {
+            p.desde = (0, hitl_curto_1.desdeDoPedido)((0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, pedido.thread)), pedido);
+        }
+        catch {
+            p.desde = pedido.criadoEm;
+        }
+    }
     const novas = lote.perguntas.map(p => {
         const pedido = abertos.find(a => a.pedido.id === p.pedidoId).pedido;
+        const recomendada = p.alternativas.find(a => a.recomendada);
         return {
             numero: p.numero, thread: pedido.thread, fase: pedido.fase, pedidoId: pedido.id,
             pedidoSha256: sha(JSON.stringify(pedido)), letras: p.alternativas.map(a => a.letra),
             alternativas: p.alternativas.map(a => a.texto), consequencias: p.alternativas.map(a => a.consequencia),
+            ...(recomendada ? { recomendada: { letra: recomendada.letra, porque: recomendada.recomendada.porque } } : {}),
+            ...(p.corpo ? { corpo: p.corpo } : {}), ...(p.ato ? { ato: p.ato } : {}), desde: p.desde ?? null,
             pergunta: p.pergunta, prazo: (0, hitl_contract_1.prazoDoPedido)(pedido) ?? null, servidaEm: quando,
         };
     });
@@ -308,7 +395,7 @@ function servirLote(raiz, entrada) {
         quando, resumoSha256: entrada.pedido.resumoSha256, candidatos: restantes,
         prazoMin: pulse_consentimento_1.PRAZO_PADRAO_MIN, estadoDir: entrada.estadoDir,
     }) : undefined;
-    const texto = (0, hitl_lote_1.textoDoLote)(lote, { canal: entrada.canal, naoEsperam,
+    const texto = (0, hitl_lote_1.textoDoLote)(lote, { canal: entrada.canal, naoEsperam, quando,
         ...(proximo ? { proximo: { codigo: proximo.codigo, faltam: restantes.length } } : {}) });
     return { texto, numeros, restantes, naoEsperam, ...(proximo ? { proximo } : {}) };
 }
@@ -316,21 +403,514 @@ function servirLote(raiz, entrada) {
  * O lote de um sim ja servido, para quem pede de novo, ou o aviso de que ele ja nao serve. Reenviar
  * pergunta morta (toda respondida ou vencida) seria pedir uma resposta que o gate vai recusar.
  */
-function loteDeNovo(servido, numeros, codigo, quando, canal, aberto) {
-    const vivas = servido.perguntas.filter(p => numeros.includes(p.numero) && perguntaViva(p, quando)).map(p => p.numero);
+function loteDeNovo(raiz, servido, numeros, codigo, quando, canal, aberto) {
+    const vivas = servido.perguntas.filter(p => numeros.includes(p.numero) && perguntaEmAberto(p, quando)).map(p => p.numero);
     if (vivas.length)
-        return reenviarLote(servido, vivas, canal);
+        return reenviarLote(raiz, servido, vivas, canal, quando);
     return `As perguntas do código ${codigo} já foram respondidas ou venceram. ` +
         (aberto ? `Para as de agora, responda ${aberto.codigo} a.` : 'O próximo resumo traz as que ainda esperarem você.');
 }
 /** O MESMO lote de novo, para quem repete o sim porque nao viu a mensagem chegar. */
-function reenviarLote(servido, numeros, canal) {
-    const perguntas = servido.perguntas.filter(p => numeros.includes(p.numero)).map(p => ({
-        numero: p.numero, thread: p.thread, fase: p.fase, pergunta: p.pergunta, pedidoId: p.pedidoId,
-        alternativas: p.letras.map((letra, i) => ({ letra: letra, texto: p.alternativas[i],
-            consequencia: p.consequencias[i] })),
-    }));
-    return (0, hitl_lote_1.textoDoLote)({ contrato: 'ork.hitl-lote/v1', perguntas, restantes: 0, recusadas: [], abertas: 0 }, { canal });
+function reenviarLote(raiz, servido, numeros, canal, quando) {
+    const semRecomendada = [];
+    const perguntas = servido.perguntas.filter(p => numeros.includes(p.numero)).flatMap(p => {
+        // Registro gravado antes do RM-048 nao tem a recomendada: ela sai de novo do pedido servido.
+        // Sem ela, a pergunta nao e reenviada no contrato curto (que exige uma recomendada), e o
+        // nucleo nunca inventa uma: o dono recebe a linha para responder pelo numero.
+        const recomendada = p.recomendada ?? recomendadaDoRegistro(raiz, p);
+        if (!recomendada) {
+            semRecomendada.push(p.numero);
+            return [];
+        }
+        return [{
+                numero: p.numero, thread: p.thread, fase: p.fase, pergunta: p.pergunta, pedidoId: p.pedidoId,
+                ...(p.corpo ? { corpo: p.corpo } : {}), ...(p.ato ? { ato: p.ato } : {}), desde: p.desde ?? null,
+                alternativas: p.letras.map((letra, i) => ({ letra: letra, texto: p.alternativas[i],
+                    consequencia: p.consequencias[i], ...(recomendada?.letra === letra ? { recomendada: { porque: recomendada.porque } } : {}) })),
+            }];
+    });
+    const aviso = semRecomendada.length
+        ? [`Pergunta${semRecomendada.length === 1 ? '' : 's'} ${semRecomendada.join(', ')}: responda pelo número e a letra, por exemplo ${semRecomendada[0]}a.`] : [];
+    if (!perguntas.length)
+        return aviso.join('\n') || 'Nenhuma pergunta para reenviar agora.';
+    return [(0, hitl_lote_1.textoDoLote)({ contrato: 'ork.hitl-lote/v1', perguntas, restantes: 0, recusadas: [], abertas: 0 }, { canal, quando }), ...aviso].join('\n');
+}
+/** A recomendada de uma pergunta servida, relida do pedido exato que saiu com o numero. */
+function recomendadaDoRegistro(raiz, p) {
+    try {
+        const evento = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, p.thread))
+            .find(e => e.tipo === 'hitl_requested' && e.pedido?.id === p.pedidoId);
+        const pergunta = (0, hitl_lote_1.perguntaDoPedido)(evento.pedido, p.numero);
+        if ('motivo' in pergunta)
+            return undefined;
+        const r = pergunta.alternativas.find(a => a.recomendada);
+        return r ? { letra: r.letra, porque: r.recomendada.porque } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+// ---------------------------------------------------------------------------
+// RM-048 (D4): a linha que o dono recebeu vale enquanto o gate esperar a mesma pergunta.
+// ---------------------------------------------------------------------------
+/**
+ * O pedido que recebe a resposta: o proprio, quando ainda esta aberto ou ja foi respondido (ai o
+ * caminho de sempre diz "repetida" ou "divergente"), ou o renovado, quando venceu sem resposta.
+ */
+function pedidoParaResponder(raiz, pedido, quando) {
+    const respondido = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, pedido.thread))
+        .some(e => ['human_gate', 'session_answered'].includes(e.tipo) && e.pedidoId === pedido.id);
+    if (respondido || (0, hitl_contract_1.estadoDoPedido)(pedido, quando) === 'aberto')
+        return { vigente: pedido };
+    return { vigente: (0, hitl_gates_1.renovarPedidoDoGate)(raiz, pedido, quando), renovadoDe: pedido.id };
+}
+/**
+ * As threads abertas cujo ultimo pedido de gate com este codigo existe. Codigo que casa com mais
+ * de uma thread e devolvido inteiro: quem chama pergunta de volta, nunca escolhe (R3).
+ */
+function pedidosComCodigo(raiz, codigo) {
+    const alvo = codigo.trim().toUpperCase(), achados = [];
+    for (const id of (0, thread_1.listarIds)(raiz)) {
+        try {
+            if ((0, thread_1.lerThread)(raiz, id).status === 'fechada')
+                continue;
+            const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, id));
+            const ultimo = eventos.filter(e => e.tipo === 'hitl_requested').map(e => e.pedido)
+                .filter(q => (0, hitl_contract_1.ehV2)(q) && q.classe === 'pergunta' && q.alvo.tipo === 'gate' && String(q.codigo).toUpperCase() === alvo).at(-1);
+            if (ultimo)
+                achados.push({ thread: id, pedido: ultimo, eventos });
+        }
+        catch { /* thread ilegivel nao responde por codigo */ }
+    }
+    return achados;
+}
+/** A1 do CHECK: os codigos curtos em uso agora (gates abertos e o resumo), para a nota nao repetir. */
+function codigosEmUso(raiz, estadoDir) {
+    const codigos = [];
+    const estado = (() => { try {
+        return (0, pulse_consentimento_1.lerConsentimento)(raiz, estadoDir);
+    }
+    catch {
+        return undefined;
+    } })();
+    if (estado)
+        codigos.push(estado.pedido.codigo);
+    for (const id of (0, thread_1.listarIds)(raiz)) {
+        try {
+            if ((0, thread_1.lerThread)(raiz, id).status === 'fechada')
+                continue;
+            for (const e of (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, id))) {
+                const c = e.pedido?.codigo;
+                if (e.tipo === 'hitl_requested' && typeof c === 'string')
+                    codigos.push(c);
+            }
+        }
+        catch { /* thread ilegivel nao contribui */ }
+    }
+    return codigos;
+}
+/** O bloco de evidencia a um pedido de distancia (item 4): artefato, claims, riscos e diff. */
+function textoDoDetalhe(raiz, pedido, chave, canal) {
+    const a = (0, hitl_presentation_1.apresentarHitl)(raiz, pedido.thread, pedido.profundidade);
+    const tg = canal === 'telegram';
+    return [
+        `${tg ? '🔎 ' : ''}Evidências de ${chave} (${pedido.thread} · ${pedido.fase})`,
+        ...(a.artefato ? ['', 'Artefato:', a.artefato] : []),
+        '', 'Claims:', a.claims, '', 'Riscos:', a.riscos,
+        ...(a.diff ? ['', 'Diff:', a.diff] : []),
+    ].join('\n').slice(0, hitl_lote_1.TETO_DA_MENSAGEM);
+}
+/** As alternativas reais em uma linha, para devolver a pergunta sem chutar veredito. */
+function opcoesReais(pedido, prefixo) {
+    return (0, hitl_contract_1.escolhasDoPedido)(pedido).map(o => `${prefixo}${(0, hitl_contract_1.chaveDaEscolha)(pedido, o.numero)} (${o.texto})`).join(', ');
+}
+/**
+ * "DE6H a": a resposta a um gate pelo codigo curto que o dono recebeu, sem numero de lote e sem
+ * identificador longo. A prova e a do endereco do pulse, a mesma do lote: o codigo esta DENTRO do
+ * texto assinado, e o rastro grava o que o nucleo traduziu. Devolve `undefined` quando nenhum gate
+ * aberto usa o codigo, para o chamador dizer isso com as palavras dele.
+ */
+function responderPorCodigoDeGate(raiz, envelope, codigo, opcoes) {
+    const { quando, canal } = opcoes, tg = canal === 'telegram';
+    const achados = pedidosComCodigo(raiz, codigo);
+    if (!achados.length)
+        return undefined;
+    if (achados.length > 1) {
+        return resultado('codigo', `O código ${codigo} está em ${achados.length} threads (${achados.map(a => a.thread).join(', ')}). ` +
+            'Responda pelo número da pergunta no lote, por exemplo 1a.', { recusas: [{ motivo: 'codigo.ambiguo' }] });
+    }
+    const { thread, pedido, eventos } = achados[0];
+    // A3 do CHECK: a MESMA mensagem entregue de novo pelo gateway e repetida, nunca renova nem grava.
+    const mesma = eventos.find(e => e.tipo === 'human_gate' && e.mensagem === envelope.mensagem);
+    if (mesma) {
+        return resultado('codigo', `${codigo}: esta mensagem já estava registrada (${String(mesma.estado)}).`, { repetida: true, registradas: [{ numero: 0, thread, letra: '', estado: String(mesma.estado), repetida: true }] });
+    }
+    const resto = envelope.resposta.trim().slice(codigo.length).trim();
+    if (/^(detalhes?|evid[eê]ncias?|\?)[.!]?$/i.test(resto))
+        return resultado('codigo', textoDoDetalhe(raiz, pedido, codigo, canal));
+    const anterior = eventos.find(e => e.tipo === 'human_gate' && e.pedidoId === pedido.id);
+    if (anterior && anterior.estado !== 'aguardando') {
+        return resultado('codigo', `${tg ? '⚠️ ' : '! '}${codigo} já foi respondido (${String(anterior.estado)}) às ` +
+            `${(0, horario_1.formatarHora)(anterior.ts, { agora: quando })}; a resposta não muda.`, { recusas: [{ motivo: 'ja-respondido' }] });
+    }
+    const trecho = (0, hitl_texto_livre_1.lerTrecho)(resto);
+    const r = trecho ? (0, hitl_texto_livre_1.resolverTrecho)(trecho, (0, hitl_contract_1.escolhasDoPedido)(pedido).map(o => o.acao), (0, hitl_contract_1.escolhasDoPedido)(pedido).map(o => (0, hitl_contract_1.chaveDaEscolha)(pedido, o.numero)))
+        : { tipo: 'nenhuma' };
+    if (r.tipo === 'detalhe')
+        return resultado('codigo', textoDoDetalhe(raiz, pedido, codigo, canal));
+    if (r.tipo !== 'escolha') {
+        return resultado('codigo', `${r.tipo === 'ambigua' ? `"${resto.slice(0, 40)}" serve para mais de uma alternativa de ${codigo}` : `Não entendi "${resto.slice(0, 40)}" para ${codigo}`}; ` +
+            `nada foi registrado. Responda com uma destas: ${opcoesReais(pedido, `${codigo} `)}.`, { recusas: [{ motivo: r.tipo === 'ambigua' ? 'ambigua' : 'nao-entendida' }] });
+    }
+    // D2: com mais de um pedido aberto na mesma thread, palavra nao registra; letra continua.
+    if (trecho.tipo === 'intencao') {
+        const abertos = pedidosAbertosDaThread(raiz, thread, quando);
+        if (abertos > 1) {
+            return resultado('codigo', `A thread de ${codigo} tem ${abertos} pedidos abertos; resposta por palavra não registra. ` +
+                `Responda com a letra: ${opcoesReais(pedido, `${codigo} `)}.`, { recusas: [{ motivo: 'varios-pedidos-na-thread' }] });
+        }
+    }
+    return registrarPorCodigo(raiz, envelope, { thread, pedido, codigo, indice: r.indice, quando, canal,
+        rastroExtra: trecho.tipo === 'intencao' ? { textoLivre: trecho.palavra } : {} });
+}
+/** Registra a escolha num pedido achado pelo codigo, renovando-o se venceu. Nao escolhe nada. */
+function registrarPorCodigo(raiz, envelope, e) {
+    const tg = e.canal === 'telegram';
+    let vigente, renovadoDe;
+    try {
+        const anterior = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, e.thread)).find(x => x.tipo === 'human_gate' && x.pedidoId === e.pedido.id);
+        // Respondido com "continuar esperando", o gate ainda espera: a nova resposta vai ao renovado.
+        ({ vigente, renovadoDe } = anterior && anterior.estado === 'aguardando'
+            ? { vigente: (0, hitl_gates_1.renovarPedidoDoGate)(raiz, e.pedido, e.quando), renovadoDe: e.pedido.id }
+            : pedidoParaResponder(raiz, e.pedido, e.quando));
+    }
+    catch (erro) {
+        const m = erro.message;
+        if (m.includes('a pergunta mudou')) {
+            // A pergunta de agora e outra, com outro codigo: ela e aberta e mostrada, nunca respondida.
+            try {
+                const agora = (0, hitl_gates_1.abrirPedidoGate)(raiz, e.thread, (0, hitl_contract_1.motivoDoPedido)(e.pedido), e.quando);
+                const novo = agora.codigo;
+                const texto = typeof novo === 'string' ? (0, hitl_curto_1.textoDoPedidoCurto)((0, hitl_curto_1.montarPedidoCurto)((0, hitl_curto_1.entradaDoPedido)(agora), { quando: e.quando, responder: { tipo: 'codigo', codigo: novo } }), e.canal) : '';
+                return resultado('codigo', [`${tg ? '⚠️ ' : '! '}A pergunta de ${e.codigo} mudou desde que saiu; nada foi registrado. A de agora:`, '', texto].join('\n'), { recusas: [{ motivo: 'pergunta-mudou' }] });
+            }
+            catch { /* cai na frase de baixo */ }
+        }
+        return resultado('codigo', m.includes('o gate já foi respondido')
+            ? `${tg ? '⚠️ ' : '! '}${e.codigo} já foi respondido por outra linha; a resposta não muda.`
+            : `${tg ? '⚠️ ' : '! '}${e.codigo} já não espera você: a fase mudou desde que a pergunta saiu. Nada foi registrado.`, { recusas: [{ motivo: 'pedido-antigo' }] });
+    }
+    const chave = (0, hitl_contract_1.chaveDaEscolha)(vigente, e.indice + 1);
+    const derivada = { ...envelope, resposta: chave };
+    const assinado = { alvo: pulse_consentimento_1.ALVO_DO_PULSE, endereco: pulse_consentimento_1.ENDERECO_DA_RESPOSTA, envelope,
+        rastro: { contrato: exports.CONTRATO_RESPOSTA_DO_PULSE, codigo: e.codigo, letra: chave, respostaDoDonoSha256: sha(envelope.resposta),
+            ...(renovadoDe ? { renovadoDe } : {}), ...e.rastroExtra } };
+    try {
+        const r = (0, hitl_gates_1.responderGate)(raiz, e.thread, vigente.id, derivada, e.quando, assinado);
+        const o = (0, hitl_contract_1.escolhasDoPedido)(vigente)[e.indice];
+        const consequencia = (0, hitl_contract_1.ehV2)(vigente) && vigente.classe === 'pergunta' ? vigente.alternativas[e.indice]?.consequencia : undefined;
+        return resultado('codigo', `${tg ? '✅ ' : ''}${e.codigo} → ${chave}) ${o.texto}${consequencia ? `: ${consequencia}` : ''}.`, { registradas: [{ numero: 0, thread: e.thread, letra: chave, estado: r.estado, repetida: r.repetida }], repetida: r.repetida });
+    }
+    catch (erro) {
+        const m = erro.message;
+        const motivo = m.includes('ocupado') ? `a thread de ${e.codigo} estava ocupada; mande de novo em um minuto.`
+            : m.includes('proveniência') || m.includes('não autenticada') ? `não consegui provar a origem da resposta a tempo; mande ${e.codigo} ${chave} de novo.`
+                : m.includes('já respondido') ? `${e.codigo} já tinha resposta registrada; a resposta não muda.`
+                    : m.includes('pedido antigo') ? `${e.codigo} já não espera você: a fase mudou desde que a pergunta saiu. Nada foi registrado.`
+                        : `não consegui registrar ${e.codigo}: ${m.slice(0, 120)}`;
+        return resultado('codigo', `${tg ? '⚠️ ' : '! '}${motivo}`, { recusas: [{ motivo }] });
+    }
+}
+// ---------------------------------------------------------------------------
+// RM-048 (item 2): o texto livre, quando e inequivoco.
+// ---------------------------------------------------------------------------
+/**
+ * Quantos pedidos (gate ou sessao) estao abertos agora nesta thread: sem resposta, dentro do
+ * prazo e no contexto corrente. D2: com mais de um, palavra nao registra.
+ */
+function pedidosAbertosDaThread(raiz, thread, quando) {
+    const t = (0, thread_1.lerThread)(raiz, thread), eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, thread));
+    const contexto = (0, hitl_gates_1.contextoHitlDosEventos)(t, eventos);
+    const respondidos = new Set(eventos.filter(e => ['human_gate', 'session_answered'].includes(e.tipo)).map(e => String(e.pedidoId)));
+    const abertos = new Set();
+    for (const e of eventos) {
+        if (e.tipo !== 'hitl_requested' || e.contexto !== contexto)
+            continue;
+        const q = e.pedido;
+        try {
+            if (!(0, hitl_contract_1.alvoDoPedido)(q) || respondidos.has(q.id) || (0, hitl_contract_1.estadoDoPedido)(q, quando) !== 'aberto')
+                continue;
+            abertos.add(q.id);
+        }
+        catch { /* pedido invalido nao conta */ }
+    }
+    return abertos.size;
+}
+/** O pedido exato que saiu com o numero, relido do ledger. */
+function pedidoDaServida(raiz, p) {
+    try {
+        const evento = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, p.thread))
+            .find(e => e.tipo === 'hitl_requested' && e.pedido?.id === p.pedidoId);
+        (0, hitl_contract_1.validarPedidoHitl)(evento?.pedido);
+        return evento.pedido;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Traduz uma palavra numa letra para a pergunta servida, ou devolve por que nao da. Nunca escolhe
+ * pelo dono: ambigua, fora do vocabulario ou com mais de um pedido aberto na thread volta como
+ * pergunta, com as letras reais.
+ */
+function letraDaPalavra(raiz, p, trecho, quando) {
+    const pedido = pedidoDaServida(raiz, p);
+    if (!pedido)
+        return { recusa: `não consegui ler a pergunta ${p.numero}; responda com o número e a letra.` };
+    const acoes = (0, hitl_contract_1.escolhasDoPedido)(pedido).map(o => o.acao);
+    const r = (0, hitl_texto_livre_1.resolverTrecho)(trecho, acoes, p.letras);
+    const reais = p.letras.map((l, i) => `${p.numero}${l} (${p.alternativas[i]})`).join(', ');
+    if (r.tipo === 'detalhe')
+        return { detalhe: pedido };
+    if (r.tipo === 'ambigua')
+        return { recusa: `para a pergunta ${p.numero}, "${trecho.tipo === 'intencao' ? trecho.palavra : ''}" serve para mais de uma alternativa; mande uma: ${reais}.` };
+    if (r.tipo === 'nenhuma')
+        return { recusa: `a pergunta ${p.numero} não tem alternativa para essa resposta; mande uma destas: ${reais}.` };
+    if (trecho.tipo === 'intencao') {
+        const abertos = pedidosAbertosDaThread(raiz, p.thread, quando);
+        if (abertos > 1)
+            return { recusa: `a thread da pergunta ${p.numero} tem ${abertos} pedidos abertos; resposta por palavra não registra. Mande a letra: ${reais}.` };
+        return { letra: p.letras[r.indice], palavra: trecho.palavra };
+    }
+    return { letra: p.letras[r.indice] };
+}
+/** "1. B, 2. aprovo, 3 detalhes": cada item vira letra, detalhe ou recusa, e as letras seguem o lote. */
+function responderALista(raiz, envelope, itens, opcoes) {
+    const { quando, canal, estadoDir } = opcoes, tg = canal === 'telegram';
+    const servido = lerLoteServido(raiz, estadoDir);
+    const escolhas = [], avisos = [], detalhes = [];
+    for (const { numero, trecho } of itens) {
+        const p = servido.perguntas.find(q => q.numero === numero);
+        if (trecho.tipo === 'letra' || !p) {
+            escolhas.push({ numero, letra: trecho.tipo === 'letra' ? trecho.letra : '?' });
+            continue;
+        }
+        const r = letraDaPalavra(raiz, p, trecho, quando);
+        if ('detalhe' in r)
+            detalhes.push(textoDoDetalhe(raiz, r.detalhe, String(numero), canal));
+        else if ('recusa' in r)
+            avisos.push(`${tg ? '⚠️ ' : '! '}${r.recusa}`);
+        else
+            escolhas.push({ numero, letra: r.letra, ...(r.palavra ? { palavra: r.palavra } : {}) });
+    }
+    if (!escolhas.length) {
+        return resultado('lote', [...avisos, ...detalhes].join('\n\n') || 'Nada para registrar.', { recusas: avisos.map(motivo => ({ motivo })) });
+    }
+    const r = responderAsPerguntas(raiz, envelope, escolhas, { quando, canal, estadoDir, avisos });
+    return detalhes.length ? { ...r, mensagem: [r.mensagem, ...detalhes].join('\n\n').slice(0, hitl_lote_1.TETO_DA_MENSAGEM) } : r;
+}
+function abertosDoDono(raiz, quando, estadoDir) {
+    const janela = hitl_texto_livre_1.JANELA_DO_TEXTO_LIVRE_MIN * 60000, agora = Date.parse(quando);
+    const abertos = [];
+    const estado = (0, pulse_consentimento_1.lerConsentimento)(raiz, estadoDir);
+    if (estado && !estado.respondido && estado.pedido.candidatos.length) {
+        abertos.push({ tipo: 'consentimento', codigo: estado.pedido.codigo, rotulo: `${estado.pedido.codigo} a (receber as perguntas)`,
+            recente: agora - Date.parse(estado.pedido.criadoEm) < janela });
+    }
+    // A mesma pergunta (mesma thread e mesmo alvo) conta uma vez, servida ou nao, vencida ou nao.
+    const chave = (q) => { const a = (0, hitl_contract_1.alvoDoPedido)(q); return `${q.thread}|${a?.tipo === 'session' ? `s:${a.sessionId}` : `g:${q.fase}`}`; };
+    // Os gates que o resumo aberto oferece sao o que o "sim" pede: o consentimento os representa.
+    const vistas = new Set(estado && !estado.respondido
+        ? estado.pedido.candidatos.map(c => `${c.thread}|g:${c.fase ?? ''}`) : []);
+    for (const p of lerLoteServido(raiz, estadoDir).perguntas.filter(q => perguntaEmAberto(q, quando))) {
+        const pedido = pedidoDaServida(raiz, p);
+        if (pedido)
+            vistas.add(chave(pedido));
+        abertos.push({ tipo: 'pergunta', servida: p, rotulo: `${p.numero} com a letra (${[p.thread, p.fase].filter(Boolean).join(' · ')})`,
+            recente: agora - Date.parse(p.servidaEm) < janela });
+    }
+    for (const id of (0, thread_1.listarIds)(raiz)) {
+        try {
+            const t = (0, thread_1.lerThread)(raiz, id);
+            if (t.status === 'fechada')
+                continue;
+            const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, id));
+            const contexto = (0, hitl_gates_1.contextoHitlDosEventos)(t, eventos);
+            const respondidos = new Set(eventos.filter(e => ['human_gate', 'session_answered'].includes(e.tipo)).map(e => String(e.pedidoId)));
+            for (const e of eventos) {
+                if (e.tipo !== 'hitl_requested' || e.contexto !== contexto)
+                    continue;
+                const q = e.pedido;
+                try {
+                    if (!(0, hitl_contract_1.alvoDoPedido)(q) || respondidos.has(q.id) || (0, hitl_contract_1.estadoDoPedido)(q, quando) !== 'aberto' || (0, hitl_classificacao_1.quemDecide)((0, hitl_contract_1.motivoDoPedido)(q)) !== 'dono')
+                        continue;
+                }
+                catch {
+                    continue;
+                }
+                if (vistas.has(chave(q)))
+                    continue;
+                vistas.add(chave(q));
+                const codigo = (0, hitl_contract_1.ehV2)(q) && q.classe === 'pergunta' ? q.codigo : undefined;
+                abertos.push({ tipo: 'pedido', recente: false, ...(codigo ? { codigo } : {}),
+                    rotulo: codigo ? `${codigo} a (${q.thread} · ${q.fase})` : `${q.thread} · ${q.fase}` });
+            }
+            // Segunda passada do CHECK: o gate cujo pedido venceu continua esperando o dono, e a linha
+            // dele ("DE6H a") nao vence (D4). Ele conta mesmo sem pedido aberto agora.
+            const gate = `${id}|g:${t.faseAtual}`;
+            if (!vistas.has(gate)) {
+                const espera = (0, roadmap_status_1.esperaDoDono)(raiz, t, quando);
+                if (espera && !abertos.some(a => a.servida?.thread === id)) {
+                    vistas.add(gate);
+                    abertos.push({ tipo: 'pedido', recente: false, ...(espera.codigo ? { codigo: espera.codigo } : {}),
+                        rotulo: espera.codigo ? `${espera.codigo} a (${id} · ${t.faseAtual})` : `${id} · ${t.faseAtual}` });
+                }
+            }
+        }
+        catch { /* thread ilegivel nao entra na conta; a palavra solta so fica mais cautelosa */ }
+    }
+    return abertos;
+}
+/**
+ * "aprovo", "sim", "a", "1": a palavra solta. Registra quando ha UMA pergunta recente e ela nao e
+ * sem volta; senao devolve a pergunta com as opcoes reais. A prova ja foi conferida por quem chama.
+ */
+function responderLivre(raiz, envelope, trecho, opcoes) {
+    const { quando, canal, estadoDir } = opcoes, tg = canal === 'telegram';
+    const abertos = abertosDoDono(raiz, quando, estadoDir);
+    const volta = (mensagem, motivo) => resultado('nao-entendida', mensagem, { recusas: [{ motivo }] });
+    if (!abertos.length) {
+        return volta('Não há pergunta aberta para responder só com uma palavra; nada foi registrado. ' +
+            'Responda com o número e a letra (por exemplo 1a) ou com o código da pergunta (por exemplo DE6H a).', 'sem-pergunta-recente');
+    }
+    if (abertos.length > 1) {
+        const lista = abertos.slice(0, 5).map(a => a.rotulo).join('; ') + (abertos.length > 5 ? `; e mais ${abertos.length - 5}` : '');
+        return volta(`Há ${abertos.length} perguntas esperando você, e uma palavra só não diz qual; nada foi registrado. ` +
+            `Responda pelo número ou pelo código: ${lista}.`, 'varias-perguntas');
+    }
+    const [unico] = abertos;
+    if (!unico.recente) {
+        return volta(`A pergunta que espera você não acabou de sair por aqui; palavra solta não registra. Responda: ${unico.rotulo}.`, 'sem-pergunta-recente');
+    }
+    if (unico.tipo === 'consentimento') {
+        // O resumo pergunta sim ou nao: a palavra vira a letra, e o caminho e o do codigo, com a prova de sempre.
+        return responderAoResumo(raiz, envelope, unico.codigo, { quando, canal, estadoDir, palavra: trecho });
+    }
+    const p = unico.servida;
+    const pedido = pedidoDaServida(raiz, p);
+    if (pedido && (0, hitl_contract_1.ehV2)(pedido) && pedido.classe === 'pergunta' && pedido.irreversivel) {
+        return volta(`${tg ? '🔒 ' : '! '}A pergunta ${p.numero} é sem volta; palavra solta não registra. Responda com o número e a letra: ` +
+            `${p.letras.map((l, i) => `${p.numero}${l} (${p.alternativas[i]})`).join(', ')}.`, 'irreversivel');
+    }
+    // D2: a resposta solta nao diz a qual pedido se refere; com mais de um aberto na thread, nem
+    // letra nem digito soltos registram. Numerados ("1a") e por codigo ("DE6H a") continuam valendo.
+    const naThread = pedidosAbertosDaThread(raiz, p.thread, quando);
+    if (naThread > 1) {
+        return volta(`${tg ? '⚠️ ' : '! '}a thread da pergunta ${p.numero} tem ${naThread} pedidos abertos; resposta solta não registra. ` +
+            `Mande o número e a letra: ${p.letras.map((l, i) => `${p.numero}${l} (${p.alternativas[i]})`).join(', ')}.`, 'varios-pedidos-na-thread');
+    }
+    const r = letraDaPalavra(raiz, p, trecho, quando);
+    if ('detalhe' in r)
+        return resultado('lote', textoDoDetalhe(raiz, r.detalhe, String(p.numero), canal));
+    if ('recusa' in r)
+        return volta(`${tg ? '⚠️ ' : '! '}${r.recusa}`, 'nao-registrou');
+    return responderAsPerguntas(raiz, envelope, [{ numero: p.numero, letra: r.letra, palavra: r.palavra ?? normalizarTrecho(trecho) }], { quando, canal, estadoDir });
+}
+const normalizarTrecho = (t) => t.tipo === 'letra' ? t.letra : t.tipo === 'digito' ? String(t.numero) : t.palavra;
+exports.CONTRATO_ESCUTA = 'ork.pulse-escuta/v1';
+function arquivoDaEscuta(raiz, estadoDir) {
+    return path.join(estadoDir ?? path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'monitor'), 'pulse-escuta.json');
+}
+/**
+ * D3: a janela da palavra solta, para o adaptador decidir a ROTA de "sim", "ok", "a". Nao e prova:
+ * a mensagem interceptada ainda passa pela assinatura do ingresso e por esta mesma regra no nucleo.
+ * Janela fechada (ou arquivo ausente), a palavra vai ao assistente, como sempre foi.
+ */
+function atualizarEscuta(raiz, quando, estadoDir) {
+    const janela = hitl_texto_livre_1.JANELA_DO_TEXTO_LIVRE_MIN * 60000;
+    const limites = [];
+    const estado = (0, pulse_consentimento_1.lerConsentimento)(raiz, estadoDir);
+    if (estado && !estado.respondido && estado.pedido.candidatos.length)
+        limites.push(Date.parse(estado.pedido.criadoEm) + janela);
+    for (const p of lerLoteServido(raiz, estadoDir).perguntas)
+        if (perguntaEmAberto(p, quando))
+            limites.push(Date.parse(p.servidaEm) + janela);
+    const ate = limites.filter(l => l > Date.parse(quando)).sort((a, b) => b - a)[0];
+    const escuta = { contrato: exports.CONTRATO_ESCUTA, livreAte: ate ? new Date(ate).toISOString() : null, atualizadoEm: quando };
+    const arquivo = arquivoDaEscuta(raiz, estadoDir);
+    fs.mkdirSync(path.dirname(arquivo), { recursive: true });
+    const tmp = `${arquivo}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(escuta) + '\n', { mode: 0o600 });
+    fs.renameSync(tmp, arquivo);
+    return { livreAte: escuta.livreAte };
+}
+// ---------------------------------------------------------------------------
+// RM-048 (item 8): a nota do MASTER e a ratificacao, pelo mesmo endereco assinado.
+// ---------------------------------------------------------------------------
+/**
+ * "K7QX 4 entregou o que pedi": a nota vai ao ledger com `por` = o remetente autenticado e com o
+ * recibo do canal. Quem chama ja conferiu a prova; aqui so se le o conteudo. Nota humana que ja
+ * existe nao e trocada por este caminho; a aceita por omissao e, porque a nota do dono sobrescreve.
+ */
+function responderNota(raiz, envelope, p, opcoes) {
+    const tg = opcoes.canal === 'telegram';
+    const nota = (0, master_nota_1.lerNota)(envelope.resposta.trim().slice(p.codigo.length));
+    if (!nota) {
+        return resultado('nota', `Para dar a nota de ${p.thread}, responda ${p.codigo} <0 a 5> <porquê>, por exemplo: ` +
+            `${p.codigo} 4 entregou o que pedi. Nada foi registrado.`, { recusas: [{ motivo: 'nota.formato' }] });
+    }
+    if ((0, master_nota_1.mensagemJaUsadaEmNota)(raiz, p.thread, envelope.mensagem)) {
+        return resultado('nota', `A nota de ${p.thread} desta mensagem já estava registrada.`, { repetida: true });
+    }
+    try {
+        // A4 do CHECK: ler a nota que existe e gravar a nova sob o lock da thread, para uma nota humana
+        // dada no mesmo instante por outro caminho nao ser sobrescrita.
+        const ja = (0, hitl_gates_1.comLockHitl)(raiz, p.thread, () => {
+            const t = (0, thread_1.lerThread)(raiz, p.thread);
+            if (t.score && t.score.regime !== 'omissao' && (0, master_1.autoriaHumana)(t.score.avaliadoPor))
+                return t.score.valor;
+            const prova = (0, master_nota_1.reciboDoCanal)(raiz, envelope, { notaPedida: { contrato: master_nota_1.CONTRATO_PEDIDO_DE_NOTA, pedidoId: p.pedidoId, codigo: p.codigo },
+                enderecoAssinado: { alvo: pulse_consentimento_1.ALVO_DO_PULSE, endereco: pulse_consentimento_1.ENDERECO_DA_RESPOSTA, contrato: exports.CONTRATO_RESPOSTA_DO_PULSE, codigo: p.codigo,
+                    respostaDoDonoSha256: sha(envelope.resposta) } }, opcoes.estadoDir);
+            (0, master_1.registrarMaster)(raiz, p.thread, { score: nota.score, justificativa: nota.justificativa, por: envelope.por, refazer: !!t.score, prova });
+            return undefined;
+        });
+        if (ja !== undefined) {
+            return resultado('nota', `${tg ? '⚠️ ' : '! '}${p.thread} já tem nota humana ${ja}/5; a nota não muda por aqui.`, { recusas: [{ motivo: 'nota.ja-dada' }] });
+        }
+        return resultado('nota', `${tg ? '🧾 ' : ''}Nota ${nota.score}/5 registrada para ${p.thread}, por ${envelope.por}. ` +
+            'O índice derivado do ledger continua ao lado.', { registradas: [{ numero: 0, thread: p.thread, letra: String(nota.score), estado: 'nota', repetida: false }] });
+    }
+    catch (e) {
+        return resultado('nota', `${tg ? '⚠️ ' : '! '}não consegui registrar a nota de ${p.thread}: ${e.message.slice(0, 160)}`, { recusas: [{ motivo: 'nota.recusada' }] });
+    }
+}
+/** O teclado do digest: a ratificacao da proposta, com o remetente autenticado e o recibo. */
+function responderRatificacao(raiz, envelope, texto, opcoes) {
+    const tg = opcoes.canal === 'telegram';
+    const partes = texto.split(/\s+/);
+    const prova = () => (0, master_nota_1.reciboDoCanal)(raiz, envelope, { ratificacao: { contrato: master_nota_1.CONTRATO_PEDIDO_DE_NOTA, texto },
+        enderecoAssinado: { alvo: pulse_consentimento_1.ALVO_DO_PULSE, endereco: pulse_consentimento_1.ENDERECO_DA_RESPOSTA, contrato: exports.CONTRATO_RESPOSTA_DO_PULSE,
+            respostaDoDonoSha256: sha(envelope.resposta) } }, opcoes.estadoDir);
+    try {
+        let feitas;
+        if (partes[0].toLowerCase() === 'ratificar-lote' && partes.length === 3) {
+            feitas = (0, master_digest_1.responderLoteDigest)(raiz, ['ratificar-lote', partes[1], partes[2]].join(' '), envelope.por, prova())
+                .map(r => ({ thread: r.thread.id, score: r.masterLog.score }));
+        }
+        else {
+            const classe = (0, master_1.parseClasse)(partes[3]);
+            if (partes[0].toLowerCase() !== 'ratificar' || partes.length !== 4 || !classe) {
+                return resultado('nota', 'Para ratificar, use a linha do teclado do digest: ratificar <thread> <assinatura> <classe>.', { recusas: [{ motivo: 'ratificacao.formato' }] });
+            }
+            feitas = (0, master_batch_1.ratificarBatch)(raiz, [{ thread: partes[1], assinatura: partes[2], classe }], envelope.por, prova())
+                .map(r => ({ thread: r.thread.id, score: r.masterLog.score }));
+        }
+        return resultado('nota', `${tg ? '🧾 ' : ''}Ratificado por ${envelope.por}: ${feitas.map(f => `${f.thread} ${f.score}/5`).join(', ')}.`, { registradas: feitas.map(f => ({ numero: 0, thread: f.thread, letra: String(f.score), estado: 'nota', repetida: false })) });
+    }
+    catch (e) {
+        return resultado('nota', `${tg ? '⚠️ ' : '! '}não consegui ratificar: ${e.message.slice(0, 160)}`, { recusas: [{ motivo: 'ratificacao.recusada' }] });
+    }
 }
 const EXEMPLO = 'Responda ao resumo com o código e a letra, por exemplo: P4EJ a. Às perguntas, com o número e a letra, por exemplo: 1a 2c. ' +
     'Para trocar a cadência, mande só a tag: #OrkPulseOn, #OrkPulseOn-15m, -30m, -60m ou #OrkPulseOff.';
@@ -361,45 +941,73 @@ function responderPeloPulse(raiz, envelope, opcoes = {}) {
     }
     // A conversa do pulse tem dois escritores (a varredura e este receptor): um de cada vez.
     const estadoDir = opcoes.estadoDir ?? path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'monitor');
-    return (0, monitor_lock_1.comLockDaConversa)(estadoDir, () => lido.forma === 'lote'
-        ? responderAsPerguntas(raiz, envelope, lido.escolhas, { quando, canal, estadoDir })
-        : responderAoResumo(raiz, envelope, lido.codigo, { quando, canal, estadoDir }));
+    return (0, monitor_lock_1.comLockDaConversa)(estadoDir, () => {
+        const r = (() => {
+            try {
+                return lido.forma === 'lote' ? responderAsPerguntas(raiz, envelope, lido.escolhas, { quando, canal, estadoDir })
+                    : lido.forma === 'lista' ? responderALista(raiz, envelope, lido.itens, { quando, canal, estadoDir })
+                        : lido.forma === 'livre' ? responderLivre(raiz, envelope, lido.trecho, { quando, canal, estadoDir })
+                            : lido.forma === 'ratificacao' ? responderRatificacao(raiz, envelope, lido.texto, { canal, estadoDir })
+                                : responderAoResumo(raiz, envelope, lido.codigo, { quando, canal, estadoDir });
+            }
+            catch (e) {
+                // S3 do CHECK: estado ilegivel ou falha inesperada vira resposta util, nunca silencio nem erro cru.
+                // O detalhe fica no stderr de quem chamou (o adaptador nao o repassa): caminho local e
+                // mensagem interna nao vao ao Telegram.
+                console.error(`pulse responder: ${e.message}`);
+                return resultado('nao-entendida', 'Não consegui concluir esta resposta agora (erro interno do núcleo). ' +
+                    'Confira em ork pulse e mande de novo em um minuto.', { recusas: [{ motivo: 'erro-interno' }] });
+            }
+        })();
+        // RM-048 (D3): a janela da palavra solta acompanha o que ainda espera o dono agora.
+        try {
+            atualizarEscuta(raiz, quando, estadoDir);
+        }
+        catch { /* dica de rota; a prova nao depende dela */ }
+        return r;
+    });
 }
 function responderAoResumo(raiz, envelope, codigo, opcoes) {
     const { quando, canal, estadoDir } = opcoes;
     const estado = (0, pulse_consentimento_1.lerConsentimento)(raiz, estadoDir);
-    if (!estado)
-        return resultado('consentimento', 'Não há resumo esperando resposta agora. Quando houver pergunta para você, o resumo avisa.');
-    if (estado.pedido.codigo !== codigo) {
+    if (!estado || estado.pedido.codigo !== codigo) {
         const servido = lerLoteServido(raiz, estadoDir);
         const numeros = servido.porCodigo[codigo];
         // Sim repetido a um codigo que ja serviu lote: devolve o MESMO lote, nunca um novo.
         if (numeros?.length) {
             // O dono pediu de novo, por outra mensagem: ele recebe o mesmo lote, e nao silencio.
-            const aberto = !estado.respondido && Date.parse(quando) < Date.parse(estado.pedido.prazo) && estado.pedido.candidatos.length
-                ? estado.pedido : undefined;
-            return resultado('consentimento', loteDeNovo(servido, numeros, codigo, quando, canal, aberto), { resposta: 'sim', repetida: false });
+            // RM-048 (D5): o resumo mais recente nao vence para o sim; o codigo dele continua valendo.
+            const aberto = estado && !estado.respondido && estado.pedido.candidatos.length ? estado.pedido : undefined;
+            return resultado('consentimento', loteDeNovo(raiz, servido, numeros, codigo, quando, canal, aberto), { resposta: 'sim', repetida: false });
         }
-        return resultado('consentimento', `O código ${codigo} não é o do resumo aberto. O resumo aberto usa ${estado.pedido.codigo}: ` +
-            `responda ${estado.pedido.codigo} a para receber as perguntas.`);
+        // RM-048 (item 8): o codigo de um pedido de nota do MASTER ("K7QX 4 entregou o que pedi").
+        // A1 do CHECK: se o mesmo codigo tambem e de um gate aberto, nada e escolhido pelo dono.
+        const nota = (0, master_nota_1.pedidoDeNotaDoCodigo)(raiz, codigo, estadoDir);
+        if (nota && pedidosComCodigo(raiz, codigo).length) {
+            return resultado('codigo', `O código ${codigo} é de uma nota e de uma pergunta ao mesmo tempo; nada foi registrado. ` +
+                'Responda a pergunta pelo número do lote e peça outro código de nota (ork master pedir).', { recusas: [{ motivo: 'codigo.ambiguo' }] });
+        }
+        // RM-048 (D4): o codigo curto de um gate ("DE6H a") responde ao gate, pelo mesmo endereco assinado.
+        const peloGate = responderPorCodigoDeGate(raiz, envelope, codigo, { quando, canal });
+        if (peloGate)
+            return peloGate;
+        if (nota)
+            return responderNota(raiz, envelope, nota, { canal, estadoDir });
+        if (!estado)
+            return resultado('consentimento', `Não reconheço o código ${codigo} agora: nenhum resumo ou pergunta aberta usa ele. ` +
+                'Quando houver pergunta para você, o resumo avisa.');
+        return resultado('consentimento', `O código ${codigo} não é o do resumo aberto nem de uma pergunta aberta. O resumo aberto usa ` +
+            `${estado.pedido.codigo}: responda ${estado.pedido.codigo} a para receber as perguntas.`);
     }
     let r;
     try {
-        r = (0, pulse_consentimento_1.responderConsentimento)(raiz, { codigo, envelope, quando, estadoDir });
+        // RM-048 (D5): o sim ao resumo mais recente vale depois do prazo; o lote reconfere cada gate.
+        r = (0, pulse_consentimento_1.responderConsentimento)(raiz, { codigo, envelope, quando, estadoDir, aceitarVencido: true });
     }
     catch (e) {
         const m = e.message;
         if (!m.startsWith('consentimento do pulse: '))
             throw e;
-        if (m.includes('vencido')) {
-            // Vencido nao autoriza, e o dono nao fica sem caminho: o mesmo conjunto ganha codigo novo.
-            if (!estado.pedido.candidatos.length)
-                return resultado('consentimento', `Este resumo venceu às ${(0, horario_1.formatarHora)(estado.pedido.prazo, { agora: quando })}.`);
-            const novo = (0, pulse_consentimento_1.abrirConsentimento)(raiz, { quando, resumoSha256: estado.pedido.resumoSha256,
-                candidatos: estado.pedido.candidatos, prazoMin: pulse_consentimento_1.PRAZO_PADRAO_MIN, estadoDir });
-            return resultado('consentimento', `Este resumo venceu às ${(0, horario_1.formatarHora)(estado.pedido.prazo, { agora: quando })}. ` +
-                `Para receber as perguntas agora, responda ${novo.codigo} a.`);
-        }
         if (m.includes('divergente')) {
             const antes = estado.respondido;
             return resultado('consentimento', antes.resposta === 'sim'
@@ -417,7 +1025,7 @@ function responderAoResumo(raiz, envelope, codigo, opcoes) {
             `As ${n} perguntas continuam guardadas`}, e o próximo resumo lembra ${n === 1 ? 'dela' : 'delas'}.`, { resposta: 'nao', repetida: mesmaMensagem });
     }
     if (r.repetida && r.respondido.numeros) {
-        return resultado('consentimento', loteDeNovo(lerLoteServido(raiz, estadoDir), r.respondido.numeros, codigo, quando, canal), { resposta: 'sim', repetida: mesmaMensagem });
+        return resultado('consentimento', loteDeNovo(raiz, lerLoteServido(raiz, estadoDir), r.respondido.numeros, codigo, quando, canal), { resposta: 'sim', repetida: mesmaMensagem });
     }
     const entregue = servirLote(raiz, { pedido: r.pedido, quando, canal, estadoDir });
     marcarLoteEntregueSeAindaFor(raiz, quando, estadoDir, r.pedido.id, entregue.numeros);
@@ -438,8 +1046,15 @@ function motivoParaODono(p, letra, erro, quando) {
     const m = erro.message, n = p.numero;
     if (m.includes('expirado'))
         return `a pergunta ${n} venceu às ${(0, horario_1.formatarHora)(p.prazo, { agora: quando })}; o próximo resumo a traz de novo se ela ainda esperar você.`;
+    if (m.includes('o gate já foi respondido'))
+        return `a pergunta ${n} já foi respondida por outra linha; a resposta não muda.`;
+    if (m.includes('a pergunta mudou'))
+        return `a pergunta ${n} mudou desde que saiu; nada foi registrado, e ela volta no próximo resumo com o texto de agora.`;
     if (m.includes('pedido antigo'))
         return `a pergunta ${n} já não espera você: a fase mudou desde que ela saiu.`;
+    // RM-048 (D4): vencida, a renovacao so acontece se o gate ainda espera; senao, ela e historia.
+    if (/pausa humana nesta fase|conclusão da fase|escalação tipada não comprovada/.test(m))
+        return `a pergunta ${n} já não espera você.`;
     if (m.includes('já respondido'))
         return `a pergunta ${n} já tinha resposta registrada; a resposta não muda.`;
     if (m.includes('ocupado'))
@@ -462,7 +1077,7 @@ function responderAsPerguntas(raiz, envelope, escolhas, opcoes) {
     for (const e of escolhas)
         porNumero.set(e.numero, new Set([...(porNumero.get(e.numero) ?? []), e.letra]));
     const vistos = new Set();
-    for (const { numero, letra } of escolhas) {
+    for (const { numero, letra, palavra } of escolhas) {
         if (vistos.has(numero))
             continue;
         vistos.add(numero);
@@ -475,7 +1090,7 @@ function responderAsPerguntas(raiz, envelope, escolhas, opcoes) {
         }
         const p = servido.perguntas.find(q => q.numero === numero);
         if (!p) {
-            const abertas = servido.perguntas.filter(q => perguntaViva(q, quando)).map(q => q.numero);
+            const abertas = servido.perguntas.filter(q => perguntaEmAberto(q, quando)).map(q => q.numero);
             const motivo = `não há pergunta ${numero} ${abertas.length ? `aberta; as abertas são ${abertas.join(', ')}` : 'aberta agora'}.`;
             recusas.push({ numero, motivo });
             linhas.push(`${telegram ? '⚠️ ' : '! '}${motivo}`);
@@ -488,6 +1103,12 @@ function responderAsPerguntas(raiz, envelope, escolhas, opcoes) {
             linhas.push(`${telegram ? '⚠️ ' : '! '}${motivo}`);
             continue;
         }
+        if (!p.respondida && !perguntaEmAberto(p, quando)) {
+            const motivo = `a pergunta ${numero} saiu há mais de 24 h; ela volta no próximo resumo se ainda esperar você.`;
+            recusas.push({ numero, motivo });
+            linhas.push(`${telegram ? '⚠️ ' : '! '}${motivo}`);
+            continue;
+        }
         if (p.respondida) {
             if (p.respondida.letra === letra) {
                 // Repetida para o canal so quando e a MESMA mensagem; o dono que manda de novo e respondido.
@@ -509,10 +1130,14 @@ function responderAsPerguntas(raiz, envelope, escolhas, opcoes) {
             // O numero aponta para o pedido que saiu, byte a byte. Pedido trocado nao recebe a letra.
             if (sha(JSON.stringify(pedido)) !== p.pedidoSha256)
                 throw new Error('pedido antigo: fase, modo ou sessão mudou');
-            const derivada = { ...envelope, resposta: (0, hitl_contract_1.chaveDaEscolha)(pedido, indice + 1) };
+            // RM-048 (D4): vencido e sem resposta, o numero vai ao pedido renovado, e so quando a
+            // pergunta e o contexto sao os mesmos. Respondido, segue o caminho de sempre (repetida).
+            const { vigente, renovadoDe } = pedidoParaResponder(raiz, pedido, quando);
+            const derivada = { ...envelope, resposta: (0, hitl_contract_1.chaveDaEscolha)(vigente, indice + 1) };
             const assinado = { alvo: pulse_consentimento_1.ALVO_DO_PULSE, endereco: pulse_consentimento_1.ENDERECO_DA_RESPOSTA, envelope,
-                rastro: { contrato: exports.CONTRATO_RESPOSTA_DO_PULSE, numero, letra, respostaDoDonoSha256: sha(envelope.resposta) } };
-            const r = (0, hitl_gates_1.responderGate)(raiz, p.thread, p.pedidoId, derivada, quando, assinado);
+                rastro: { contrato: exports.CONTRATO_RESPOSTA_DO_PULSE, numero, letra, respostaDoDonoSha256: sha(envelope.resposta),
+                    ...(renovadoDe ? { renovadoDe } : {}), ...(palavra ? { textoLivre: palavra } : {}) } };
+            const r = (0, hitl_gates_1.responderGate)(raiz, p.thread, vigente.id, derivada, quando, assinado);
             registradas.push({ numero, thread: p.thread, letra, estado: r.estado, repetida: r.repetida });
             linhas.push(`${telegram ? '✅ ' : ''}${numero} → ${letra}) ${p.alternativas[indice]}: ${p.consequencias[indice]}.`);
             servido = { ...servido, perguntas: servido.perguntas.map(q => q.numero === numero
@@ -528,15 +1153,15 @@ function responderAsPerguntas(raiz, envelope, escolhas, opcoes) {
     const cabecalho = registradas.length
         ? `${telegram ? '📝 ' : ''}Orkastery, ${registradas.length === 1 ? '1 resposta registrada' : `${registradas.length} respostas registradas`}`
         : `${telegram ? '📝 ' : ''}Orkastery, nenhuma resposta registrada`;
-    const pendentes = servido.perguntas.filter(q => perguntaViva(q, quando)).map(q => q.numero);
+    const pendentes = servido.perguntas.filter(q => perguntaEmAberto(q, quando)).map(q => q.numero);
     const aberto = (0, pulse_consentimento_1.lerConsentimento)(raiz, estadoDir);
-    const proximo = aberto && !aberto.respondido && aberto.pedido.candidatos.length && Date.parse(quando) < Date.parse(aberto.pedido.prazo)
-        ? aberto.pedido : undefined;
+    // RM-048 (D5): o codigo do resumo mais recente continua valendo depois do prazo.
+    const proximo = aberto && !aberto.respondido && aberto.pedido.candidatos.length ? aberto.pedido : undefined;
     const texto = [
-        cabecalho, '', ...linhas,
+        cabecalho, '', ...(opcoes.avisos ?? []), ...linhas,
         ...(pendentes.length ? ['', `Ainda sem resposta: ${pendentes.join(', ')}.`] : []),
         ...(proximo ? [`Faltam ${proximo.candidatos.length}. Para receber as próximas, responda ${proximo.codigo} a.`] : []),
     ].join('\n');
-    return resultado('lote', texto, { registradas, recusas,
+    return resultado('lote', texto, { registradas, recusas: [...(opcoes.avisos ?? []).map(motivo => ({ motivo })), ...recusas],
         repetida: registradas.length > 0 && recusas.length === 0 && registradas.every(r => r.repetida) });
 }