@orkastery/cli 0.2.0 → 0.3.0

package/dist/pulse-cadencia.js

@@ -0,0 +1,163 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CADENCIA_PADRAO = exports.CADENCIAS = exports.CONTRATO_CADENCIA = void 0;
+exports.extrairTagDoPulse = extrairTagDoPulse;
+exports.lerCadencia = lerCadencia;
+exports.gravarCadencia = gravarCadencia;
+exports.janelaDoInstante = janelaDoInstante;
+exports.inicioDaProximaJanela = inicioDaProximaJanela;
+exports.lerUltimoResumo = lerUltimoResumo;
+exports.gravarUltimoResumo = gravarUltimoResumo;
+exports.janelaAberta = janelaAberta;
+exports.textoDaCadencia = textoDaCadencia;
+/**
+ * I-50 (RM-039): a cadencia do resumo do pulse, trocada pelo dono em conversa com uma tag.
+ *
+ * As tags sao as que o dono definiu:
+ *   `#OrkPulseOff`      de 8 em 8 horas, ancorado as 08h do fuso dono (08h, 16h e 00h);
+ *   `#OrkPulseOn`       de 2 em 2 horas;
+ *   `#OrkPulseOn-15m`, `-30m` e `-60m`: de 15, 30 ou 60 minutos.
+ *
+ * O cron bate em intervalo curto e quem decide se ESTA batida entrega e o nucleo, lendo a
+ * cadencia duravel em `.orkastery/monitor/pulse-cadencia.json`. Assim a troca de tag vale na
+ * proxima batida, sem editar o crontab. A cadencia governa o status periodico; pergunta de
+ * verdade ao dono nao espera janela nenhuma e sai na hora.
+ *
+ * Cada cadencia divide o dia do dono em janelas ancoradas (15m em :00, :15, :30 e :45; 2h nas
+ * horas pares; 8h as 08h, 16h e 00h). Entrega-se no maximo uma vez por janela.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const horario_1 = require("./horario");
+const estado_thread_1 = require("./estado-thread");
+exports.CONTRATO_CADENCIA = 'ork.pulse-cadencia/v1';
+const ARQUIVO_CADENCIA = 'pulse-cadencia.json';
+const ARQUIVO_ULTIMO_RESUMO = 'pulse-ultimo-resumo.json';
+exports.CADENCIAS = {
+    '#OrkPulseOff': { tag: '#OrkPulseOff', janelaMin: 480, ancoraMin: 8 * 60, descricao: 'de 8 em 8 horas, as 08h, 16h e 00h' },
+    '#OrkPulseOn': { tag: '#OrkPulseOn', janelaMin: 120, ancoraMin: 0, descricao: 'de 2 em 2 horas' },
+    '#OrkPulseOn-15m': { tag: '#OrkPulseOn-15m', janelaMin: 15, ancoraMin: 0, descricao: 'de 15 em 15 minutos' },
+    '#OrkPulseOn-30m': { tag: '#OrkPulseOn-30m', janelaMin: 30, ancoraMin: 0, descricao: 'de 30 em 30 minutos' },
+    '#OrkPulseOn-60m': { tag: '#OrkPulseOn-60m', janelaMin: 60, ancoraMin: 0, descricao: 'de hora em hora' },
+};
+/** Sem tag gravada, vale a hora cheia: o pedido do dono em 20/09/2026. */
+exports.CADENCIA_PADRAO = '#OrkPulseOn-60m';
+/** A primeira tag de pulse do texto, em qualquer canal; `null` quando nao ha. */
+function extrairTagDoPulse(texto) {
+    if (typeof texto !== 'string')
+        return null;
+    const m = /#OrkPulse(On|Off)(?:-(15|30|60)m)?(?![\w-])/i.exec(texto);
+    if (!m)
+        return null;
+    if (m[1].toLowerCase() === 'off')
+        return m[2] ? null : '#OrkPulseOff';
+    return m[2] ? `#OrkPulseOn-${m[2]}m` : '#OrkPulseOn';
+}
+const dirDoMonitor = (raiz, estadoDir) => estadoDir ?? path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'monitor');
+/** A cadencia em vigor: a gravada pelo dono, ou a padrao. Arquivo ilegivel vale a padrao. */
+function lerCadencia(raiz, estadoDir) {
+    try {
+        const bruto = JSON.parse(fs.readFileSync(path.join(dirDoMonitor(raiz, estadoDir), ARQUIVO_CADENCIA), 'utf8'));
+        if (bruto.contrato === exports.CONTRATO_CADENCIA && Object.hasOwn(exports.CADENCIAS, bruto.tag))
+            return { ...exports.CADENCIAS[bruto.tag], gravada: bruto };
+    }
+    catch { /* sem cadencia gravada: vale a padrao */ }
+    return { ...exports.CADENCIAS[exports.CADENCIA_PADRAO], gravada: null };
+}
+/** Grava a tag do dono. `por` e quem mandou (o remetente autenticado do canal, ou o operador). */
+function gravarCadencia(raiz, tag, origem, estadoDir) {
+    if (!Object.hasOwn(exports.CADENCIAS, tag))
+        throw new Error(`pulse.cadencia: tag desconhecida ${tag}`);
+    const por = origem.por.trim();
+    if (!por)
+        throw new Error('pulse.cadencia: informe quem trocou a cadencia');
+    const gravada = { contrato: exports.CONTRATO_CADENCIA, tag, por, canal: origem.canal, em: origem.em ?? new Date().toISOString() };
+    const dir = dirDoMonitor(raiz, estadoDir);
+    fs.mkdirSync(dir, { recursive: true });
+    const temp = path.join(dir, `.${ARQUIVO_CADENCIA}.${process.pid}.tmp`);
+    fs.writeFileSync(temp, JSON.stringify(gravada, null, 2) + '\n', { mode: 0o600 });
+    fs.renameSync(temp, path.join(dir, ARQUIVO_CADENCIA));
+    return gravada;
+}
+/** O numero da janela de um instante: minutos locais desde a ancora, divididos pela janela. */
+function janelaDoInstante(def, quando, fuso = (0, horario_1.fusoDoDono)().fuso) {
+    const p = (0, horario_1.partesLocais)(quando, fuso);
+    const localMin = Date.UTC(Number(p.ano), Number(p.mes) - 1, Number(p.dia), Number(p.hora), Number(p.minuto)) / 60000;
+    return Math.floor((localMin - def.ancoraMin) / def.janelaMin);
+}
+/** Quando a proxima janela comeca, em ISO: para dizer ao dono a hora do proximo resumo. */
+function inicioDaProximaJanela(def, quando, fuso = (0, horario_1.fusoDoDono)().fuso) {
+    const atual = janelaDoInstante(def, quando, fuso);
+    let t = Date.parse(quando);
+    // Avanca minuto a minuto no maximo uma janela: simples e sem aritmetica de fuso.
+    for (let i = 0; i <= def.janelaMin; i++) {
+        t += 60_000;
+        if (janelaDoInstante(def, t, fuso) > atual) {
+            const d = new Date(t);
+            d.setUTCSeconds(0, 0);
+            return d.toISOString();
+        }
+    }
+    return new Date(t).toISOString();
+}
+function lerUltimoResumo(raiz, estadoDir) {
+    try {
+        const bruto = JSON.parse(fs.readFileSync(path.join(dirDoMonitor(raiz, estadoDir), ARQUIVO_ULTIMO_RESUMO), 'utf8'));
+        return typeof bruto.em === 'string' && Number.isFinite(Date.parse(bruto.em)) ? bruto.em : null;
+    }
+    catch {
+        return null;
+    }
+}
+function gravarUltimoResumo(raiz, em, estadoDir) {
+    const dir = dirDoMonitor(raiz, estadoDir);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, ARQUIVO_ULTIMO_RESUMO), JSON.stringify({ em }) + '\n', { mode: 0o600 });
+}
+/**
+ * Esta batida do cron pode entregar o status periodico? So quando a janela mudou desde o ultimo
+ * resumo entregue. Pergunta nova ao dono nao passa por aqui: ela sai na hora.
+ */
+function janelaAberta(def, ultimoResumoEm, quando, fuso = (0, horario_1.fusoDoDono)().fuso) {
+    if (!ultimoResumoEm)
+        return true;
+    return janelaDoInstante(def, quando, fuso) > janelaDoInstante(def, ultimoResumoEm, fuso);
+}
+/** A confirmacao que volta ao dono pelo mesmo canal, no fuso dele. */
+function textoDaCadencia(def, quando) {
+    return `Pulse ${def.descricao} (${def.tag}). Pergunta para você continua saindo na hora. ` +
+        `Próximo resumo com novidade a partir de ${(0, horario_1.formatarDataHoraRotulada)(inicioDaProximaJanela(def, quando))}.`;
+}

package/dist/pulse-consentimento.js

@@ -0,0 +1,260 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRAZO_PADRAO_MIN = exports.ENDERECO_DA_RESPOSTA = exports.ALVO_DO_PULSE = exports.TAMANHO_DO_CODIGO = exports.ALFABETO_DO_CODIGO = exports.CONTRATO_CONSENTIMENTO = void 0;
+exports.arquivoDoConsentimento = arquivoDoConsentimento;
+exports.gerarCodigo = gerarCodigo;
+exports.interpretarResposta = interpretarResposta;
+exports.assinaturaDosCandidatos = assinaturaDosCandidatos;
+exports.lerConsentimento = lerConsentimento;
+exports.consentimentoVigente = consentimentoVigente;
+exports.abrirConsentimento = abrirConsentimento;
+exports.responderConsentimento = responderConsentimento;
+exports.marcarLoteEntregue = marcarLoteEntregue;
+/**
+ * I-41 (D16): o consentimento que separa a camada 1 da camada 2.
+ *
+ * O resumo termina perguntando "Posso te mandar as perguntas agora?". Essa pergunta e um pedido
+ * HITL como qualquer outro, e obedece as mesmas regras: resposta por letra ou palavra curta, sem
+ * identificador longo na mao do humano, e proveniencia provada pelo HMAC do ingresso autenticado.
+ *
+ * O QUE NAO MUDA, e o motivo: `assinaturaDaResposta` e `autenticarResposta` sao chamadas daqui
+ * sem uma linha alterada, e o corpo assinado continua o de sempre. E essa assinatura que impede o
+ * agente consentir no lugar do dono, e ela nao se negocia.
+ *
+ * I-41 (GO-FIX 1, B1): O ENDERECO. O dono digita "P4EJ a" no Telegram, e o gateway que recebe essa
+ * mensagem nao conhece identificador de pedido nenhum. Por isso o ingresso assina o endereco do
+ * pulse (`ALVO_DO_PULSE` na posicao de thread, `ENDERECO_DA_RESPOSTA` na posicao de pedido) junto
+ * com o texto exato que o dono digitou. O codigo esta DENTRO do texto assinado, entao um "sim" a um
+ * resumo nao vale para outro: o codigo precisa bater com o pedido aberto, e a janela de 60
+ * segundos do ingresso fecha a repeticao. Quem traduz o codigo no pedido e o nucleo.
+ *
+ * O consentimento nao e de uma thread: ele e do projeto, porque o resumo atravessa todas. O alvo e
+ * uma constante e nao um nome de thread: ids de thread deste projeto comecam com o abbrev.
+ *
+ * Silencio nao perde nada. Consentimento vencido nao nega e nao apaga: o proximo resumo abre
+ * outro e cita as perguntas guardadas. Os itens vivem no pulse, nao aqui.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const estado_thread_1 = require("./estado-thread");
+const hitl_gates_1 = require("./hitl-gates");
+exports.CONTRATO_CONSENTIMENTO = 'ork.pulse-consent/v1';
+/**
+ * Crockford base32 sem os quatro ambiguos (I, L, O, U). Com letra na frente e ao menos um digito,
+ * quatro caracteres ainda dao mais de 350.000 codigos, e o escopo de unicidade que importa e um: o
+ * consentimento aberto agora. Ambiguo fora do alfabeto importa porque o dono digita isto no
+ * celular, onde 0 e O sao a mesma coisa.
+ */
+exports.ALFABETO_DO_CODIGO = '23456789ABCDEFGHJKMNPQRSTVWXYZ';
+exports.TAMANHO_DO_CODIGO = 4;
+const DIGITOS_DO_CODIGO = '23456789';
+const LETRAS_DO_CODIGO = 'ABCDEFGHJKMNPQRSTVWXYZ';
+/**
+ * I-41 (GO-FIX 1, B1): o endereco do pulse no corpo assinado.
+ *
+ * O ingresso poe `ALVO_DO_PULSE` na posicao de thread e `ENDERECO_DA_RESPOSTA` na posicao de
+ * pedido, e o texto que o dono digitou na posicao de resposta. Nenhum dos dois e nome de thread
+ * ou de pedido: um envelope assinado para uma thread de verdade nao serve aqui, e vice-versa.
+ */
+exports.ALVO_DO_PULSE = 'pulse';
+exports.ENDERECO_DA_RESPOSTA = 'resposta';
+/** Uma hora, a mesma janela do resumo pedido em 20/09. Vencido nao nega: so deixa de valer. */
+exports.PRAZO_PADRAO_MIN = 60;
+const sha = (s) => (0, node_crypto_1.createHash)('sha256').update(s).digest('hex');
+function arquivoDoConsentimento(raiz, estadoDir) {
+    return path.join(estadoDir ?? path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'monitor'), 'pulse-consentimento.json');
+}
+/**
+ * Codigo novo, uniforme, diferente dos que estiverem em uso agora.
+ *
+ * I-41 (GO-FIX 1): todo codigo comeca por LETRA e tem pelo menos um DIGITO. O ingresso do Telegram
+ * reconhece a resposta ao resumo pela forma "codigo + resposta". Com digito, palavra comum de
+ * quatro letras ("HMMM ok") nunca tem essa forma, e a conversa com o assistente continua indo para
+ * o assistente. Com letra na frente, o codigo nunca e lido como resposta ao lote, que comeca pelo
+ * numero da pergunta: "22A2 a" seria "22a 2a".
+ */
+function gerarCodigo(emUso = []) {
+    const usados = new Set(emUso.map(c => c.toUpperCase()));
+    for (let tentativa = 0; tentativa < 256; tentativa++) {
+        let codigo = LETRAS_DO_CODIGO[(0, node_crypto_1.randomInt)(LETRAS_DO_CODIGO.length)];
+        for (let i = 1; i < exports.TAMANHO_DO_CODIGO; i++)
+            codigo += exports.ALFABETO_DO_CODIGO[(0, node_crypto_1.randomInt)(exports.ALFABETO_DO_CODIGO.length)];
+        if (![...codigo].some(c => DIGITOS_DO_CODIGO.includes(c)))
+            continue;
+        if (!usados.has(codigo))
+            return codigo;
+    }
+    // 810.000 combinacoes contra um punhado em uso: chegar aqui e defeito, nao azar.
+    throw new Error('consentimento do pulse: não foi possível gerar código curto livre');
+}
+/**
+ * O que o dono pode digitar. Letra `a`/`b`, ou palavra curta, com ou sem o codigo na frente,
+ * em qualquer caixa. O que ele NAO precisa digitar e identificador longo.
+ *
+ * Quando o codigo vem escrito, ele precisa bater: um "sim" digitado para o resumo anterior nao
+ * consente com o resumo de agora. Quando nao vem, o pedido aberto e um so e a letra basta.
+ */
+function interpretarResposta(bruto, codigo) {
+    if (typeof bruto !== 'string' || bruto.length > 64)
+        return undefined;
+    const limpo = bruto.trim().toLowerCase().replace(/[.,!]+$/, '');
+    const prefixo = codigo.toLowerCase();
+    const corpo = limpo.startsWith(prefixo) ? limpo.slice(prefixo.length).trim() : limpo;
+    if (limpo !== corpo && corpo === '')
+        return undefined; // só o código, sem escolha, não é resposta
+    if (['a', 's', 'sim', 'pode', 'manda'].includes(corpo))
+        return 'sim';
+    if (['b', 'n', 'nao', 'não', 'agora nao', 'agora não'].includes(corpo))
+        return 'nao';
+    return undefined;
+}
+/**
+ * A assinatura de um conjunto de candidatos: os mesmos gates, a mesma oferta. O pedido aberto nao
+ * entra: ele vence e renasce sem que a pergunta mude, e vencer nao e noticia para o dono.
+ */
+function assinaturaDosCandidatos(candidatos) {
+    return sha(JSON.stringify(candidatos.map(c => [c.thread, c.fase, c.motivo, c.fonte ?? 'gate'])));
+}
+function lerConsentimento(raiz, estadoDir) {
+    const arquivo = arquivoDoConsentimento(raiz, estadoDir);
+    if (!fs.existsSync(arquivo))
+        return undefined;
+    const salvo = JSON.parse(fs.readFileSync(arquivo, 'utf8'));
+    if (salvo.versao !== 1 || salvo.pedido?.contrato !== exports.CONTRATO_CONSENTIMENTO) {
+        throw new Error('consentimento do pulse: estado inválido; exige inspeção');
+    }
+    // Estado gravado antes do GO-FIX 1 nao guardava candidatos: sem eles, o sim nao tem o que servir.
+    if (!Array.isArray(salvo.pedido.candidatos)) {
+        salvo.pedido = { ...salvo.pedido, candidatos: [], candidatosSha256: assinaturaDosCandidatos([]) };
+    }
+    return salvo;
+}
+function gravar(raiz, estado, estadoDir) {
+    const arquivo = arquivoDoConsentimento(raiz, estadoDir);
+    fs.mkdirSync(path.dirname(arquivo), { recursive: true });
+    const tmp = arquivo + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify(estado) + '\n', { mode: 0o600 });
+    fs.renameSync(tmp, arquivo);
+}
+/** O pedido que ainda vale agora: aberto, dentro do prazo e sem resposta gravada. */
+function consentimentoVigente(raiz, quando, estadoDir) {
+    const estado = lerConsentimento(raiz, estadoDir);
+    if (!estado || estado.respondido)
+        return undefined;
+    return Date.parse(quando) < Date.parse(estado.pedido.prazo) ? estado.pedido : undefined;
+}
+/**
+ * Abre o pedido que acompanha um resumo. Um pedido vigente NAO e substituido: trocar o codigo
+ * debaixo de quem esta digitando e o defeito que fez a mesma pergunta sair com tres
+ * identificadores diferentes entre 16/09 e 20/09.
+ */
+function abrirConsentimento(raiz, entrada) {
+    const candidatos = [...(entrada.candidatos ?? [])];
+    const candidatosSha256 = assinaturaDosCandidatos(candidatos);
+    const vigente = consentimentoVigente(raiz, entrada.quando, entrada.estadoDir);
+    if (vigente && vigente.resumoSha256 === entrada.resumoSha256 && vigente.candidatosSha256 === candidatosSha256)
+        return vigente;
+    const anterior = lerConsentimento(raiz, entrada.estadoDir)?.pedido.codigo;
+    const prazoMin = entrada.prazoMin ?? exports.PRAZO_PADRAO_MIN;
+    const pedido = {
+        contrato: exports.CONTRATO_CONSENTIMENTO, id: (0, node_crypto_1.randomUUID)(),
+        // O codigo novo nunca repete o anterior: um "sim" atrasado ao resumo velho nao vale para o novo.
+        codigo: gerarCodigo(anterior ? [anterior] : []),
+        criadoEm: entrada.quando,
+        prazo: new Date(Date.parse(entrada.quando) + prazoMin * 60000).toISOString(),
+        acumuladas: candidatos.length, resumoSha256: entrada.resumoSha256, candidatos, candidatosSha256,
+    };
+    gravar(raiz, { versao: 1, pedido }, entrada.estadoDir);
+    return pedido;
+}
+/**
+ * Recebe a resposta do dono pelo codigo curto.
+ *
+ * A ordem importa e e a mesma do gate: primeiro proveniencia, depois conteudo. Um envelope sem
+ * assinatura valida nunca chega a ser interpretado como "sim", e por isso texto malformado de
+ * origem nao autenticada nao consegue liberar lote nenhum. O envelope e o que o ingresso assinou
+ * para o endereco do pulse, com o texto que o dono digitou ("P4EJ a").
+ *
+ * Repetir a MESMA resposta devolve o que ja foi decidido, inclusive por outra mensagem: o dono que
+ * nao viu o lote chegar manda "P4EJ a" de novo e recebe o mesmo lote, nunca um lote novo. Mudar
+ * de ideia sobre o mesmo resumo e recusado com o que ja vale.
+ */
+function responderConsentimento(raiz, entrada) {
+    const quando = entrada.quando ?? new Date().toISOString();
+    const estado = lerConsentimento(raiz, entrada.estadoDir);
+    if (!estado)
+        throw new Error('consentimento do pulse: não há pedido aberto');
+    const { pedido } = estado;
+    if (pedido.codigo.toUpperCase() !== String(entrada.codigo).trim().toUpperCase()) {
+        throw new Error('consentimento do pulse: código não confere com o pedido aberto');
+    }
+    // Proveniencia primeiro, pelo caminho de sempre, no endereco do pulse.
+    (0, hitl_gates_1.autenticarResposta)(exports.ALVO_DO_PULSE, exports.ENDERECO_DA_RESPOSTA, entrada.envelope, entrada.envelope.recebidoEm);
+    (0, hitl_gates_1.autenticarResposta)(exports.ALVO_DO_PULSE, exports.ENDERECO_DA_RESPOSTA, entrada.envelope, quando);
+    const resposta = interpretarResposta(entrada.envelope.resposta, pedido.codigo);
+    const recibo = sha(entrada.envelope.prova);
+    if (estado.respondido) {
+        // Uso unico por significado: a mesma resposta do mesmo dono devolve o que ja foi decidido.
+        if (resposta !== estado.respondido.resposta || estado.respondido.por !== entrada.envelope.por) {
+            throw new Error('consentimento do pulse: já respondido; resposta divergente recusada');
+        }
+        return { resposta: estado.respondido.resposta, repetida: true, pedido, respondido: estado.respondido };
+    }
+    if (Date.parse(quando) >= Date.parse(pedido.prazo)) {
+        throw new Error('consentimento do pulse: pedido vencido; nenhuma autorização concedida');
+    }
+    if (!resposta)
+        throw new Error('consentimento do pulse: responda com a (sim) ou b (agora não)');
+    const respondido = {
+        resposta, respondidoEm: quando, mensagem: entrada.envelope.mensagem, por: entrada.envelope.por, recibo,
+    };
+    gravar(raiz, { ...estado, respondido }, entrada.estadoDir);
+    return { resposta, repetida: false, pedido, respondido };
+}
+/**
+ * Marca o lote consentido como entregue, com os numeros que ele levou. Sem isto, um sim viraria
+ * autorizacao permanente e a cada resposta sairia um lote novo, que e a inundacao voltando por
+ * outra porta. Com os numeros, repetir o sim devolve o MESMO lote.
+ */
+function marcarLoteEntregue(raiz, quando, estadoDir, numeros) {
+    const estado = lerConsentimento(raiz, estadoDir);
+    if (!estado?.respondido || estado.respondido.resposta !== 'sim')
+        throw new Error('consentimento do pulse: não há sim para servir');
+    if (estado.respondido.loteEntregueEm)
+        throw new Error('consentimento do pulse: este sim já serviu um lote');
+    gravar(raiz, { ...estado, respondido: { ...estado.respondido, loteEntregueEm: quando, numeros: [...numeros] } }, estadoDir);
+}