@orkastery/cli 0.5.3 → 0.6.0

package/dist/pulse-resposta.js

@@ -43,6 +43,9 @@ exports.threadsComPerguntaViva = threadsComPerguntaViva;
 exports.gatesJaServidos = gatesJaServidos;
 exports.avaliarFila = avaliarFila;
 exports.servirLote = servirLote;
+exports.chatDoTelegram = chatDoTelegram;
+exports.servirPerguntaDoArco = servirPerguntaDoArco;
+exports.restoDoCodigo = restoDoCodigo;
 exports.pedidoParaResponder = pedidoParaResponder;
 exports.pedidosComCodigo = pedidosComCodigo;
 exports.codigosEmUso = codigosEmUso;
@@ -83,6 +86,7 @@ const horario_1 = require("./horario");
 const hitl_gates_1 = require("./hitl-gates");
 const hitl_contract_1 = require("./hitl-contract");
 const monitor_lock_1 = require("./monitor-lock");
+const hitl_1 = require("./hitl");
 const hitl_lote_1 = require("./hitl-lote");
 const hitl_curto_1 = require("./hitl-curto");
 const hitl_texto_livre_1 = require("./hitl-texto-livre");
@@ -97,6 +101,9 @@ const pulse_cadencia_1 = require("./pulse-cadencia");
 const ledger_1 = require("./ledger");
 const thread_1 = require("./thread");
 const pulse_consentimento_1 = require("./pulse-consentimento");
+const noctum_arco_1 = require("./noctum-arco");
+const noctum_pergunta_1 = require("./noctum-pergunta");
+const noctum_resposta_1 = require("./noctum-resposta");
 exports.CONTRATO_RESPOSTA_DO_PULSE = 'ork.pulse-resposta/v1';
 exports.CONTRATO_LOTE_SERVIDO = 'ork.pulse-lote-servido/v1';
 /**
@@ -126,11 +133,21 @@ exports.GRAMATICA_DO_PULSE = Object.freeze({
     // 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]*$',
+    // RM-063 (fatia 3, H2): os comandos de conducao do canal, sozinhos na mensagem: `#OrkRetomar` roda a batida da
+    // conducao e responde o que voltou a andar; `#OrkFabrica` responde o `ork fabrica`. Comecam por `#`, como a cadencia.
+    conducao: '^[ \\t]*#Ork(?:Retomar|Fabrica)[ \\t]*[.!]?[ \\t]*$',
+    // RM-057 (resposta curta, D3 da ork-rm057respost; GO-FIX 1, achado 2): o título da pergunta do arco, a primeira linha
+    // da mensagem do bot a que o dono respondeu (reply), como `textoDaPerguntaDoArco` o monta no Telegram. Só ele dá a
+    // referência, e o código sai dele: confirmação, recusa, lembrete e conversa nunca têm esta linha. O gateway assina o
+    // código e o id da mensagem respondida no endereço `resposta:<código>:<id>`, e o núcleo confere que o id é o da mensagem
+    // em que a pergunta foi entregue. Não é forma de resposta: é a referência dela.
+    referencia: '^🔔 (?:[1-9][0-9]?\\. )?arco [a-z0-9][a-z0-9-]{0,62} · ((?=[A-HJKMNP-TV-Z][2-9A-HJKMNP-TV-Z]{0,2}[2-9])[A-HJKMNP-TV-Z][2-9A-HJKMNP-TV-Z]{3})$',
 });
 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');
+const CONDUCAO = new RegExp(exports.GRAMATICA_DO_PULSE.conducao, '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 > hitl_texto_livre_1.TETO_DA_FORMA)
@@ -154,6 +171,8 @@ function interpretarRespostaDoPulse(texto) {
     const tag = CADENCIA.test(texto) ? (0, pulse_cadencia_1.extrairTagDoPulse)(texto) : null;
     if (tag)
         return { forma: 'cadencia', tag };
+    if (CONDUCAO.test(texto))
+        return { forma: 'conducao', comando: /#OrkRetomar/i.test(texto) ? 'retomar' : 'fabrica' };
     const solta = (0, hitl_texto_livre_1.lerSolta)(texto);
     if (solta)
         return { forma: 'livre', trecho: solta };
@@ -199,6 +218,9 @@ function perguntaViva(p, quando) {
  * guarda de 24 h desde que saiu: depois do prazo do pedido ela vai ao pedido renovado.
  */
 function perguntaEmAberto(p, quando) {
+    // RM-057 (resposta curta): a pergunta do arco não se renova; vencida, ela deixa de esperar o dono.
+    if (p.arco)
+        return perguntaViva(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. */
@@ -451,6 +473,182 @@ function recomendadaDoRegistro(raiz, p) {
     }
 }
 // ---------------------------------------------------------------------------
+// RM-057 (resposta curta, ork-rm057respost): a pergunta do arco #Noctum no canal do pulse.
+// ---------------------------------------------------------------------------
+/** O número livre para UMA pergunta servida sozinha: o seguinte aos do registro, ou o menor livre quando passaria de 99. */
+function numeroLivreParaUma(servido) {
+    const usados = new Set(servido.perguntas.map(p => p.numero));
+    const seguinte = Math.max(0, ...usados) + 1;
+    if (seguinte <= MAIOR_NUMERO)
+        return seguinte;
+    for (let n = 1; n <= MAIOR_NUMERO; n++)
+        if (!usados.has(n))
+            return n;
+    return 1;
+}
+/** O chat de um envelope do Telegram (`telegram:<chat>:<mensagem>`), ou de um destino (`telegram:<chat>[:<tópico>]`). */
+function chatDoTelegram(ref) {
+    const m = /^telegram:(-?\d+)(?::[^:]+)?$/.exec(String(ref ?? ''));
+    return m ? m[1] : null;
+}
+/**
+ * Serve UMA pergunta do arco no canal, com número, sob o lock da conversa do pulse: o número é reservado, a mensagem sai
+ * pelo `entregar` (com o número no título) e o registro só acontece com o recibo do transporte. A mesma pergunta já
+ * servida e ainda em aberto não sai de novo. A janela da palavra solta acompanha.
+ */
+function servirPerguntaDoArco(raiz, p, opcoes) {
+    const estadoDir = opcoes.estadoDir ?? path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'monitor');
+    return (0, monitor_lock_1.comLockDaConversa)(estadoDir, () => {
+        let servido = podar(lerLoteServido(raiz, estadoDir), opcoes.quando);
+        const ja = servido.perguntas.find(q => q.arco?.codigo === p.codigo && perguntaEmAberto(q, opcoes.quando));
+        if (ja)
+            return { numero: ja.numero, entregue: false, jaServida: true, host: null, destino: ja.arco.destino, mensagens: [...(ja.arco.mensagens ?? [])] };
+        const numero = numeroLivreParaUma(servido);
+        const r = opcoes.entregar(numero);
+        if (!r.ok)
+            return { numero: null, entregue: false, jaServida: false, host: r.host, destino: null, mensagens: [] };
+        const alternativas = (0, noctum_pergunta_1.alternativasDaPergunta)(p);
+        const recomendada = alternativas.find(a => a.porque);
+        const nova = {
+            numero, thread: `arco:${p.arco}`, fase: null, pedidoId: `noctum:${p.arco}:${p.codigo}`,
+            pedidoSha256: sha(JSON.stringify([p.arco, p.ato, p.codigo, p.versao, p.envelopeSha256, p.prazo])),
+            letras: alternativas.map(a => a.letra), alternativas: alternativas.map(a => a.texto), consequencias: alternativas.map(a => a.consequencia),
+            recomendada: { letra: recomendada.letra, porque: recomendada.porque }, desde: p.criadaEm,
+            pergunta: (0, noctum_pergunta_1.fraseDaPergunta)(p), prazo: p.prazo, servidaEm: opcoes.quando,
+            arco: { arco: p.arco, ato: p.ato, codigo: p.codigo, destino: r.destino, mensagens: [...(r.mensagens ?? [])] },
+        };
+        servido = { ...servido, perguntas: [...servido.perguntas, nova] };
+        gravarLoteServido(raiz, servido, estadoDir);
+        try {
+            atualizarEscuta(raiz, opcoes.quando, estadoDir);
+        }
+        catch { /* dica de rota; a prova não depende dela */ }
+        return { numero, entregue: true, jaServida: false, host: r.host, destino: r.destino, mensagens: [...(r.mensagens ?? [])] };
+    });
+}
+/**
+ * O que vem depois do código no texto do dono. Sem o código na frente (o reply, que traz o código pelo endereço), o texto
+ * inteiro é a resposta.
+ */
+function restoDoCodigo(texto, codigo) {
+    const t = texto.trim();
+    return t.toUpperCase().startsWith(codigo.toUpperCase()) && (t.length === codigo.length || /\s/.test(t[codigo.length]))
+        ? t.slice(codigo.length).trim() : t;
+}
+/** A prova do pulse para o ato do arco: o envelope como o gateway o assinou, o endereço e o hash do texto do dono. */
+function provaDoPulse(envelope, endereco) {
+    return r => ({ via: 'pulse', envelope, endereco, pergunta: { ...r, respostaSha256: sha(envelope.resposta) } });
+}
+/** Marca a pergunta do arco servida como respondida, quando ela está no registro. */
+function marcarArcoRespondido(raiz, estadoDir, codigo, letra, quando, mensagem, estado) {
+    const servido = lerLoteServido(raiz, estadoDir);
+    if (!servido.perguntas.some(q => q.arco?.codigo === codigo && !q.respondida))
+        return;
+    gravarLoteServido(raiz, { ...servido, perguntas: servido.perguntas.map(q => q.arco?.codigo === codigo && !q.respondida
+            ? { ...q, respondida: { letra, em: quando, mensagem, estado } } : q) }, estadoDir);
+}
+/** O resultado do pulse para o desfecho da resposta à pergunta do arco. */
+function resultadoDoArco(tipo, p, d, envelope, numero = 0) {
+    if (d.tipo === 'registrada') {
+        // `repetida` para o canal é a MESMA mensagem entregue de novo pelo gateway: aí ele não confirma de novo ao dono.
+        return resultado(tipo, d.mensagem, { repetida: d.mesmaProva,
+            registradas: [{ numero, thread: `arco:${p.arco}`, letra: 'a', estado: p.ato === 'autorizar' ? 'autorizado' : 'revogado', repetida: d.mesmaProva }] });
+    }
+    if (d.tipo === 'sem-efeito')
+        return resultado(tipo, d.mensagem, { registradas: [{ numero, thread: `arco:${p.arco}`, letra: d.letra, estado: 'sem-efeito', repetida: false }] });
+    if (d.tipo === 'detalhe')
+        return resultado(tipo, d.mensagem.slice(0, hitl_lote_1.TETO_DA_MENSAGEM));
+    void envelope;
+    return resultado(tipo, d.mensagem, { recusas: [{ ...(numero ? { numero } : {}), motivo: d.motivo }] });
+}
+/** O trecho depois do código ("NX4K a"), ou `null` quando ele não é resposta; "?" pede o detalhe. */
+function trechoDepoisDoCodigo(resto) {
+    return (0, hitl_texto_livre_1.lerTrecho)(resto) ?? (/^\?$/.test(resto) ? (0, hitl_texto_livre_1.lerTrecho)('detalhes') : null);
+}
+/**
+ * "<código> a" a uma pergunta do arco: lê o resto, chama a resposta ao arco com a prova do pulse e marca a pergunta
+ * servida. Nunca escolhe pelo dono: fora do vocabulário, volta com as alternativas reais.
+ */
+function responderAoArcoPorCodigo(raiz, envelope, p, resto, opcoes) {
+    const { quando, canal } = opcoes, tg = canal === 'telegram';
+    const trecho = trechoDepoisDoCodigo(resto);
+    if (!trecho) {
+        return resultado('codigo', `${tg ? '⚠️ ' : '! '}Não entendi "${resto.slice(0, 40)}" para ${p.codigo}; nada foi registrado. ` +
+            `Responda com uma destas: ${(0, noctum_pergunta_1.alternativasDaPergunta)(p).map(a => `${a.letra} (${a.texto})`).join(', ')}.`, { recusas: [{ motivo: 'nao-entendida' }] });
+    }
+    const d = (0, noctum_resposta_1.responderPerguntaDoArco)(raiz, p, trecho, { quando, canal, provar: provaDoPulse(envelope, pulse_consentimento_1.ENDERECO_DA_RESPOSTA) });
+    if (d.tipo === 'registrada' || d.tipo === 'sem-efeito') {
+        marcarArcoRespondido(raiz, opcoes.estadoDir, p.codigo, d.letra, quando, envelope.mensagem, d.tipo === 'registrada' ? 'registrada' : 'sem-efeito');
+    }
+    return resultadoDoArco('codigo', p, d, envelope);
+}
+/**
+ * RM-057 (resposta curta, D3; GO-FIX 1, achados 2 e 4 da ork-rm057respost): a resposta EM REPLY à mensagem de uma
+ * pergunta do arco. A referência assinada traz o código e o id da mensagem respondida, e o reply só vale quando esse id é
+ * o da mensagem em que a pergunta foi entregue, no mesmo chat: a confirmação do "b", a recusa, o lembrete e a mensagem de
+ * qualquer outra pessoa nunca são a pergunta, mesmo com o código. A resposta vale só para a pergunta respondida: a letra, a
+ * palavra do vocabulário que cai numa alternativa dela, o código dela com a letra ou o número dela com a letra; "1a" em
+ * reply à mensagem de outra pergunta, a lista e o código de outra pergunta voltam sem gravar nada.
+ */
+function responderEmReply(raiz, envelope, lido, referencia, opcoes) {
+    const { quando, canal, estadoDir } = opcoes, tg = canal === 'telegram';
+    const volta = (texto, motivo) => resultado('codigo', `${tg ? '⚠️ ' : '! '}${texto}`, { recusas: [{ motivo }] });
+    const ref = (0, pulse_consentimento_1.lerReferenciaDoReply)(referencia);
+    const chat = chatDoTelegram(envelope.mensagem);
+    const servida = lerLoteServido(raiz, estadoDir).perguntas.find(q => q.arco?.codigo === ref.codigo &&
+        (q.arco.mensagens ?? []).includes(ref.mensagem) && chat !== null && chatDoTelegram(q.arco.destino) === chat);
+    if (!servida) {
+        return volta(`A mensagem que você respondeu não é a da pergunta ${ref.codigo} como o Orkastery a entregou neste chat; nada foi ` +
+            `registrado. Responda à mensagem da pergunta, ou mande ${ref.codigo} com a letra.`, 'reply.fora-da-pergunta');
+    }
+    const numero = servida.numero;
+    let trecho = null;
+    if (lido.forma === 'livre')
+        trecho = lido.trecho;
+    else if (lido.forma === 'consentimento') {
+        // O código digitado diferente do código da mensagem respondida não é escolhido pelo dono: nada é registrado.
+        if (lido.codigo !== ref.codigo) {
+            return volta(`Você respondeu com o código ${lido.codigo} à mensagem da pergunta ${ref.codigo}; nada foi registrado. ` +
+                'Responda à mensagem só com a letra, ou mande o código certo.', 'codigo.divergente');
+        }
+        trecho = trechoDepoisDoCodigo(restoDoCodigo(envelope.resposta, ref.codigo));
+    }
+    else if (lido.forma === 'lote' && lido.escolhas.length === 1 && lido.escolhas[0].numero === numero) {
+        trecho = { tipo: 'letra', letra: lido.escolhas[0].letra };
+    }
+    if (!trecho) {
+        return volta(`Em reply à pergunta ${numero} (${ref.codigo}), mande só a resposta a ela: a letra, ${numero} com a letra, ou ` +
+            `${ref.codigo} com a letra. Nada foi registrado.`, 'reply.outra-pergunta');
+    }
+    const q = (0, noctum_resposta_1.perguntasPorCodigo)(raiz, ref.codigo, quando).find(x => x.arco === servida.arco.arco);
+    if (!q)
+        return volta(`A pergunta ${ref.codigo} já não existe no arco ${servida.arco.arco}; nada foi registrado.`, 'sem-pergunta-recente');
+    const d = (0, noctum_resposta_1.responderPerguntaDoArco)(raiz, q, trecho, { quando, canal, numero, provar: provaDoPulse(envelope, opcoes.endereco) });
+    if (d.tipo === 'registrada' || d.tipo === 'sem-efeito') {
+        marcarArcoRespondido(raiz, estadoDir, q.codigo, d.letra, quando, envelope.mensagem, d.tipo === 'registrada' ? 'registrada' : 'sem-efeito');
+    }
+    return resultadoDoArco('codigo', q, d, envelope, numero);
+}
+/**
+ * RM-057 (GO-FIX 2, R1 do CHECK da ork-rm057respost): a palavra solta EM REPLY a uma mensagem que não é a pergunta do arco
+ * (a confirmação de um gate, a mensagem de outra pessoa do grupo, a do assistente). O dono respondeu àquela mensagem, e o
+ * Orkastery não adivinha que era à pergunta: a palavra nunca vira palavra solta, nada é gravado, e a resposta diz por
+ * onde responder. A palavra solta só vale sem reply, com uma só pergunta pendente no chat, ou em reply à mensagem da
+ * pergunta; o código e o número dizem a pergunta e o gateway os manda sem esta marca.
+ */
+function respostaAOutraMensagem(raiz, opcoes) {
+    const tg = opcoes.canal === 'telegram';
+    let abertos = [];
+    try {
+        abertos = abertosDoDono(raiz, opcoes.quando, opcoes.estadoDir);
+    }
+    catch { /* a recusa não depende da lista */ }
+    const lista = abertos.slice(0, 5).map(a => a.rotulo).join('; ') + (abertos.length > 5 ? `; e mais ${abertos.length - 5}` : '');
+    return resultado('nao-entendida', `${tg ? '⚠️ ' : '! '}A mensagem que você respondeu não é a de uma pergunta do Orkastery, e em reply ` +
+        'a palavra solta só vale para a mensagem da pergunta; nada foi registrado. ' + (abertos.length
+        ? `Responda à mensagem da pergunta, ou pelo número ou pelo código: ${lista}.` : 'Não há pergunta esperando você agora.'), { recusas: [{ motivo: 'reply.outra-mensagem' }] });
+}
+// ---------------------------------------------------------------------------
 // RM-048 (D4): a linha que o dono recebeu vale enquanto o gate esperar a mesma pergunta.
 // ---------------------------------------------------------------------------
 /**
@@ -507,6 +705,8 @@ function codigosEmUso(raiz, estadoDir) {
         }
         catch { /* thread ilegivel nao contribui */ }
     }
+    // RM-057 (resposta curta): as perguntas dos arcos #Noctum também usam o alfabeto do código curto.
+    codigos.push(...(0, noctum_arco_1.codigosDosArcos)(raiz));
     return codigos;
 }
 /** O bloco de evidencia a um pedido de distancia (item 4): artefato, claims, riscos e diff. */
@@ -664,6 +864,16 @@ function pedidoDaServida(raiz, p) {
  * pergunta, com as letras reais.
  */
 function letraDaPalavra(raiz, p, trecho, quando) {
+    if (p.arco) {
+        // RM-057 (resposta curta): a pergunta do arco não tem pedido de thread; a palavra casa pelas ações das alternativas dela.
+        const r = (0, noctum_pergunta_1.escolhaDaPergunta)({ ato: p.arco.ato }, trecho);
+        const reais = p.letras.map((l, i) => `${p.numero}${l} (${p.alternativas[i]})`).join(', ');
+        if (r.tipo === 'detalhe')
+            return { recusa: `o envelope da pergunta ${p.numero} sai com ${p.arco.codigo} detalhes.` };
+        if (r.tipo !== 'escolha')
+            return { recusa: `para a pergunta ${p.numero}, mande uma destas: ${reais}.` };
+        return { letra: p.letras[r.indice], ...(trecho.tipo === 'intencao' ? { palavra: trecho.palavra } : {}) };
+    }
     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.` };
@@ -723,6 +933,13 @@ function abertosDoDono(raiz, quando, estadoDir) {
     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))) {
+        if (p.arco) {
+            vistas.add(`arco:${p.arco.codigo}`);
+            // A pergunta do arco sempre tem código: o rótulo dá os dois jeitos de dizer qual (D9 da ork-rm057respost).
+            abertos.push({ tipo: 'pergunta', servida: p, codigo: p.arco.codigo,
+                rotulo: `${p.numero} ou ${p.arco.codigo}, com a letra (arco ${p.arco.arco}: ${p.arco.ato})`, recente: agora - Date.parse(p.servidaEm) < janela });
+            continue;
+        }
         const pedido = pedidoDaServida(raiz, p);
         if (pedido)
             vistas.add(chave(pedido));
@@ -769,6 +986,14 @@ function abertosDoDono(raiz, quando, estadoDir) {
         }
         catch { /* thread ilegivel nao entra na conta; a palavra solta so fica mais cautelosa */ }
     }
+    // RM-057 (resposta curta): a pergunta do arco que espera o dono e não saiu por aqui também conta, para a palavra solta
+    // nunca cair numa pergunta quando há outra esperando.
+    for (const q of (0, noctum_resposta_1.perguntasPendentes)(raiz, quando)) {
+        if (vistas.has(`arco:${q.codigo}`))
+            continue;
+        vistas.add(`arco:${q.codigo}`);
+        abertos.push({ tipo: 'arco', codigo: q.codigo, rotulo: (0, noctum_resposta_1.rotuloDaPergunta)(q), recente: false });
+    }
     return abertos;
 }
 /**
@@ -797,6 +1022,29 @@ function responderLivre(raiz, envelope, trecho, opcoes) {
         return responderAoResumo(raiz, envelope, unico.codigo, { quando, canal, estadoDir, palavra: trecho });
     }
     const p = unico.servida;
+    if (p.arco) {
+        // RM-057 (resposta curta, D3 e D4): "sem reply, vale se houver uma só pendente no canal". O canal é o chat em que a
+        // pergunta saiu: a palavra de outro chat volta como pergunta, com o código.
+        const destino = chatDoTelegram(p.arco.destino), chat = chatDoTelegram(envelope.mensagem);
+        if (destino && chat && destino !== chat) {
+            return volta(`A pergunta que espera você saiu por outro chat; palavra solta não registra. Responda: ${p.arco.codigo} a ` +
+                `(arco ${p.arco.arco}: ${p.arco.ato}), ou responda à mensagem dela.`, 'outro-chat');
+        }
+        // GO-FIX 1 (achado 6): a mensagem de antes de a pergunta sair não responde a ela, nem entregue de novo dentro dos 60 s.
+        if (!(Date.parse(envelope.recebidoEm) >= Date.parse(p.servidaEm))) {
+            return volta(`A sua mensagem é de antes de a pergunta ${p.numero} sair; palavra solta não registra. Responda: ${p.arco.codigo} a ` +
+                `(arco ${p.arco.arco}: ${p.arco.ato}), ou responda à mensagem dela.`, 'anterior-a-pergunta');
+        }
+        const q = (0, noctum_resposta_1.perguntasPorCodigo)(raiz, p.arco.codigo, quando).find(x => x.arco === p.arco.arco);
+        if (!q)
+            return volta(`A pergunta ${p.numero} já não existe no arco ${p.arco.arco}; nada foi registrado.`, 'sem-pergunta-recente');
+        const d = (0, noctum_resposta_1.responderPerguntaDoArco)(raiz, q, trecho, { quando, canal, numero: p.numero,
+            provar: provaDoPulse(envelope, pulse_consentimento_1.ENDERECO_DA_RESPOSTA) });
+        if (d.tipo === 'registrada' || d.tipo === 'sem-efeito') {
+            marcarArcoRespondido(raiz, estadoDir, q.codigo, d.letra, quando, envelope.mensagem, d.tipo === 'registrada' ? 'registrada' : 'sem-efeito');
+        }
+        return resultadoDoArco('lote', q, d, envelope, p.numero);
+    }
     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: ` +
@@ -928,19 +1176,50 @@ function resultado(tipo, mensagem, extra = {}) {
 function responderPeloPulse(raiz, envelope, opcoes = {}) {
     const quando = opcoes.quando ?? new Date().toISOString();
     const canal = opcoes.canal ?? 'telegram';
-    (0, hitl_gates_1.autenticarResposta)(pulse_consentimento_1.ALVO_DO_PULSE, pulse_consentimento_1.ENDERECO_DA_RESPOSTA, envelope, envelope.recebidoEm);
-    (0, hitl_gates_1.autenticarResposta)(pulse_consentimento_1.ALVO_DO_PULSE, pulse_consentimento_1.ENDERECO_DA_RESPOSTA, envelope, quando);
+    const endereco = (0, pulse_consentimento_1.enderecoDoPulse)(opcoes.referencia);
+    (0, hitl_gates_1.autenticarResposta)(pulse_consentimento_1.ALVO_DO_PULSE, endereco, envelope, envelope.recebidoEm);
+    (0, hitl_gates_1.autenticarResposta)(pulse_consentimento_1.ALVO_DO_PULSE, endereco, envelope, quando);
     const lido = interpretarRespostaDoPulse(envelope.resposta);
     if (lido.forma === 'desconhecida')
         return resultado('nao-entendida', `Não entendi. ${EXEMPLO}`);
+    // 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');
+    if (opcoes.referencia) {
+        // RM-057 (GO-FIX 1, achados 2 e 4): o reply responde só à pergunta da mensagem respondida, e só como resposta a ela.
+        const referencia = opcoes.referencia;
+        return (0, monitor_lock_1.comLockDaConversa)(estadoDir, () => {
+            const r = (() => {
+                try {
+                    // GO-FIX 2 (R1): em reply a outra mensagem, nada vira palavra solta; o dono ouve por onde responder.
+                    if (referencia === pulse_consentimento_1.REPLY_A_OUTRA)
+                        return respostaAOutraMensagem(raiz, { quando, canal, estadoDir });
+                    if (!['livre', 'consentimento', 'lote'].includes(lido.forma)) {
+                        return resultado('codigo', `${canal === 'telegram' ? '⚠️ ' : '! '}Em reply à pergunta, mande só a resposta a ela (a letra, ` +
+                            'o número com a letra ou o código com a letra). Nada foi registrado.', { recusas: [{ motivo: 'reply.outra-pergunta' }] });
+                    }
+                    return responderEmReply(raiz, envelope, lido, referencia, { quando, canal, estadoDir, endereco });
+                }
+                catch (e) {
+                    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' }] });
+                }
+            })();
+            try {
+                atualizarEscuta(raiz, quando, estadoDir);
+            }
+            catch { /* dica de rota; a prova nao depende dela */ }
+            return r;
+        });
+    }
     if (lido.forma === 'cadencia') {
         // I-50: preferencia de entrega, nao decisao de gate. Grava quem mandou, pelo remetente autenticado.
         const repetida = (0, pulse_cadencia_1.lerCadencia)(raiz, opcoes.estadoDir).gravada?.tag === lido.tag;
         (0, pulse_cadencia_1.gravarCadencia)(raiz, lido.tag, { por: envelope.por, canal: envelope.canal ?? envelope.origem, em: quando }, opcoes.estadoDir);
         return resultado('cadencia', (0, pulse_cadencia_1.textoDaCadencia)(pulse_cadencia_1.CADENCIAS[lido.tag], quando), { cadencia: lido.tag, repetida });
     }
-    // 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');
+    if (lido.forma === 'conducao')
+        return responderConducao(raiz, envelope, lido.comando, opcoes);
     return (0, monitor_lock_1.comLockDaConversa)(estadoDir, () => {
         const r = (() => {
             try {
@@ -987,6 +1266,16 @@ function responderAoResumo(raiz, envelope, codigo, opcoes) {
             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-057 (resposta curta, D3 da ork-rm057respost): o código de uma pergunta do arco #Noctum ("NX4K a"). Código que
+        // também é de gate, de nota ou de duas perguntas é ambíguo: nada é escolhido pelo dono.
+        const doArco = (0, noctum_resposta_1.perguntasPorCodigo)(raiz, codigo, quando);
+        if (doArco.length && (nota || doArco.length > 1 || pedidosComCodigo(raiz, codigo).length)) {
+            return resultado('codigo', `O código ${codigo} está em mais de uma pergunta ao mesmo tempo; nada foi registrado. ` +
+                'Responda pelo número da pergunta, por exemplo 1a.', { recusas: [{ motivo: 'codigo.ambiguo' }] });
+        }
+        if (doArco.length === 1) {
+            return responderAoArcoPorCodigo(raiz, envelope, doArco[0], restoDoCodigo(envelope.resposta, codigo), { quando, canal, estadoDir });
+        }
         // 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)
@@ -1103,6 +1392,33 @@ function responderAsPerguntas(raiz, envelope, escolhas, opcoes) {
             linhas.push(`${telegram ? '⚠️ ' : '! '}${motivo}`);
             continue;
         }
+        if (p.arco) {
+            // RM-057 (resposta curta, D4): a pergunta do arco servida responde pelo número, com a prova do pulse. O ato confere a
+            // pergunta de agora, o prazo e a prova sob o lock do arco; a resposta repetida não grava de novo.
+            const q = (0, noctum_resposta_1.perguntasPorCodigo)(raiz, p.arco.codigo, quando).find(x => x.arco === p.arco.arco);
+            if (!q) {
+                const motivo = `a pergunta ${numero} já não existe no arco ${p.arco.arco}.`;
+                recusas.push({ numero, motivo });
+                linhas.push(`${telegram ? '⚠️ ' : '! '}${motivo}`);
+                continue;
+            }
+            const d = (0, noctum_resposta_1.responderPerguntaDoArco)(raiz, q, { tipo: 'letra', letra }, { quando, canal, numero,
+                provar: provaDoPulse(envelope, pulse_consentimento_1.ENDERECO_DA_RESPOSTA) });
+            if (d.tipo === 'recusada') {
+                recusas.push({ numero, motivo: d.motivo });
+                linhas.push(d.mensagem);
+                continue;
+            }
+            linhas.push(d.mensagem);
+            if (d.tipo === 'detalhe')
+                continue;
+            registradas.push({ numero, thread: p.thread, letra, estado: d.tipo === 'registrada' ? 'registrada' : 'sem-efeito',
+                repetida: d.tipo === 'registrada' && d.mesmaProva });
+            servido = { ...servido, perguntas: servido.perguntas.map(x => x.numero === numero
+                    ? { ...x, respondida: { letra, em: quando, mensagem: envelope.mensagem, estado: d.tipo === 'registrada' ? 'registrada' : 'sem-efeito' } } : x) };
+            gravarLoteServido(raiz, servido, estadoDir);
+            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 });
@@ -1165,3 +1481,51 @@ function responderAsPerguntas(raiz, envelope, escolhas, opcoes) {
     return resultado('lote', texto, { registradas, recusas: [...(opcoes.avisos ?? []).map(motivo => ({ motivo })), ...recusas],
         repetida: registradas.length > 0 && recusas.length === 0 && registradas.every(r => r.repetida) });
 }
+// ---------------------------------------------------------------------------
+// RM-063 (fatia 3, H2): `#OrkRetomar` e `#OrkFabrica` no canal do dono.
+// ---------------------------------------------------------------------------
+/** Os canais de conducao que o envelope pode declarar; o resto fica com o que o adaptador ja exporta. */
+const CANAIS_DO_HOST = ['hermes', 'openclaw', 'claude-code', 'codex', 'cli'];
+/**
+ * A batida da conducao em segundo plano: o ingresso do host espera ate 10 s, e a batida traz a base, le os PRs e pode
+ * despachar uma fase. O processo filho entrega o que voltou a andar pelo transporte do pulse (`--entregar`).
+ */
+function retomarEmSegundoPlano(raiz, canal) {
+    const { spawn } = require('node:child_process');
+    const env = { ...process.env, ...(canal && CANAIS_DO_HOST.includes(canal) ? { ORK_CANAL: canal } : {}) };
+    const filho = spawn(process.execPath, [path.join(__dirname, 'index.js'), 'conducao', 'batida', '--entregar'], { cwd: (0, estado_thread_1.raizDoEstado)(raiz), detached: true, stdio: 'ignore', env });
+    filho.unref();
+}
+/** O `ork fabrica` desta maquina, da ultima copia local da branch da fabrica (sem rede: o ingresso tem prazo curto). */
+function fabricaDestaMaquina(raiz) {
+    const { exigirManifesto } = require('./manifest');
+    const { lerFabrica, textoDaFabrica } = require('./fabrica-estado');
+    const { nomeDaMaquina } = require('./maquina');
+    const carregado = exigirManifesto((0, estado_thread_1.raizDoEstado)(raiz));
+    const painel = lerFabrica(carregado.raiz, { remoto: carregado.manifesto.fabrica.remoto, semRemoto: true });
+    return textoDaFabrica(painel, nomeDaMaquina());
+}
+function responderConducao(raiz, envelope, comando, opcoes) {
+    if (comando === 'fabrica') {
+        let texto;
+        try {
+            texto = (opcoes.fabrica ?? fabricaDestaMaquina)(raiz);
+        }
+        catch (e) {
+            console.error(`pulse responder: fabrica: ${e.message}`);
+            return resultado('fabrica', 'Não consegui ler a fábrica agora. Confira com ork fabrica no terminal.', { recusas: [{ motivo: 'erro-interno' }] });
+        }
+        const limpo = (0, hitl_1.redigirSegredos)(texto).trim();
+        return resultado('fabrica', limpo.length > hitl_lote_1.TETO_DA_MENSAGEM ? `${limpo.slice(0, hitl_lote_1.TETO_DA_MENSAGEM - 40)}\n… (cortado; ork fabrica)` : limpo);
+    }
+    const canal = typeof envelope.canal === 'string' && envelope.canal ? envelope.canal : null;
+    try {
+        (opcoes.retomar ?? retomarEmSegundoPlano)(raiz, canal);
+    }
+    catch (e) {
+        console.error(`pulse responder: retomar: ${e.message}`);
+        return resultado('retomar', 'Não consegui disparar a batida da condução agora. Rode ork conducao batida no terminal.', { recusas: [{ motivo: 'erro-interno' }] });
+    }
+    return resultado('retomar', 'Retomando: a batida da condução está rodando nesta máquina agora (merge do PR pronto, registro da ' +
+        'entrega, MASTER por omissão e a fase seguinte, dentro da sua autorização durável). O que voltou a andar chega em seguida, por este canal.');
+}