@orkastery/cli 0.5.6 → 0.6.1

package/dist/noctum-arco.js

@@ -33,19 +33,27 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PRAZO_PARA_AUTORIZAR_MIN = exports.TEXTO_DE_REVOGACAO = exports.textoDeAutorizacao = exports.enderecoDoArco = exports.ALVO_DO_NOCTUM = exports.CONTRATO_ARCO = void 0;
+exports.MOTIVOS_DE_ENCERRAMENTO = exports.PRAZO_PARA_AUTORIZAR_MIN = exports.TEXTO_DE_REVOGACAO = exports.textoDeAutorizacao = exports.enderecoDoArco = exports.ALVO_DO_NOCTUM = exports.CONTRATO_ARCO = void 0;
 exports.contextoDoArco = contextoDoArco;
 exports.hashDaRevogacao = hashDaRevogacao;
 exports.proporEnvelope = proporEnvelope;
+exports.codigosDosArcos = codigosDosArcos;
+exports.pedirRevogacao = pedirRevogacao;
+exports.perguntasDoArco = perguntasDoArco;
 exports.autorizarPeloIngresso = autorizarPeloIngresso;
 exports.revogarPeloIngresso = revogarPeloIngresso;
+exports.autorizarPelaResposta = autorizarPelaResposta;
+exports.revogarPelaResposta = revogarPelaResposta;
 exports.criarDialogoDoArco = criarDialogoDoArco;
 exports.idDaDecisao = idDaDecisao;
 exports.enfileirarDecisao = enfileirarDecisao;
 exports.lerArco = lerArco;
+exports.lerArcoComProposta = lerArcoComProposta;
 exports.conferirAntesDoEfeito = conferirAntesDoEfeito;
 exports.reservarDespacho = reservarDespacho;
+exports.encerrarArco = encerrarArco;
 exports.concluirDespacho = concluirDespacho;
+exports.versoesAutorizadas = versoesAutorizadas;
 /**
  * RM-058, fatia N1: o estado do arco #Noctum e o ingresso do envelope.
  *
@@ -82,6 +90,8 @@ const hitl_local_receipt_1 = require("./hitl-local-receipt");
 const hitl_native_1 = require("./hitl-native");
 const hitl_public_receipt_1 = require("./hitl-public-receipt");
 const noctum_envelope_1 = require("./noctum-envelope");
+const noctum_pergunta_1 = require("./noctum-pergunta");
+const pulse_consentimento_1 = require("./pulse-consentimento");
 const thread_1 = require("./thread");
 exports.CONTRATO_ARCO = 'ork.noctum-arco/v1';
 /**
@@ -100,6 +110,13 @@ exports.TEXTO_DE_REVOGACAO = 'revogar';
 exports.PRAZO_PARA_AUTORIZAR_MIN = 60;
 /** O diálogo do host espera no máximo isto, e nunca além do prazo da proposta. */
 const ESPERA_DO_DIALOGO_MS = 300000;
+/**
+ * RM-058 N6 (D2 e D8 da ork-rm058n6): por que o arco fechou. O fechamento é ato do núcleo, não do dono: ele só registra que
+ * a hora, o teto ou a fila acabaram, e que a revogação do dono já foi tratada. RM-058, integração (D7 da ork-rm058integra):
+ * `supervisao` é a parada da supervisão da N4 (o supervisor que falhou, o teto, a violação de custo ou o ambiente do
+ * despacho), que o fechamento lê do log dela depois do revogado e da hora e antes do custo.
+ */
+exports.MOTIVOS_DE_ENCERRAMENTO = ['revogado', 'hora', 'custo', 'fila-vazia', 'supervisao'];
 const ZERO = '0'.repeat(64);
 const ARQUIVO = 'arco.jsonl';
 const sha = (s) => (0, node_crypto_1.createHash)('sha256').update(s).digest('hex');
@@ -266,11 +283,19 @@ async function comLockDoArcoAssincrono(raiz, arco, executar) {
         }
     }
 }
+/** A identidade de uma prova do dono: cada uma vale para um ato só. */
+function chaveDaProva(i) {
+    if (i.origem === 'mcp-local')
+        return `mcp-local:${i.solicitacao}`;
+    if (i.origem === 'terminal')
+        return `terminal:${i.solicitacao}`;
+    return `${i.origem}:${i.mensagem}`;
+}
 function derivar(linhas) {
     const d = { propostas: new Map(), ultima: null, autorizacao: null, revogacao: null, decisoes: [], usadas: new Set(),
-        despachos: new Map() };
+        despachos: new Map(), encerramento: null, revogacoesPedidas: [] };
     const usar = (i) => {
-        const prova = i.origem === 'mcp-local' ? `mcp-local:${i.solicitacao}` : `${i.origem}:${i.mensagem}`;
+        const prova = chaveDaProva(i);
         // Uma prova do dono vale para um ato só: reaproveitada noutra linha, o log foi emendado à mão.
         if (d.usadas.has(prova))
             throw adulterado('a mesma prova do dono aparece em dois atos do log');
@@ -294,8 +319,23 @@ function derivar(linhas) {
                 Object.assign(r, { desfecho: 'recusado', motivo: e.motivo, concluidoEm: em });
             continue;
         }
+        if (e.tipo === 'encerrado') {
+            // O fechamento é um só e vem depois da autorização: outra linha assim só existe num log emendado à mão.
+            if (!d.autorizacao || d.encerramento)
+                throw adulterado('encerramento sem autorização ou repetido');
+            d.encerramento = { motivo: e.motivo, detalhe: e.detalhe, em, versao: d.autorizacao.versao, envelopeSha256: d.autorizacao.envelopeSha256 };
+            continue;
+        }
+        if (e.tipo === 'revogacao_pedida') {
+            // Pergunta de revogação sem autorização antes dela só existe num log emendado à mão.
+            if (!d.autorizacao)
+                throw adulterado('pergunta de revogação sem autorização');
+            d.revogacoesPedidas.push({ codigo: e.codigo, prazo: e.prazo, em });
+            continue;
+        }
         if (e.tipo === 'proposto') {
-            const p = { versao: e.versao, envelopeSha256: e.envelopeSha256, conteudo: e.conteudo, prazo: e.prazo };
+            const p = { versao: e.versao, envelopeSha256: e.envelopeSha256, conteudo: e.conteudo, prazo: e.prazo, em,
+                ...(typeof e.codigo === 'string' ? { codigo: e.codigo } : {}) };
             if ((0, noctum_envelope_1.hashDoEnvelope)(p.conteudo) !== p.envelopeSha256)
                 throw adulterado(`proposta ${p.versao} com hash que não confere`);
             d.propostas.set(p.versao, p);
@@ -304,6 +344,8 @@ function derivar(linhas) {
         else if (e.tipo === 'autorizado') {
             if (d.propostas.get(e.versao)?.envelopeSha256 !== e.envelopeSha256)
                 throw adulterado(`autorização da versão ${e.versao} sem proposta`);
+            if (d.encerramento)
+                throw adulterado(`autorização da versão ${e.versao} depois do encerramento`);
             d.autorizacao = { versao: e.versao, envelopeSha256: e.envelopeSha256, ingresso: e.ingresso };
             usar(e.ingresso);
         }
@@ -321,6 +363,8 @@ function situacao(d, quando) {
         return 'revogado';
     if (!d.autorizacao)
         return 'proposto';
+    if (d.encerramento)
+        return 'encerrado';
     const janela = d.propostas.get(d.autorizacao.versao).conteudo.janela;
     const agora = Date.parse(quando);
     if (agora < Date.parse(janela.inicio))
@@ -329,13 +373,19 @@ function situacao(d, quando) {
 }
 function estadoDe(arco, d, quando) {
     const vigente = d.autorizacao ? d.propostas.get(d.autorizacao.versao) : null;
-    const pendente = d.ultima && !d.revogacao && d.ultima.versao !== d.autorizacao?.versao &&
+    const pendente = d.ultima && !d.revogacao && !d.encerramento && d.ultima.versao !== d.autorizacao?.versao &&
         Date.parse(quando) < Date.parse(d.ultima.prazo) ? d.ultima : null;
-    return { contrato: exports.CONTRATO_ARCO, arco, situacao: situacao(d, quando), versao: vigente?.versao ?? null,
+    const sit = situacao(d, quando);
+    // RM-057 (resposta curta): só a última pergunta de revogação espera o dono, e só com o arco ainda de pé.
+    const rev = d.revogacoesPedidas.at(-1);
+    const revogacaoPedida = rev && (sit === 'vigente' || sit === 'agendado') && Date.parse(quando) < Date.parse(rev.prazo)
+        ? { codigo: rev.codigo, prazo: rev.prazo, pedidaEm: rev.em } : null;
+    return { contrato: exports.CONTRATO_ARCO, arco, situacao: sit, versao: vigente?.versao ?? null,
         envelopeSha256: vigente?.envelopeSha256 ?? null, conteudo: vigente?.conteudo ?? null,
         autorizadoPor: d.autorizacao?.ingresso ?? null, revogadoPor: d.revogacao,
-        propostaPendente: pendente ? { versao: pendente.versao, envelopeSha256: pendente.envelopeSha256, prazo: pendente.prazo } : null,
-        decisoes: d.decisoes, despachos: [...d.despachos.values()], consumo: consumoDe(d) };
+        propostaPendente: pendente ? { versao: pendente.versao, envelopeSha256: pendente.envelopeSha256, prazo: pendente.prazo,
+            ...(pendente.codigo ? { codigo: pendente.codigo } : {}) } : null,
+        decisoes: d.decisoes, despachos: [...d.despachos.values()], consumo: consumoDe(d), encerramento: d.encerramento, revogacaoPedida };
 }
 /** D12 da ork-rm058n2: a reserva consome uma sessão até ser recusada; a concluída e a pendente contam. */
 function consumoDe(d) {
@@ -355,7 +405,7 @@ function consumoDe(d) {
  * A mesma proposta repetida devolve a que está pendente. Proposta nova sobre um envelope já
  * autorizado é emenda: o vigente continua valendo até o dono autorizar a nova versão.
  */
-function proporEnvelope(raiz, pedido, quando = new Date().toISOString()) {
+function proporEnvelope(raiz, pedido, quando = new Date().toISOString(), emUso = []) {
     const conteudo = (0, noctum_envelope_1.validarPedidoDeAbertura)(pedido);
     const envelopeSha256 = (0, noctum_envelope_1.hashDoEnvelope)(conteudo);
     if (!(Date.parse(quando) < Date.parse(conteudo.janela.fim))) {
@@ -365,6 +415,8 @@ function proporEnvelope(raiz, pedido, quando = new Date().toISOString()) {
         const log = lerLog(raiz, conteudo.arco), d = derivar(log.linhas);
         if (d.revogacao)
             throw new noctum_envelope_1.RecusaDoArco('noctum.efeito.revogado', 'arco revogado é terminal; abra outro arco');
+        if (d.encerramento)
+            throw new noctum_envelope_1.RecusaDoArco('noctum.efeito.encerrado', `arco encerrado (${d.encerramento.motivo}) é terminal; abra outro arco`);
         const resumo = (0, noctum_envelope_1.resumoDoEnvelope)(conteudo, envelopeSha256);
         const pendente = estadoDe(conteudo.arco, d, quando).propostaPendente;
         if (pendente?.envelopeSha256 === envelopeSha256)
@@ -376,9 +428,90 @@ function proporEnvelope(raiz, pedido, quando = new Date().toISOString()) {
         exigirEmendaSemProrrogar(d, conteudo, quando);
         const versao = (d.ultima?.versao ?? 0) + 1;
         const prazo = new Date(Date.parse(quando) + exports.PRAZO_PARA_AUTORIZAR_MIN * 60000).toISOString();
-        anexar(raiz, conteudo.arco, log, { tipo: 'proposto', versao, envelopeSha256, conteudo, prazo }, quando);
-        return { arco: conteudo.arco, versao, envelopeSha256, prazo, resumo };
+        // RM-057 (resposta curta, D2): a pergunta nasce com a proposta, com um código que nenhuma outra pergunta usa agora.
+        const codigo = (0, pulse_consentimento_1.gerarCodigo)([...emUso, ...codigosDosArcos(raiz)]);
+        anexar(raiz, conteudo.arco, log, { tipo: 'proposto', versao, envelopeSha256, conteudo, prazo, codigo }, quando);
+        return { arco: conteudo.arco, versao, envelopeSha256, prazo, resumo, codigo };
+    });
+}
+/**
+ * RM-057 (resposta curta): os códigos das perguntas de todos os arcos desta raiz, para um código novo nunca repetir um
+ * deles. Arco que não se lê não contribui (a resolução por código recusa o ambíguo de qualquer jeito).
+ */
+function codigosDosArcos(raiz) {
+    let nomes;
+    try {
+        nomes = fs.readdirSync(path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'noctum', 'arcos')).filter(n => noctum_envelope_1.ID_DO_ARCO.test(n));
+    }
+    catch {
+        return [];
+    }
+    const codigos = [];
+    for (const arco of nomes) {
+        try {
+            const d = derivar(lerLog(raiz, arco).linhas);
+            for (const p of d.propostas.values())
+                if (p.codigo)
+                    codigos.push(p.codigo);
+            for (const r of d.revogacoesPedidas)
+                codigos.push(r.codigo);
+        }
+        catch { /* arco ilegível não empresta código */ }
+    }
+    return codigos;
+}
+/**
+ * RM-057 (resposta curta, D10 da ork-rm057respost): abre a pergunta de revogação ao dono. Não revoga nada: quem revoga é
+ * a resposta dele, pela prova do canal ou do terminal. A pergunta que ainda espera o dono é devolvida, em vez de outra.
+ */
+function pedirRevogacao(raiz, arco, quando = new Date().toISOString(), emUso = []) {
+    return comLockDoArco(raiz, arco, false, () => {
+        const log = lerLog(raiz, arco), d = derivar(log.linhas);
+        if (d.revogacao)
+            throw new noctum_envelope_1.RecusaDoArco('noctum.efeito.revogado', `o arco ${arco} já foi revogado`);
+        if (d.encerramento)
+            throw new noctum_envelope_1.RecusaDoArco('noctum.efeito.encerrado', `arco ${arco} encerrado (${d.encerramento.motivo}) é terminal`);
+        if (!d.autorizacao) {
+            throw new noctum_envelope_1.RecusaDoArco('noctum.efeito.sem-autorizacao', `o arco ${arco} nunca foi autorizado: não há o que revogar, e a proposta vence sozinha`);
+        }
+        const estado = estadoDe(arco, d, quando);
+        if (estado.situacao === 'expirado')
+            throw new noctum_envelope_1.RecusaDoArco('noctum.efeito.expirado', `o arco ${arco} já terminou; não há o que revogar`);
+        const base = { arco, versao: d.autorizacao.versao, envelopeSha256: d.autorizacao.envelopeSha256 };
+        if (estado.revogacaoPedida)
+            return { ...base, codigo: estado.revogacaoPedida.codigo, prazo: estado.revogacaoPedida.prazo, nova: false };
+        const codigo = (0, pulse_consentimento_1.gerarCodigo)([...emUso, ...codigosDosArcos(raiz)]);
+        const prazo = new Date(Date.parse(quando) + exports.PRAZO_PARA_AUTORIZAR_MIN * 60000).toISOString();
+        anexar(raiz, arco, log, { tipo: 'revogacao_pedida', codigo, prazo }, quando);
+        return { ...base, codigo, prazo, nova: true };
+    });
+}
+/**
+ * RM-057 (resposta curta): as perguntas do arco ao dono, derivadas do log a cada leitura, com a situação de cada uma.
+ * Só a `pendente` aceita resposta; as outras existem para a resposta atrasada ouvir o porquê, nunca para valer.
+ */
+function perguntasDoArco(raiz, arco, quando = new Date().toISOString()) {
+    const d = derivar(lerLog(raiz, arco).linhas);
+    const estado = estadoDe(arco, d, quando);
+    const terminal = d.revogacao !== null || d.encerramento !== null;
+    const perguntas = [];
+    for (const p of d.propostas.values()) {
+        if (!p.codigo)
+            continue;
+        const situacao = d.autorizacao?.versao === p.versao ? 'respondida'
+            : d.ultima?.versao !== p.versao ? 'substituida' : terminal ? 'arco-terminal'
+                : estado.propostaPendente?.versao === p.versao && Date.parse(quando) < Date.parse(p.conteudo.janela.fim) ? 'pendente' : 'vencida';
+        perguntas.push({ contrato: noctum_pergunta_1.CONTRATO_PERGUNTA_DO_ARCO, arco, ato: 'autorizar', codigo: p.codigo, versao: p.versao,
+            envelopeSha256: p.envelopeSha256, criadaEm: p.em, prazo: p.prazo, conteudo: p.conteudo, situacao });
+    }
+    const vigente = d.autorizacao ? d.propostas.get(d.autorizacao.versao) ?? null : null;
+    d.revogacoesPedidas.forEach((r, i) => {
+        const situacao = d.revogacao ? 'respondida' : i < d.revogacoesPedidas.length - 1 ? 'substituida'
+            : d.encerramento ? 'arco-terminal' : estado.revogacaoPedida?.codigo === r.codigo ? 'pendente' : 'vencida';
+        perguntas.push({ contrato: noctum_pergunta_1.CONTRATO_PERGUNTA_DO_ARCO, arco, ato: 'revogar', codigo: r.codigo, versao: vigente?.versao ?? null,
+            envelopeSha256: vigente?.envelopeSha256 ?? null, criadaEm: r.em, prazo: r.prazo, conteudo: vigente?.conteudo ?? null, situacao });
     });
+    return perguntas;
 }
 /**
  * D7: emenda é versão nova com prova nova, mas não prorroga nada. Ela mantém o início, não passa do
@@ -394,11 +527,20 @@ function exigirEmendaSemProrrogar(d, conteudo, quando) {
     if (Date.parse(conteudo.janela.inicio) !== Date.parse(janela.inicio) || Date.parse(conteudo.janela.fim) > Date.parse(janela.fim)) {
         throw new noctum_envelope_1.RecusaDoArco('noctum.envelope.invalido', 'emenda mantém o início e não prorroga o fim do envelope autorizado');
     }
+    // RM-058 N3 (A4 da revisão da ork-rm058n3): a emenda não troca o contrato entre a `v3` e as outras. O consumo e as sessões de
+    // uma máquina só não estão no ramo de coordenação, e a soma entre máquinas os perderia; o arco entre máquinas nasce assim.
+    const antes = d.propostas.get(d.autorizacao.versao).conteudo.contrato;
+    if ((antes === noctum_envelope_1.CONTRATO_ENVELOPE_V3) !== (conteudo.contrato === noctum_envelope_1.CONTRATO_ENVELOPE_V3)) {
+        throw new noctum_envelope_1.RecusaDoArco('noctum.envelope.invalido', `a emenda não troca o contrato de ${antes} para ${conteudo.contrato}: ` +
+            'o arco entre máquinas começa como tal, e o de uma máquina segue assim; abra outro arco');
+    }
 }
 /** A proposta que o dono pode autorizar agora, ou a recusa tipada de por que não. */
 function propostaAutorizavel(d, envelopeSha256, quando) {
     if (d.revogacao)
         throw new noctum_envelope_1.RecusaDoArco('noctum.efeito.revogado', 'arco revogado é terminal; abra outro arco');
+    if (d.encerramento)
+        throw new noctum_envelope_1.RecusaDoArco('noctum.efeito.encerrado', `arco encerrado (${d.encerramento.motivo}) é terminal; abra outro arco`);
     if (!d.ultima)
         throw new noctum_envelope_1.RecusaDoArco('noctum.efeito.sem-autorizacao', 'arco sem proposta');
     if (d.ultima.envelopeSha256 !== envelopeSha256) {
@@ -448,7 +590,9 @@ function provarEnvelope(arco, texto, envelope, quando, amarra) {
 function dadosDoRecibo(arco, ato, envelopeSha256, versao, i) {
     return { contrato: 'ork.noctum-ingresso/v1', arco, endereco: (0, exports.enderecoDoArco)(arco), ato, envelopeSha256, versao,
         origem: i.origem, canal: i.canal, conta: i.conta, por: i.por, mensagem: i.mensagem, recebidoEm: i.recebidoEm,
-        recibo: i.recibo, ...(i.origem === 'native' ? { native: i.native } : {}) };
+        recibo: i.recibo, ...(i.origem === 'native' ? { native: i.native } : {}),
+        // RM-057 (resposta curta, D7): a pergunta e o endereço que o gateway assinou entram no MAC do canal.
+        ...(i.origem === 'telegram' && i.pergunta ? { pergunta: i.pergunta } : {}) };
 }
 function lerPrivado(file) {
     const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
@@ -509,6 +653,8 @@ function gravarRecibo(raiz, arco, ato, envelopeSha256, versao, i) {
 function reciboConfere(raiz, arco, ato, envelopeSha256, versao, i) {
     if (i.origem === 'mcp-local')
         return 'ok';
+    if (i.origem === 'terminal')
+        return reciboDoTerminalConfere(raiz, arco, ato, envelopeSha256, versao, i);
     try {
         const nome = nomeDoRecibo(i);
         if (i.evidencia !== `.orkastery/noctum/arcos/${arco}/ingresso/${nome}`)
@@ -561,15 +707,29 @@ function confirmado(raiz, arco, quando, vale, ato) {
         throw adulterado(`a ${ato} não ficou gravada no log`);
     return estado;
 }
-/** Autoriza a proposta pendente pelo envelope assinado do dono. Sem prova, nada muda. */
-function autorizarPeloIngresso(raiz, arco, envelopeSha256, envelope, quando = new Date().toISOString()) {
+/**
+ * Autoriza a proposta pendente pelo envelope assinado do dono. Sem prova, nada muda. `info.repetida` diz, decidido sob
+ * o lock do arco, que o ato já valia antes desta mensagem (o gateway não confirma de novo ao dono).
+ */
+function autorizarPeloIngresso(raiz, arco, envelopeSha256, envelope, quando = new Date().toISOString(), info) {
     return comLockDoArco(raiz, arco, false, () => {
         const log = lerLog(raiz, arco), d = derivar(log.linhas);
         const versao = d.ultima?.envelopeSha256 === envelopeSha256 ? d.ultima.versao : 0;
         const provado = provarEnvelope(arco, (0, exports.textoDeAutorizacao)(envelopeSha256), envelope, quando, { pedidoSha256: envelopeSha256, contexto: contextoDoArco(arco, versao), prazo: d.ultima?.prazo });
-        // A mesma autorização repetida, pela mesma mensagem, devolve o que já vale.
-        if (d.autorizacao?.envelopeSha256 === envelopeSha256 && !d.revogacao)
-            return estadoDe(arco, d, quando);
+        // A mesma autorização repetida devolve o que já vale; no arco que já acabou, a recusa tipada chega ao gateway, que
+        // responde ao dono, em vez de um ok mudo (RM-058 N6).
+        if (d.autorizacao?.envelopeSha256 === envelopeSha256 && !d.revogacao) {
+            const atual = estadoDe(arco, d, quando);
+            if (atual.situacao === 'encerrado') {
+                throw new noctum_envelope_1.RecusaDoArco('noctum.efeito.encerrado', `arco ${arco} encerrado (${d.encerramento?.motivo ?? 'fechado'}) é terminal; abra outro arco`);
+            }
+            if (atual.situacao === 'expirado') {
+                throw new noctum_envelope_1.RecusaDoArco('noctum.efeito.expirado', `o arco ${arco} terminou em ${atual.conteudo?.janela.fim ?? 'o fim da janela'}; abra outro arco`);
+            }
+            if (info)
+                info.repetida = true;
+            return atual;
+        }
         if (d.usadas.has(`${provado.origem}:${provado.mensagem}`))
             throw semProva('esta mensagem já provou outro ato neste arco');
         const proposta = propostaAutorizavel(d, envelopeSha256, quando);
@@ -578,13 +738,16 @@ function autorizarPeloIngresso(raiz, arco, envelopeSha256, envelope, quando = ne
         return confirmado(raiz, arco, quando, e => e.envelopeSha256 === envelopeSha256 && e.situacao !== 'revogado', 'autorização');
     });
 }
-/** Revoga o arco pelo envelope assinado do dono. Terminal: nenhum efeito passa depois (D7). */
-function revogarPeloIngresso(raiz, arco, envelope, quando = new Date().toISOString()) {
+/** Revoga o arco pelo envelope assinado do dono. Terminal: nenhum efeito passa depois (D7). `info.repetida`: já valia. */
+function revogarPeloIngresso(raiz, arco, envelope, quando = new Date().toISOString(), info) {
     return comLockDoArco(raiz, arco, false, () => {
         const log = lerLog(raiz, arco), d = derivar(log.linhas);
         const provado = provarEnvelope(arco, exports.TEXTO_DE_REVOGACAO, envelope, quando, { pedidoSha256: hashDaRevogacao(arco), contexto: contextoDoArco(arco, 0) });
-        if (d.revogacao)
+        if (d.revogacao) {
+            if (info)
+                info.repetida = true;
             return estadoDe(arco, d, quando);
+        }
         if (d.usadas.has(`${provado.origem}:${provado.mensagem}`))
             throw semProva('esta mensagem já provou outro ato neste arco');
         // O recibo da revogação é auditoria e nunca é reconferido: falha nele não segura o ato de segurança, e o motivo fica na linha.
@@ -601,6 +764,274 @@ function revogarPeloIngresso(raiz, arco, envelope, quando = new Date().toISOStri
         return confirmado(raiz, arco, quando, e => e.situacao === 'revogado', 'revogação');
     }, true);
 }
+// ---------------------------------------------------------------------------
+// RM-057 (resposta curta, ork-rm057respost): os atos do dono pela resposta curta à pergunta do arco.
+// ---------------------------------------------------------------------------
+/** O domínio da subchave local que assina o recibo do terminal: o mesmo segredo do recibo local, separado por domínio. */
+const DOMINIO_DO_RECIBO_DO_TERMINAL = 'ork.noctum-terminal/v1';
+/** A resposta curta já lida pelo núcleo: o código da pergunta, a letra e o hash do texto do dono. */
+function validarRespostaAPergunta(r) {
+    if (!objeto(r) || typeof r.codigo !== 'string' || !pulse_consentimento_1.CODIGO_CURTO.test(r.codigo) || !['a', 'b', 'c'].includes(String(r.letra)) ||
+        typeof r.respostaSha256 !== 'string' || !/^[a-f0-9]{64}$/.test(r.respostaSha256) ||
+        (r.numero !== undefined && (!Number.isInteger(r.numero) || r.numero < 1 || r.numero > 99))) {
+        throw semProva('a resposta curta chegou malformada');
+    }
+    return { codigo: r.codigo, letra: r.letra, respostaSha256: r.respostaSha256,
+        ...(r.numero !== undefined ? { numero: r.numero } : {}) };
+}
+/**
+ * A prova da resposta curta. Pelo canal, a MESMA `autenticarResposta` do HITL, no endereço do pulse que o gateway assinou
+ * (`resposta`, ou `resposta:<código>` no reply), no instante do envelope e no de agora, com o texto assinado igual ao que o
+ * núcleo leu. Pelo terminal, o atestado da origem da sessão, conferido por `noctum-terminal.ts` (D5): a fronteira dele é
+ * a conta do sistema, como a do diálogo nativo.
+ */
+function provarRespostaCurta(prova, quando) {
+    if (!objeto(prova))
+        throw semProva('a resposta curta precisa de prova');
+    const pergunta = validarRespostaAPergunta(prova.pergunta);
+    if (prova.via === 'pulse') {
+        const e = prova.envelope;
+        if (!objeto(e) || e.origem !== 'telegram')
+            throw semProva('a resposta curta pelo canal precisa do envelope assinado do Telegram');
+        // GO-FIX 1 (achado 4): o endereço assinado é o do pulse ou o do reply à MESMA pergunta, `resposta:<código dela>:<id>`;
+        // o recibo nunca diz uma pergunta e autoriza outra.
+        const ref = typeof prova.endereco === 'string' && prova.endereco.startsWith(`${pulse_consentimento_1.ENDERECO_DA_RESPOSTA}:`)
+            ? (0, pulse_consentimento_1.lerReferenciaDoReply)(prova.endereco.slice(pulse_consentimento_1.ENDERECO_DA_RESPOSTA.length + 1)) : null;
+        if (prova.endereco !== pulse_consentimento_1.ENDERECO_DA_RESPOSTA && ref?.codigo !== pergunta.codigo) {
+            throw semProva('o endereço assinado não é o do pulse nem o do reply a esta pergunta');
+        }
+        try {
+            (0, hitl_gates_1.autenticarResposta)(pulse_consentimento_1.ALVO_DO_PULSE, prova.endereco, e, e.recebidoEm);
+            (0, hitl_gates_1.autenticarResposta)(pulse_consentimento_1.ALVO_DO_PULSE, prova.endereco, e, quando);
+        }
+        catch (x) {
+            throw semProva(`ingresso não autenticado (${x.message})`);
+        }
+        if (typeof e.resposta !== 'string' || sha(e.resposta) !== pergunta.respostaSha256) {
+            throw semProva('o texto assinado não é a resposta que o núcleo leu');
+        }
+        return { origem: 'telegram', canal: e.canal ?? null, conta: e.conta ?? null, por: e.por, mensagem: e.mensagem,
+            recebidoEm: e.recebidoEm, recibo: sha(e.prova), pergunta: { ...pergunta, enderecoAssinado: { alvo: pulse_consentimento_1.ALVO_DO_PULSE, endereco: prova.endereco } } };
+    }
+    if (prova.via === 'terminal') {
+        const a = prova.atestado;
+        const idade = objeto(a) ? Date.parse(quando) - Date.parse(String(a.recebidoEm)) : NaN;
+        if (!objeto(a) || a.host !== 'claude-code' || typeof a.sessao !== 'string' || !/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,127}$/.test(a.sessao) ||
+            (a.entrypoint !== null && (typeof a.entrypoint !== 'string' || a.entrypoint.length > 64)) || !Array.isArray(a.conferencias) ||
+            !a.conferencias.length || a.conferencias.some(c => typeof c !== 'string' || c.length > 80) ||
+            !Number.isFinite(idade) || idade < 0 || idade > 60000) {
+            throw semProva('o atestado do terminal chegou malformado ou fora da janela de 60 s');
+        }
+        return { origem: 'terminal', host: 'claude-code', sessao: a.sessao, entrypoint: a.entrypoint, conferencias: [...a.conferencias],
+            recebidoEm: a.recebidoEm, solicitacao: (0, node_crypto_1.randomUUID)(), por: 'terminal:claude-code', pergunta };
+    }
+    throw semProva('a resposta curta chegou por uma via desconhecida');
+}
+/** A subchave do recibo do terminal. */
+function chaveDoTerminal(raiz, criar) {
+    return (0, node_crypto_1.createHmac)('sha256', (0, hitl_local_receipt_1.chaveLocal)(raiz, criar)).update(DOMINIO_DO_RECIBO_DO_TERMINAL).digest();
+}
+const nomeDoReciboDoTerminal = (i) => `${sha(`terminal:${i.solicitacao}`)}.json`;
+function dadosDoReciboDoTerminal(arco, ato, envelopeSha256, versao, i) {
+    return { contrato: 'ork.noctum-ingresso/v1', arco, endereco: (0, exports.enderecoDoArco)(arco), ato, envelopeSha256, versao, origem: 'terminal',
+        host: i.host, sessao: i.sessao, entrypoint: i.entrypoint, conferencias: i.conferencias, solicitacao: i.solicitacao, por: i.por,
+        recebidoEm: i.recebidoEm, pergunta: i.pergunta };
+}
+/** O recibo do terminal, com a subchave local: a conferência antes do efeito o relê, como relê o do canal. */
+function gravarReciboDoTerminal(raiz, arco, ato, envelopeSha256, versao, i) {
+    const dir = path.join(dirDoArco(raiz, arco), 'ingresso');
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const nome = nomeDoReciboDoTerminal(i), file = path.join(dir, nome);
+    const dados = dadosDoReciboDoTerminal(arco, ato, envelopeSha256, versao, i);
+    const bytes = JSON.stringify({ dados, assinatura: (0, node_crypto_1.createHmac)('sha256', chaveDoTerminal(raiz, true)).update(JSON.stringify(dados)).digest('hex') });
+    const temp = path.join(dir, `${(0, node_crypto_1.randomUUID)()}.tmp`);
+    const fd = fs.openSync(temp, 'wx', 0o600);
+    try {
+        fs.writeFileSync(fd, bytes);
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    try {
+        fs.linkSync(temp, file);
+    }
+    catch (e) {
+        if (e.code !== 'EEXIST')
+            throw e;
+    }
+    finally {
+        fs.unlinkSync(temp);
+    }
+    if (lerPrivado(file).toString('utf8') !== bytes)
+        throw adulterado('recibo do terminal já existe com outro conteúdo');
+    return { evidencia: `.orkastery/noctum/arcos/${arco}/ingresso/${nome}`, evidenciaSha256: sha(bytes) };
+}
+/** Reconfere o recibo do terminal: o arquivo privado, o hash, os dados iguais aos da linha e o MAC da subchave local. */
+function reciboDoTerminalConfere(raiz, arco, ato, envelopeSha256, versao, i) {
+    try {
+        const nome = nomeDoReciboDoTerminal(i);
+        if (i.evidencia !== `.orkastery/noctum/arcos/${arco}/ingresso/${nome}`)
+            return 'falhou';
+        const bytes = lerPrivado(path.join(dirDoArco(raiz, arco), 'ingresso', nome));
+        if (sha(bytes) !== i.evidenciaSha256)
+            return 'falhou';
+        const v = JSON.parse(bytes.toString('utf8'));
+        const { evidencia: _evidencia, evidenciaSha256: _sha, semRecibo: _sem, ...atestado } = i;
+        if (!objeto(v) || Object.keys(v).sort().join(',') !== 'assinatura,dados' || typeof v.assinatura !== 'string' ||
+            !/^[a-f0-9]{64}$/.test(v.assinatura) || (0, noctum_envelope_1.canonico)(v.dados) !== (0, noctum_envelope_1.canonico)(dadosDoReciboDoTerminal(arco, ato, envelopeSha256, versao, atestado))) {
+            return 'falhou';
+        }
+        return (0, node_crypto_1.timingSafeEqual)(Buffer.from(v.assinatura, 'hex'), (0, node_crypto_1.createHmac)('sha256', chaveDoTerminal(raiz, false)).update(JSON.stringify(v.dados)).digest())
+            ? 'ok' : 'falhou';
+    }
+    catch {
+        return 'falhou';
+    }
+}
+/** GO-FIX 1 (achado 6 da ork-rm057respost): a resposta não é de antes da pergunta; a mensagem velha não responde à nova. */
+function exigirDepoisDaPergunta(provado, criadaEm) {
+    if (!(Date.parse(provado.recebidoEm) >= Date.parse(criadaEm)))
+        throw semProva('a mensagem é de antes da pergunta que ela diz responder');
+}
+/**
+ * GO-FIX 1 (achado 6 da ork-rm057respost): uma mensagem assinada do dono responde a UMA pergunta. A conferência de "uma
+ * prova, um ato" do log vale por arco; esta vale para todos: a mensagem é reivindicada num arquivo privado por mensagem,
+ * criado de uma vez (link exclusivo) antes do ato. A mesma mensagem de novo, para a mesma pergunta e o mesmo ato, segue ao
+ * caminho de sempre (repetida); para outra pergunta, de qualquer arco, é recusada antes de gravar, mesmo dentro dos 60 s
+ * da assinatura (a reentrega do gateway depois de reiniciar, ou um processo que reapresente o envelope).
+ */
+function reivindicarMensagem(raiz, chave, alvo, quando) {
+    const principal = (0, estado_thread_1.raizDoEstado)(raiz);
+    (0, estado_thread_1.exigirEstadoSemLink)(principal, ['.orkastery', 'noctum', 'mensagens-usadas']);
+    const dir = path.join(principal, '.orkastery', 'noctum', 'mensagens-usadas');
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const file = path.join(dir, `${sha(chave)}.json`);
+    const dados = JSON.stringify({ contrato: 'ork.noctum-mensagem-usada/v1', mensagemSha256: sha(chave), ...alvo, em: quando });
+    const temp = path.join(dir, `${(0, node_crypto_1.randomUUID)()}.tmp`);
+    const fd = fs.openSync(temp, 'wx', 0o600);
+    try {
+        fs.writeFileSync(fd, dados);
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    try {
+        fs.linkSync(temp, file);
+        return;
+    }
+    catch (e) {
+        if (e.code !== 'EEXIST')
+            throw e;
+    }
+    finally {
+        fs.unlinkSync(temp);
+    }
+    let antes;
+    try {
+        antes = JSON.parse(lerPrivado(file).toString('utf8'));
+    }
+    catch {
+        throw semProva('o registro desta mensagem não se lê; nada foi gravado');
+    }
+    if (!objeto(antes) || antes.arco !== alvo.arco || antes.codigo !== alvo.codigo || antes.ato !== alvo.ato) {
+        throw semProva('esta mensagem já respondeu a outra pergunta; mande outra');
+    }
+}
+/** O ingresso do dono com o recibo durável da via (o do canal ou o do terminal). */
+function comRecibo(raiz, arco, ato, envelopeSha256, versao, provado) {
+    return provado.origem === 'terminal'
+        ? { ...provado, ...gravarReciboDoTerminal(raiz, arco, ato, envelopeSha256, versao, provado) }
+        : { ...provado, ...gravarRecibo(raiz, arco, ato, envelopeSha256, versao, provado) };
+}
+/**
+ * RM-057 (resposta curta): autoriza a proposta pela resposta curta do dono à pergunta dela. O hash vem da pergunta (a
+ * proposta com este código), nunca da resposta. Sob o lock do arco: a pergunta tem de ser a de agora (a proposta mais
+ * nova, no prazo e na janela), a prova não pode ter servido a outro ato, e o ato só volta com sucesso relido do disco.
+ */
+function autorizarPelaResposta(raiz, arco, codigo, prova, quando = new Date().toISOString(), info) {
+    return comLockDoArco(raiz, arco, false, () => {
+        const log = lerLog(raiz, arco), d = derivar(log.linhas);
+        const proposta = [...d.propostas.values()].find(p => p.codigo === codigo);
+        if (!proposta)
+            throw new noctum_envelope_1.RecusaDoArco('noctum.pergunta.desconhecida', `o arco ${arco} não tem a pergunta ${codigo}`);
+        const provado = provarRespostaCurta(prova, quando);
+        if (provado.pergunta?.codigo !== codigo)
+            throw semProva('a prova responde a outra pergunta');
+        exigirDepoisDaPergunta(provado, proposta.em);
+        if (provado.origem === 'telegram')
+            reivindicarMensagem(raiz, chaveDaProva(provado), { arco, codigo, ato: 'autorizar' }, quando);
+        if (d.autorizacao?.envelopeSha256 === proposta.envelopeSha256 && d.autorizacao.versao === proposta.versao && !d.revogacao) {
+            const atual = estadoDe(arco, d, quando);
+            if (atual.situacao === 'encerrado') {
+                throw new noctum_envelope_1.RecusaDoArco('noctum.efeito.encerrado', `arco ${arco} encerrado (${d.encerramento?.motivo ?? 'fechado'}) é terminal; abra outro arco`);
+            }
+            if (atual.situacao === 'expirado') {
+                throw new noctum_envelope_1.RecusaDoArco('noctum.efeito.expirado', `o arco ${arco} terminou em ${atual.conteudo?.janela.fim ?? 'o fim da janela'}; abra outro arco`);
+            }
+            if (info) {
+                info.repetida = true;
+                info.mesmaProva = chaveDaProva(d.autorizacao.ingresso) === chaveDaProva(provado);
+            }
+            return atual;
+        }
+        if (d.usadas.has(chaveDaProva(provado)))
+            throw semProva('esta mensagem já provou outro ato neste arco');
+        // A pergunta respondida é a de agora: a proposta mais nova, no prazo e na janela (a recusa diz por que não).
+        const autorizavel = propostaAutorizavel(d, proposta.envelopeSha256, quando);
+        const ingresso = comRecibo(raiz, arco, 'autorizar', autorizavel.envelopeSha256, autorizavel.versao, provado);
+        anexar(raiz, arco, log, { tipo: 'autorizado', versao: autorizavel.versao, envelopeSha256: autorizavel.envelopeSha256, ingresso }, quando);
+        return confirmado(raiz, arco, quando, e => e.envelopeSha256 === autorizavel.envelopeSha256 && e.situacao !== 'revogado', 'autorização');
+    });
+}
+/**
+ * RM-057 (resposta curta, D10): revoga o arco pela resposta curta do dono à pergunta de revogação. Terminal, como a
+ * revogação assinada. A pergunta tem de ser a última de revogação, no prazo; o recibo é auditoria e nunca segura o ato.
+ */
+function revogarPelaResposta(raiz, arco, codigo, prova, quando = new Date().toISOString(), info) {
+    return comLockDoArco(raiz, arco, false, () => {
+        const log = lerLog(raiz, arco), d = derivar(log.linhas);
+        const pedida = d.revogacoesPedidas.find(r => r.codigo === codigo);
+        if (!pedida)
+            throw new noctum_envelope_1.RecusaDoArco('noctum.pergunta.desconhecida', `o arco ${arco} não tem a pergunta ${codigo}`);
+        const provado = provarRespostaCurta(prova, quando);
+        if (provado.pergunta?.codigo !== codigo)
+            throw semProva('a prova responde a outra pergunta');
+        exigirDepoisDaPergunta(provado, pedida.em);
+        if (provado.origem === 'telegram')
+            reivindicarMensagem(raiz, chaveDaProva(provado), { arco, codigo, ato: 'revogar' }, quando);
+        if (d.revogacao) {
+            if (info) {
+                info.repetida = true;
+                info.mesmaProva = chaveDaProva(d.revogacao) === chaveDaProva(provado);
+            }
+            return estadoDe(arco, d, quando);
+        }
+        if (d.revogacoesPedidas.at(-1)?.codigo !== codigo) {
+            throw new noctum_envelope_1.RecusaDoArco('noctum.pergunta.substituida', `a pergunta ${codigo} foi substituída por outra de revogação`);
+        }
+        if (!(Date.parse(quando) < Date.parse(pedida.prazo))) {
+            throw new noctum_envelope_1.RecusaDoArco('noctum.pergunta.vencida', `a pergunta ${codigo} venceu em ${(0, horario_1.formatarDataHora)(pedida.prazo)}; peça a revogação de novo`);
+        }
+        if (d.usadas.has(chaveDaProva(provado)))
+            throw semProva('esta mensagem já provou outro ato neste arco');
+        let recibo;
+        try {
+            const comProva = comRecibo(raiz, arco, 'revogar', null, null, provado);
+            recibo = { evidencia: comProva.evidencia, evidenciaSha256: comProva.evidenciaSha256 };
+        }
+        catch (e) {
+            recibo = { evidencia: '', evidenciaSha256: '', semRecibo: e instanceof noctum_envelope_1.RecusaDoArco ? e.motivo : 'noctum.recibo.nao-gravado' };
+        }
+        anexar(raiz, arco, log, { tipo: 'revogado', ingresso: { ...provado, ...recibo } }, quando);
+        return confirmado(raiz, arco, quando, e => e.situacao === 'revogado', 'revogação');
+    }, true);
+}
+/** As opções do diálogo, uma por alternativa da pergunta, com o selo na recomendada. */
+function opcoesDoDialogo(ato) {
+    return (0, noctum_pergunta_1.alternativasDaPergunta)({ ato }).map(a => `${a.letra}) ${a.texto}${a.porque ? ' (Recomendação)' : ''}`);
+}
 /**
  * O diálogo nativo do host para autorizar ou revogar, com o callback de elicitação fornecido pelo
  * servidor, nunca pelos argumentos de uma ferramenta. É a mesma fronteira de `criarIngressoLocal`:
@@ -621,6 +1052,7 @@ function criarDialogoDoArco(raiz, origem, elicitar) {
         try {
             const cancelar = new Promise(r => controller.signal.addEventListener('abort', () => r({ action: 'cancel' }), { once: true }));
             const r = await Promise.race([elicitar(JSON.parse(JSON.stringify(a)), controller.signal), cancelar]);
+            // Só a primeira alternativa (a recomendada) age; adiar e mudar algo não fazem nada (D13 da ork-rm057respost).
             if (!objeto(r) || r.action !== 'accept' || !objeto(r.content) || Object.keys(r.content).length !== 1 ||
                 r.content.opcao !== a.opcoes[0])
                 throw semProva('o dono não confirmou pelo diálogo nativo do host');
@@ -641,8 +1073,11 @@ function criarDialogoDoArco(raiz, origem, elicitar) {
                 const d = derivar(lerLog(raiz, arco).linhas);
                 return propostaAutorizavel(d, envelopeSha256, new Date().toISOString());
             });
-            const a = { contrato: 'ork.noctum-dialogo/v1', arco, ato: 'autorizar', envelopeSha256,
-                resumo: (0, noctum_envelope_1.resumoDoEnvelope)(antes.conteudo, envelopeSha256), opcoes: ['Autorizar este envelope', 'Não autorizar'] };
+            const resumo = (0, noctum_envelope_1.resumoDoEnvelope)(antes.conteudo, envelopeSha256), quando = new Date().toISOString();
+            const pergunta = { contrato: noctum_pergunta_1.CONTRATO_PERGUNTA_DO_ARCO, arco, ato: 'autorizar', codigo: antes.codigo ?? '',
+                versao: antes.versao, envelopeSha256, criadaEm: antes.em, prazo: antes.prazo, conteudo: antes.conteudo };
+            const a = { contrato: 'ork.noctum-dialogo/v1', arco, ato: 'autorizar', envelopeSha256, resumo,
+                mensagem: [(0, noctum_pergunta_1.textoDoDialogoDoArco)(pergunta, quando), '', ...resumo].join('\n'), opcoes: opcoesDoDialogo('autorizar') };
             const { requestId, recebidoEm } = await perguntar(a, antes.prazo);
             // O mundo pode ter mudado enquanto o dono lia: tudo é conferido de novo sob o lock.
             return comLockDoArcoAssincrono(raiz, arco, () => {
@@ -660,9 +1095,13 @@ function criarDialogoDoArco(raiz, origem, elicitar) {
             const atual = lerArco(raiz, arco);
             if (!atual)
                 throw new noctum_envelope_1.RecusaDoArco('noctum.efeito.sem-autorizacao', `arco ${arco} sem proposta`);
-            const a = { contrato: 'ork.noctum-dialogo/v1', arco, ato: 'revogar', envelopeSha256: atual.envelopeSha256,
-                resumo: [`Revogar o arco ${arco}: nenhum efeito novo passa depois disto, e o arco não reabre`],
-                opcoes: ['Revogar o arco', 'Manter o arco'] };
+            const resumo = [`Revogar o arco ${arco}: nenhum efeito novo passa depois disto, e o arco não reabre`];
+            const quando = new Date().toISOString();
+            const pergunta = { contrato: noctum_pergunta_1.CONTRATO_PERGUNTA_DO_ARCO, arco, ato: 'revogar', codigo: atual.revogacaoPedida?.codigo ?? '',
+                versao: atual.versao, envelopeSha256: atual.envelopeSha256, criadaEm: quando,
+                prazo: atual.revogacaoPedida?.prazo ?? new Date(Date.parse(quando) + ESPERA_DO_DIALOGO_MS).toISOString(), conteudo: atual.conteudo };
+            const a = { contrato: 'ork.noctum-dialogo/v1', arco, ato: 'revogar', envelopeSha256: atual.envelopeSha256, resumo,
+                mensagem: [(0, noctum_pergunta_1.textoDoDialogoDoArco)(pergunta, quando), '', ...resumo].join('\n'), opcoes: opcoesDoDialogo('revogar') };
             const { requestId, recebidoEm } = await perguntar(a, undefined);
             return comLockDoArcoAssincrono(raiz, arco, () => {
                 const log = lerLog(raiz, arco), d = derivar(log.linhas);
@@ -745,6 +1184,17 @@ function lerArco(raiz, arco, quando = new Date().toISOString()) {
     const log = lerLog(raiz, arco);
     return log.linhas.length ? estadoDe(arco, derivar(log.linhas), quando) : null;
 }
+/**
+ * RM-058, integração (D3 da ork-rm058integra): a guarda das threads do arco (`noctum-guarda.ts`) lê a lista de trabalhos
+ * do envelope vigente e a da proposta no prazo; o estado só traz o hash e o prazo dela. `null` quando o arco não existe.
+ */
+function lerArcoComProposta(raiz, arco, quando = new Date().toISOString()) {
+    const log = lerLog(raiz, arco);
+    if (!log.linhas.length)
+        return null;
+    const d = derivar(log.linhas), estado = estadoDe(arco, d, quando);
+    return { estado, proposta: estado.propostaPendente ? d.propostas.get(estado.propostaPendente.versao).conteudo : null };
+}
 /**
  * A conferência imediatamente antes de um efeito. Relê o disco, sem cache, e recusa na ordem:
  * ação excluída, estado adulterado (inclusive cauda incompleta), revogação, falta de autorização,
@@ -775,6 +1225,11 @@ function vigenteConferido(raiz, arco, envelopeSha256, log) {
         throw new noctum_envelope_1.RecusaDoArco('noctum.efeito.revogado', `arco ${arco} revogado pelo dono`);
     if (!d.autorizacao)
         throw new noctum_envelope_1.RecusaDoArco('noctum.efeito.sem-autorizacao', `arco ${arco} sem envelope autorizado`);
+    // RM-058 N6 (D2): encerrado é terminal como o revogado; reserva devolvida depois do teto não o reabre.
+    if (d.encerramento) {
+        throw new noctum_envelope_1.RecusaDoArco('noctum.efeito.encerrado', `arco ${arco} encerrado (${d.encerramento.motivo}) em ${(0, horario_1.formatarDataHora)(d.encerramento.em)}; ` +
+            'nenhum despacho ou efeito novo passa, e o arco não reabre');
+    }
     // A prova do dono é reconferida aqui, pelo recibo do canal, e não lida da linha do log (FX2 no gate).
     const prova = reciboConfere(raiz, arco, 'autorizar', d.autorizacao.envelopeSha256, d.autorizacao.versao, d.autorizacao.ingresso);
     if (prova === 'sem-verificador') {
@@ -824,8 +1279,9 @@ function threadsDoTrabalho(raiz, item, texto) {
 /**
  * D11 e D12 da ork-rm058n2: confere o envelope e reserva o despacho, as duas coisas sob o lock do arco, imediatamente
  * antes do efeito. A cadeia da N1 (`vigenteConferido`) mais a janela, o trabalho na lista `v2`, a conta e o runtime do
- * envelope e o orçamento: cada despacho reserva uma sessão no teto do arco e nos subtetos da conta e do runtime, e teto
- * em outra unidade recusa, porque a N2 não mede consumo nela. O trabalho de pedido só despacha a thread que o arco abriu
+ * envelope e o orçamento: cada despacho reserva uma sessão no teto do arco e nos subtetos da conta e do runtime; teto em
+ * outra unidade confere o consumo medido que o passo traz (`pedido.medido`, D5 da ork-rm058n6) e, sem ele ou com lacuna,
+ * recusa (`sem-medicao`). O trabalho de pedido só despacha a thread que o arco abriu
  * para ele, e só abre uma pelo GOAL quando nenhuma casa ainda; SHIP e MASTER nunca saem do arco da N2. A revogação usa o
  * mesmo lock: ou ela vem antes e nada é reservado, ou vem depois e vale para o despacho seguinte.
  */
@@ -869,13 +1325,24 @@ function reservarDespacho(raiz, pedido, quando = new Date().toISOString()) {
             throw fora(`a conta ${String(pedido.conta)} não está no envelope`);
         }
         const consumo = consumoDe(d);
-        const tetos = [['do arco', c.orcamento.arco, consumo.arco],
-            [`da conta ${pedido.conta}`, tetoDaConta, consumo.porConta[pedido.conta] ?? 0],
-            [`do runtime ${pedido.runtime}`, tetoDoRuntime, consumo.porRuntime[pedido.runtime] ?? 0]];
-        for (const [nome, teto, usado] of tetos) {
+        const tetos = [['do arco', c.orcamento.arco, consumo.arco, 'arco'],
+            [`da conta ${pedido.conta}`, tetoDaConta, consumo.porConta[pedido.conta] ?? 0, 'conta'],
+            [`do runtime ${pedido.runtime}`, tetoDoRuntime, consumo.porRuntime[pedido.runtime] ?? 0, 'runtime']];
+        for (const [nome, teto, usado, chave] of tetos) {
             if (teto.unidade !== 'sessoes') {
-                throw new noctum_envelope_1.RecusaDoArco('noctum.orcamento.sem-medicao', `o teto ${nome} está em ${teto.unidade}, e a N2 só mede sessoes: ` +
-                    'sem medir o consumo, o teto não é garantido, e consumo desconhecido nunca vale zero');
+                // RM-058 N6 (D5): fora de `sessoes`, o consumo medido fora do lock decide; sem medida, ou com lacuna, recusa.
+                const medido = pedido.medido?.[chave];
+                if (!medido || medido.unidade !== teto.unidade || 'lacuna' in medido || !Number.isFinite(medido.valor)) {
+                    throw new noctum_envelope_1.RecusaDoArco('noctum.orcamento.sem-medicao', `o teto ${nome} está em ${teto.unidade}, e o consumo nessa unidade não foi ` +
+                        `medido para esta reserva${medido && 'lacuna' in medido ? ` (${medido.lacuna})` : ''}: sem medir, o teto não é garantido, e ` +
+                        'consumo desconhecido nunca vale zero');
+                }
+                if (medido.valor >= teto.valor) {
+                    const valor = teto.unidade === 'percentual-da-cota' ? `${Math.round(medido.valor * 10) / 10}%` : String(medido.valor);
+                    throw new noctum_envelope_1.RecusaDoArco('noctum.orcamento.esgotado', `o teto ${nome} é de ${teto.valor} ${teto.unidade} e o consumo medido é ` +
+                        (medido.tetoSuperior ? `até ${valor} (teto superior: inclui uso de fora do arco)` : valor));
+                }
+                continue;
             }
             if (usado + 1 > teto.valor) {
                 throw new noctum_envelope_1.RecusaDoArco('noctum.orcamento.esgotado', `o teto ${nome} é de ${teto.valor} sessoes e ${usado} já foram reservadas`);
@@ -889,6 +1356,26 @@ function reservarDespacho(raiz, pedido, quando = new Date().toISOString()) {
         return { arco: pedido.arco, seq, versao: vigente.versao, envelopeSha256: vigente.envelopeSha256, fim: c.janela.fim, consumo: estado.consumo };
     }, true);
 }
+/**
+ * RM-058 N6 (D2 e D8 da ork-rm058n6): fecha o arco, uma vez, sob o lock do arco (espera como a revogação, porque é ato de
+ * segurança). Depois disto `vigenteConferido` recusa todo despacho e efeito com `noctum.efeito.encerrado`, a emenda é
+ * recusada e a fila encerra. O segundo fechamento devolve o primeiro. Só fecha arco que o dono autorizou; o revogado
+ * também fecha, para o registro do fechamento (a situação continua `revogado`).
+ */
+function encerrarArco(raiz, arco, fechamento, quando = new Date().toISOString()) {
+    if (!exports.MOTIVOS_DE_ENCERRAMENTO.includes(fechamento?.motivo)) {
+        throw new noctum_envelope_1.RecusaDoArco('noctum.envelope.invalido', `motivo de encerramento fora de ${exports.MOTIVOS_DE_ENCERRAMENTO.join(', ')}`);
+    }
+    return comLockDoArco(raiz, arco, false, () => {
+        const log = lerLog(raiz, arco), d = derivar(log.linhas);
+        if (!d.autorizacao)
+            throw new noctum_envelope_1.RecusaDoArco('noctum.efeito.sem-autorizacao', `arco ${arco} nunca autorizado não encerra`);
+        if (d.encerramento)
+            return estadoDe(arco, d, quando);
+        anexar(raiz, arco, log, { tipo: 'encerrado', motivo: fechamento.motivo, detalhe: String(fechamento.detalhe ?? '').slice(0, 500) }, quando);
+        return confirmado(raiz, arco, quando, e => e.encerramento !== null, 'encerramento');
+    }, true);
+}
 /**
  * O desfecho da reserva, uma vez só: o despacho que abriu sessão (ou que a sessão em andamento já atendia), ou o que o
  * núcleo recusou, que devolve a sessão ao orçamento. Vale também depois de revogação ou expiração: é a contabilidade do
@@ -909,3 +1396,23 @@ function concluirDespacho(raiz, arco, seq, desfecho, quando = new Date().toISOSt
         return confirmado(raiz, arco, quando, e => e.despachos.some(x => x.seq === seq && x.desfecho !== 'pendente'), 'conclusão do despacho');
     }, true);
 }
+/**
+ * RM-058 N3 (D6 da ork-rm058n3): as versões do envelope que o dono autorizou neste arco, na ordem do log. O ramo de
+ * coordenação guarda registros assinados sob versões anteriores (a vaga tomada antes de uma emenda continua contando), e a
+ * leitura confere cada um com as máquinas da versão que ele diz. A vigente é a última; o recibo do dono continua conferido
+ * por `vigenteConferido`, antes de cada efeito.
+ */
+function versoesAutorizadas(raiz, arco) {
+    const log = lerLog(raiz, arco), d = derivar(log.linhas);
+    const vistas = new Set();
+    const versoes = [];
+    for (const { evento: e } of log.linhas) {
+        if (e.tipo !== 'autorizado' || vistas.has(e.versao))
+            continue;
+        vistas.add(e.versao);
+        const p = d.propostas.get(e.versao);
+        // RM-058, integração (T8, D12): o instante do ingresso de cada autorização, que o aceite do piloto lê.
+        versoes.push({ versao: p.versao, envelopeSha256: p.envelopeSha256, conteudo: p.conteudo, autorizadoEm: e.ingresso.recebidoEm });
+    }
+    return versoes;
+}