@orkastery/cli 0.5.3 → 0.6.0

package/dist/noctum-arco.js

@@ -0,0 +1,1418 @@
+"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.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.
+ *
+ * O estado mora num log append-only em `.orkastery/noctum/arcos/<arco>/arco.jsonl`, na raiz do
+ * estado. Cada linha leva o sha256 da anterior e um MAC de subchave derivada da chave local do
+ * núcleo (`.orkastery/private`, a mesma fronteira do recibo local do HITL), e linha trocada reprova
+ * toda leitura. Essa chave fica legível para qualquer processo com o mesmo usuário do sistema, que é
+ * o caso dos agentes da fábrica: o MAC do log não os impede de escrever uma linha. Uma linha que se diz
+ * do Telegram ou do callback nativo ainda precisa do recibo do canal, que a conferência antes do efeito
+ * relê e que a chave local não produz. Uma linha que se diz do diálogo do host não tem recibo do canal:
+ * a fronteira dela é a conta do sistema, como no recibo local do HITL, e com a chave local ela passa.
+ * Truncar o log também segue possível, como no ledger (D5 da ork-rm058n1, limites ditos na página).
+ *
+ * Proposta não autoriza nada. O envelope só passa a valer por ingresso com prova de origem do
+ * dono, pelo mesmo caminho do HITL: o envelope assinado do Telegram ou do callback nativo, que
+ * `autenticarResposta` confere no endereço `noctum` / `arco:<arco>` (D1), ou o diálogo nativo
+ * do host, por callback de elicitação que o servidor fornece. Argumento de ferramenta nunca é
+ * resposta.
+ *
+ * Nada aqui guarda estado em memória: toda leitura relê o disco e todo veredito usa o instante
+ * dado. Por isso revogação e expiração valem na chamada seguinte, e restart não renova nada.
+ */
+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 horario_1 = require("./horario");
+const hitl_canais_1 = require("./hitl-canais");
+const hitl_gates_1 = require("./hitl-gates");
+const hitl_ingress_receipt_1 = require("./hitl-ingress-receipt");
+const hitl_contract_1 = require("./hitl-contract");
+const hitl_lock_1 = require("./hitl-lock");
+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';
+/**
+ * D1 da ork-rm058n1: o endereço que o ingresso assina, nas posições de thread e de pedido. O
+ * `:` não cabe no identificador que `/ork gate` e `/ork session` aceitam, e o pulse assina outro
+ * alvo: nenhum envelope de gate, de sessão ou do pulse serve de prova aqui, nem o contrário.
+ */
+exports.ALVO_DO_NOCTUM = 'noctum';
+const enderecoDoArco = (arco) => `arco:${arco}`;
+exports.enderecoDoArco = enderecoDoArco;
+/** O texto que o dono assina. Fechado: qualquer outro não autoriza nem revoga. */
+const textoDeAutorizacao = (envelopeSha256) => `autorizar ${envelopeSha256}`;
+exports.textoDeAutorizacao = textoDeAutorizacao;
+exports.TEXTO_DE_REVOGACAO = 'revogar';
+/** Uma hora para autorizar a proposta, como o pedido HITL. Vencida, ela não autoriza mais nada. */
+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');
+const adulterado = (detalhe) => new noctum_envelope_1.RecusaDoArco('noctum.estado.adulterado', `${detalhe}; o estado do arco exige inspeção`);
+const semProva = (detalhe) => new noctum_envelope_1.RecusaDoArco('noctum.origem.sem-prova', detalhe);
+const objeto = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const ID_DE_THREAD = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/;
+/** Subchave própria do arco: o mesmo segredo do recibo local, separado por domínio. */
+function chaveDoArco(raiz, criar) {
+    return (0, node_crypto_1.createHmac)('sha256', (0, hitl_local_receipt_1.chaveLocal)(raiz, criar)).update(exports.CONTRATO_ARCO).digest();
+}
+function dirDoArco(raiz, arco) {
+    if (typeof arco !== 'string' || !noctum_envelope_1.ID_DO_ARCO.test(arco))
+        throw new noctum_envelope_1.RecusaDoArco('noctum.envelope.invalido', 'identificador de arco inválido');
+    const principal = (0, estado_thread_1.raizDoEstado)(raiz);
+    (0, estado_thread_1.exigirEstadoSemLink)(principal, ['.orkastery', 'noctum', 'arcos', arco]);
+    return path.join(principal, '.orkastery', 'noctum', 'arcos', arco);
+}
+/** O contexto que o callback nativo amarra, por arco e versão (ou zero, na revogação). */
+function contextoDoArco(arco, versao) {
+    return sha(JSON.stringify([exports.CONTRATO_ARCO, arco, versao]));
+}
+/** O `pedidoSha256` que o callback nativo assina para revogar: não é hash de envelope nenhum. */
+function hashDaRevogacao(arco) {
+    return sha(JSON.stringify(['ork.noctum-revogacao/v1', arco]));
+}
+/**
+ * Lê e confere o log inteiro. Linha sem quebra no fim está sendo gravada: fica de fora e não
+ * dá autoridade a ninguém. Qualquer outra divergência (MAC, cadeia, sequência, arco) reprova.
+ */
+function lerLog(raiz, arco) {
+    const file = path.join(dirDoArco(raiz, arco), ARQUIVO);
+    let bruto;
+    try {
+        const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+        try {
+            const st = fs.fstatSync(fd);
+            if (!st.isFile() || st.nlink !== 1 || st.uid !== process.getuid?.() || (st.mode & 0o077) !== 0) {
+                throw adulterado('log do arco não é arquivo privado do núcleo');
+            }
+            bruto = fs.readFileSync(fd);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            return { linhas: [], ultimaLinha: null, terminaEmQuebra: true, bytesCompletos: 0, bytesLidos: 0 };
+        }
+        if (e instanceof noctum_envelope_1.RecusaDoArco)
+            throw e;
+        throw adulterado('log do arco ilegível');
+    }
+    // Em bytes, não em caracteres: cauda que corta um caractere de vários bytes não desalinha os tamanhos.
+    const fim = bruto.lastIndexOf(0x0a) + 1;
+    const textos = bruto.subarray(0, fim).toString('utf8').split('\n').slice(0, -1);
+    const tamanhos = { terminaEmQuebra: fim === bruto.length, bytesCompletos: fim, bytesLidos: bruto.length };
+    if (!textos.length)
+        return { linhas: [], ultimaLinha: null, ...tamanhos };
+    let chave;
+    try {
+        chave = chaveDoArco(raiz, false);
+    }
+    catch {
+        throw adulterado('chave do núcleo ausente para conferir o log');
+    }
+    let anterior = ZERO;
+    const linhas = textos.map((texto, i) => {
+        let l;
+        try {
+            l = JSON.parse(texto);
+        }
+        catch {
+            throw adulterado(`linha ${i + 1} não é JSON`);
+        }
+        if (!objeto(l) || Object.keys(l).sort().join(',') !== 'dados,mac' || typeof l.mac !== 'string' || !/^[a-f0-9]{64}$/.test(l.mac)) {
+            throw adulterado(`linha ${i + 1} fora do formato`);
+        }
+        const esperado = (0, node_crypto_1.createHmac)('sha256', chave).update(JSON.stringify(l.dados)).digest();
+        if (!(0, node_crypto_1.timingSafeEqual)(Buffer.from(l.mac, 'hex'), esperado))
+            throw adulterado(`linha ${i + 1} com MAC que não confere`);
+        const d = l.dados;
+        if (d.contrato !== exports.CONTRATO_ARCO || d.arco !== arco || d.seq !== i + 1 || d.anterior !== anterior) {
+            throw adulterado(`linha ${i + 1} fora da cadeia`);
+        }
+        anterior = sha(texto);
+        return d;
+    });
+    return { linhas, ultimaLinha: textos.at(-1), ...tamanhos };
+}
+/**
+ * Grava uma linha. Só roda sob o lock do arco, depois de `lerLog`.
+ *
+ * Sob o lock, cauda sem quebra de linha é escrita abortada (queda, disco cheio) ou lixo: nunca deu
+ * autoridade a ninguém, e é descartada antes da linha nova. Sem isso, uma cauda rasgada impediria a
+ * revogação do dono. Escrita curta volta o arquivo ao tamanho de antes e é acusada: o chamador nunca
+ * recebe sucesso de uma linha que não ficou inteira no disco.
+ */
+function anexar(raiz, arco, log, evento, quando) {
+    const dados = { contrato: exports.CONTRATO_ARCO, arco, seq: log.linhas.length + 1,
+        anterior: log.ultimaLinha === null ? ZERO : sha(log.ultimaLinha), em: quando, evento };
+    const mac = (0, node_crypto_1.createHmac)('sha256', chaveDoArco(raiz, true)).update(JSON.stringify(dados)).digest('hex');
+    const linha = Buffer.from(JSON.stringify({ dados, mac }) + '\n', 'utf8');
+    const file = path.join(dirDoArco(raiz, arco), ARQUIVO);
+    const fd = fs.openSync(file, fs.constants.O_WRONLY | fs.constants.O_APPEND | fs.constants.O_CREAT | fs.constants.O_NOFOLLOW, 0o600);
+    try {
+        if (fs.fstatSync(fd).size !== log.bytesLidos)
+            throw adulterado('o log mudou entre a leitura e a escrita sob o lock');
+        if (log.bytesLidos !== log.bytesCompletos)
+            fs.ftruncateSync(fd, log.bytesCompletos);
+        const escritos = fs.writeSync(fd, linha);
+        if (escritos !== linha.length) {
+            fs.ftruncateSync(fd, log.bytesCompletos);
+            fs.fsyncSync(fd);
+            throw adulterado(`escrita curta no log (${escritos} de ${linha.length} bytes); nada foi gravado`);
+        }
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/** Tentativas de 100 ms pelo lock: a revogação não perde para um escritor que segura o arco por um instante. */
+const TENTATIVAS_DO_LOCK = 30;
+function dirParaLock(raiz, arco, criar) {
+    const dir = dirDoArco(raiz, arco);
+    if (criar)
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    else if (!fs.existsSync(dir))
+        throw new noctum_envelope_1.RecusaDoArco('noctum.efeito.sem-autorizacao', `arco ${arco} sem proposta`);
+    return dir;
+}
+/** Só a disputa pelo kernel espera; qualquer outra falha, inclusive a recusa de dentro, sobe na hora. */
+const disputaDoLock = (e) => e instanceof Error && e.message.startsWith('HITL ocupado; exclusão do kernel');
+/**
+ * `esperar` na revogação, o ato de segurança, e na reserva e no desfecho do despacho (N2), que são passos curtos de quem
+ * já tem a vez de despachar; o resto falha na hora, sem prender o processo.
+ */
+function comLockDoArco(raiz, arco, criar, executar, esperar = false) {
+    const dir = dirParaLock(raiz, arco, criar);
+    for (let tentativa = 1;; tentativa++) {
+        try {
+            return (0, hitl_lock_1.comLockInspecionavel)(dir, 'noctum-arco', executar);
+        }
+        catch (e) {
+            if (!esperar || tentativa >= TENTATIVAS_DO_LOCK || !disputaDoLock(e))
+                throw e;
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
+        }
+    }
+}
+/** A mesma espera, sem prender o event loop: é a que o diálogo usa dentro do servidor MCP. */
+async function comLockDoArcoAssincrono(raiz, arco, executar) {
+    const dir = dirParaLock(raiz, arco, false);
+    for (let tentativa = 1;; tentativa++) {
+        try {
+            return (0, hitl_lock_1.comLockInspecionavel)(dir, 'noctum-arco', executar);
+        }
+        catch (e) {
+            if (tentativa >= TENTATIVAS_DO_LOCK || !disputaDoLock(e))
+                throw e;
+            await new Promise(r => setTimeout(r, 100));
+        }
+    }
+}
+/** 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(), encerramento: null, revogacoesPedidas: [] };
+    const usar = (i) => {
+        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');
+        d.usadas.add(prova);
+    };
+    for (const { evento: e, seq, em } of linhas) {
+        if (e.tipo === 'despacho_reservado') {
+            d.despachos.set(seq, { ...e.reserva, seq, reservadoEm: em, desfecho: 'pendente', threadDespachada: null, sessionId: null,
+                idempotente: false, motivo: null, concluidoEm: null });
+            continue;
+        }
+        if (e.tipo === 'despacho_concluido' || e.tipo === 'despacho_recusado') {
+            const r = d.despachos.get(e.reserva);
+            // Desfecho sem reserva, ou um segundo desfecho, só existe num log emendado à mão.
+            if (!r || r.desfecho !== 'pendente')
+                throw adulterado(`desfecho da reserva ${e.reserva} sem reserva pendente`);
+            if (e.tipo === 'despacho_concluido')
+                Object.assign(r, { desfecho: 'concluido', threadDespachada: e.thread, sessionId: e.sessionId,
+                    idempotente: e.idempotente, concluidoEm: em });
+            else
+                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, 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);
+            d.ultima = p;
+        }
+        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);
+        }
+        else if (e.tipo === 'revogado') {
+            d.revogacao = e.ingresso;
+            usar(e.ingresso);
+        }
+        else if (e.tipo === 'decisao_enfileirada')
+            d.decisoes.push(e.decisao);
+    }
+    return d;
+}
+function situacao(d, quando) {
+    if (d.revogacao)
+        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))
+        return 'agendado';
+    return agora >= Date.parse(janela.fim) ? 'expirado' : 'vigente';
+}
+function estadoDe(arco, d, quando) {
+    const vigente = d.autorizacao ? d.propostas.get(d.autorizacao.versao) : null;
+    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;
+    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,
+            ...(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) {
+    const c = { arco: 0, porConta: {}, porRuntime: {} };
+    for (const r of d.despachos.values()) {
+        if (r.desfecho === 'recusado')
+            continue;
+        c.arco += 1;
+        c.porConta[r.conta] = (c.porConta[r.conta] ?? 0) + 1;
+        c.porRuntime[r.runtime] = (c.porRuntime[r.runtime] ?? 0) + 1;
+    }
+    return c;
+}
+/**
+ * Grava a proposta de um envelope. Não autoriza nada: quem autoriza é o dono, pelo ingresso.
+ *
+ * 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(), 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))) {
+        throw new noctum_envelope_1.RecusaDoArco('noctum.envelope.invalido', `a janela pedida terminou em ${conteudo.janela.fim}`);
+    }
+    return comLockDoArco(raiz, conteudo.arco, true, () => {
+        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)
+            return { arco: conteudo.arco, ...pendente, resumo };
+        if (d.autorizacao?.envelopeSha256 === envelopeSha256) {
+            const vigente = d.propostas.get(d.autorizacao.versao);
+            return { arco: conteudo.arco, versao: vigente.versao, envelopeSha256, prazo: vigente.prazo, resumo };
+        }
+        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();
+        // 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
+ * fim do envelope autorizado e não reabre arco que já terminou: arco novo é outro arco.
+ */
+function exigirEmendaSemProrrogar(d, conteudo, quando) {
+    if (!d.autorizacao)
+        return;
+    const janela = d.propostas.get(d.autorizacao.versao).conteudo.janela;
+    if (!(Date.parse(quando) < Date.parse(janela.fim))) {
+        throw new noctum_envelope_1.RecusaDoArco('noctum.efeito.expirado', `o arco terminou em ${janela.fim}; emenda não reabre arco, abra outro`);
+    }
+    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) {
+        const conhecida = [...d.propostas.values()].some(p => p.envelopeSha256 === envelopeSha256);
+        throw new noctum_envelope_1.RecusaDoArco(conhecida ? 'noctum.efeito.hash-antigo' : 'noctum.envelope.invalido', conhecida ? `a proposta mais nova é ${d.ultima.envelopeSha256}` : 'hash sem proposta neste arco');
+    }
+    if (!(Date.parse(quando) < Date.parse(d.ultima.prazo))) {
+        throw new noctum_envelope_1.RecusaDoArco('noctum.envelope.invalido', `proposta vencida em ${(0, horario_1.formatarDataHora)(d.ultima.prazo)}; proponha de novo`);
+    }
+    if (!(Date.parse(quando) < Date.parse(d.ultima.conteudo.janela.fim))) {
+        throw new noctum_envelope_1.RecusaDoArco('noctum.efeito.expirado', `a janela terminou em ${d.ultima.conteudo.janela.fim}`);
+    }
+    if (d.autorizacao?.versao !== d.ultima.versao)
+        exigirEmendaSemProrrogar(d, d.ultima.conteudo, quando);
+    return d.ultima;
+}
+/**
+ * A prova de origem do envelope assinado, pela mesma `autenticarResposta` do HITL: chave do canal,
+ * allowlists, conta homologada e janela de 60 s. O texto assinado precisa ser exatamente o ato.
+ * O callback nativo ainda amarra o hash do pedido, o contexto e o prazo no próprio corpo.
+ */
+function provarEnvelope(arco, texto, envelope, quando, amarra) {
+    if (!objeto(envelope) || (envelope.origem !== 'telegram' && envelope.origem !== 'native')) {
+        throw semProva('o ingresso precisa ser o envelope assinado do Telegram ou do callback nativo do host');
+    }
+    try {
+        (0, hitl_gates_1.autenticarResposta)(exports.ALVO_DO_NOCTUM, (0, exports.enderecoDoArco)(arco), envelope, quando);
+    }
+    catch (e) {
+        throw semProva(`ingresso não autenticado (${e.message})`);
+    }
+    if (typeof envelope.resposta !== 'string' || envelope.resposta.trim() !== texto) {
+        throw semProva(`o texto assinado não é "${texto}"`);
+    }
+    const base = { canal: envelope.canal ?? null, conta: envelope.conta ?? null, por: envelope.por,
+        mensagem: envelope.mensagem, recebidoEm: envelope.recebidoEm, recibo: sha(envelope.prova) };
+    if (envelope.origem === 'telegram')
+        return { origem: 'telegram', ...base };
+    const native = hitl_native_1.nativeContextSchema.parse(envelope.native);
+    if (native.pedidoSha256 !== amarra.pedidoSha256 || native.context !== amarra.contexto ||
+        (amarra.prazo !== undefined && native.expiresAt !== amarra.prazo)) {
+        throw semProva('o callback nativo assinou outro pedido, contexto ou prazo');
+    }
+    return { origem: 'native', ...base, native: { ...native } };
+}
+/** O corpo do recibo durável: o que o ingresso provou e para qual ato, sem o texto assinado. */
+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 } : {}),
+        // 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);
+    try {
+        const st = fs.fstatSync(fd);
+        if (!st.isFile() || st.nlink !== 1 || st.uid !== process.getuid?.() || (st.mode & 0o077) !== 0) {
+            throw adulterado('recibo do ingresso não é arquivo privado do núcleo');
+        }
+        return fs.readFileSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+const nomeDoRecibo = (i) => `${sha(i.mensagem)}.json`;
+/**
+ * O recibo durável do envelope assinado, no formato que o HITL assina e publica: `dados` com o MAC
+ * da chave do canal e, ao lado, o `.public` que deixa reconferir sem a chave. É ele que a conferência
+ * antes do efeito relê (como o FX2 faz no gate): quem tem só a chave local do núcleo não o forja.
+ */
+function gravarRecibo(raiz, arco, ato, envelopeSha256, versao, i) {
+    const dir = path.join(dirDoArco(raiz, arco), 'ingresso');
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const nome = nomeDoRecibo(i), file = path.join(dir, nome);
+    const canal = i.canal === null ? null : (0, hitl_canais_1.parseCanal)(i.canal);
+    const dados = dadosDoRecibo(arco, ato, envelopeSha256, versao, i);
+    const chave = i.origem === 'native' ? (0, hitl_native_1.nativeKey)(String(canal)) : (0, hitl_ingress_receipt_1.chaveDoIngresso)(canal);
+    const bytes = JSON.stringify({ dados, assinatura: (0, node_crypto_1.createHmac)('sha256', chave).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 ingresso já existe com outro conteúdo');
+    (0, hitl_public_receipt_1.signPublicReceipt)(file, canal, i.origem === 'native');
+    return { evidencia: `.orkastery/noctum/arcos/${arco}/ingresso/${nome}`, evidenciaSha256: sha(bytes) };
+}
+/**
+ * Reconfere o recibo durável do envelope assinado, com a chave do canal quando o processo a tem, ou
+ * com o verificador público herdado (`ORK_RECEIPT_VERIFIERS`). Chave presente e inválida reprova; sem
+ * chave e sem verificador, a prova não pode ser reconferida aqui.
+ */
+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}`)
+            return 'falhou';
+        const file = path.join(dirDoArco(raiz, arco), 'ingresso', nome);
+        const bytes = lerPrivado(file);
+        if (sha(bytes) !== i.evidenciaSha256)
+            return 'falhou';
+        const v = JSON.parse(bytes.toString('utf8'));
+        const { evidencia: _evidencia, evidenciaSha256: _sha, ...assinado } = 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)(dadosDoRecibo(arco, ato, envelopeSha256, versao, assinado))) {
+            return 'falhou';
+        }
+        const native = i.origem === 'native';
+        const canal = i.canal === null ? null : (0, hitl_canais_1.parseCanal)(i.canal);
+        if (i.canal !== null && canal !== i.canal)
+            return 'falhou';
+        const variavel = native ? `ORK_HITL_NATIVE_KEY_${String(canal).toUpperCase()}` : (0, hitl_canais_1.variavelDaChaveDoCanal)(canal);
+        if (process.env[variavel] !== undefined) {
+            // A conta e o vínculo de agora, como no gate: depois de uma troca, o que a conta antiga autorizou não vale.
+            if (i.origem === 'native') {
+                if (Object.entries((0, hitl_native_1.nativeBinding)(String(canal))).some(([k, v]) => i.native[k] !== v))
+                    return 'falhou';
+            }
+            else
+                (0, hitl_ingress_receipt_1.contaDoEnvelope)(canal, i.conta ?? undefined);
+            const chave = native ? (0, hitl_native_1.nativeKey)(String(canal)) : (0, hitl_ingress_receipt_1.chaveDoIngresso)(canal);
+            return (0, node_crypto_1.timingSafeEqual)(Buffer.from(v.assinatura, 'hex'), (0, node_crypto_1.createHmac)('sha256', chave).update(JSON.stringify(v.dados)).digest())
+                ? 'ok' : 'falhou';
+        }
+        const autoridade = (0, hitl_public_receipt_1.publicReceiptAuthority)(canal, native);
+        if (!autoridade)
+            return 'sem-verificador';
+        let vinculo = i.conta;
+        if (i.origem === 'native') {
+            const { messageId: _m, context: _c, pedidoSha256: _p, expiresAt: _e, ...identidade } = i.native;
+            vinculo = identidade;
+        }
+        return (0, hitl_public_receipt_1.publicBindingMatches)(autoridade, vinculo) && (0, hitl_public_receipt_1.verifyPublicReceipt)(file, bytes, autoridade) ? 'ok' : 'falhou';
+    }
+    catch {
+        return 'falhou';
+    }
+}
+/** Relê o disco depois de gravar: o ato só volta com sucesso quando está no log, inteiro. */
+function confirmado(raiz, arco, quando, vale, ato) {
+    const log = lerLog(raiz, arco), estado = estadoDe(arco, derivar(log.linhas), quando);
+    if (!log.terminaEmQuebra || !vale(estado))
+        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. `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 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);
+        const ingresso = { ...provado, ...gravarRecibo(raiz, arco, 'autorizar', envelopeSha256, proposta.versao, provado) };
+        anexar(raiz, arco, log, { tipo: 'autorizado', versao: proposta.versao, envelopeSha256, ingresso }, quando);
+        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). `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 (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.
+        let recibo;
+        try {
+            recibo = gravarRecibo(raiz, arco, 'revogar', null, null, provado);
+        }
+        // Só o motivo tipado: a mensagem crua do erro pode trazer caminho da máquina, e o relatório da manhã lê esta linha.
+        catch (e) {
+            recibo = { evidencia: '', evidenciaSha256: '', semRecibo: e instanceof noctum_envelope_1.RecusaDoArco ? e.motivo : 'noctum.recibo.nao-gravado' };
+        }
+        const ingresso = { ...provado, ...recibo };
+        anexar(raiz, arco, log, { tipo: 'revogado', ingresso }, quando);
+        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`:
+ * a instalação do cliente MCP é confiável; o modelo não responde por ela. A N1 entrega o contrato;
+ * a ferramenta do MCP que o expõe fica para a fatia que liga o transporte (D1).
+ */
+function criarDialogoDoArco(raiz, origem, elicitar) {
+    if (!['claude-code', 'codex'].includes(origem.host) || !ID_DE_THREAD.test(origem.connectionId)) {
+        throw semProva('diálogo de origem desconhecida');
+    }
+    const conexao = { ...origem };
+    const perguntar = async (a, prazo) => {
+        const controller = new AbortController(), requestId = (0, node_crypto_1.randomUUID)();
+        const espera = Math.min(ESPERA_DO_DIALOGO_MS, prazo === undefined ? ESPERA_DO_DIALOGO_MS : Date.parse(prazo) - Date.now());
+        if (!(espera > 0))
+            throw new noctum_envelope_1.RecusaDoArco('noctum.envelope.invalido', 'proposta vencida; proponha de novo');
+        const timer = setTimeout(() => controller.abort(), espera);
+        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');
+            return { requestId, recebidoEm: new Date().toISOString() };
+        }
+        finally {
+            clearTimeout(timer);
+            controller.abort();
+        }
+    };
+    const ingressoDoDialogo = (requestId, recebidoEm, opcao) => ({
+        origem: 'mcp-local', host: conexao.host, conexao: conexao.connectionId, solicitacao: requestId,
+        por: `mcp-local:${conexao.host}`, recebidoEm, respostaSha256: sha(opcao)
+    });
+    return {
+        async autorizar(arco, envelopeSha256) {
+            const antes = comLockDoArco(raiz, arco, false, () => {
+                const d = derivar(lerLog(raiz, arco).linhas);
+                return propostaAutorizavel(d, envelopeSha256, new Date().toISOString());
+            });
+            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, () => {
+                const log = lerLog(raiz, arco), d = derivar(log.linhas);
+                if (d.autorizacao?.envelopeSha256 === envelopeSha256 && !d.revogacao)
+                    return estadoDe(arco, d, recebidoEm);
+                const proposta = propostaAutorizavel(d, envelopeSha256, recebidoEm);
+                anexar(raiz, arco, log, { tipo: 'autorizado', versao: proposta.versao, envelopeSha256,
+                    ingresso: ingressoDoDialogo(requestId, recebidoEm, a.opcoes[0]) }, recebidoEm);
+                return confirmado(raiz, arco, recebidoEm, e => e.envelopeSha256 === envelopeSha256 && e.situacao !== 'revogado', 'autorização');
+            });
+        },
+        async revogar(arco) {
+            // Leitura sem lock (o log é lido inteiro e conferido): revogar não pode falhar antes de perguntar ao dono.
+            const atual = lerArco(raiz, arco);
+            if (!atual)
+                throw new noctum_envelope_1.RecusaDoArco('noctum.efeito.sem-autorizacao', `arco ${arco} sem proposta`);
+            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);
+                if (!d.revogacao)
+                    anexar(raiz, arco, log, { tipo: 'revogado', ingresso: ingressoDoDialogo(requestId, recebidoEm, a.opcoes[0]) }, recebidoEm);
+                return confirmado(raiz, arco, recebidoEm, e => e.situacao === 'revogado', 'revogação');
+            });
+        },
+    };
+}
+const linhaCurta = (v, teto) => typeof v === 'string' && v.trim().length > 0 && v.length <= teto && !/[\r\n]/.test(v);
+/** RM-057: 3 a 5 alternativas, letras em sequência, exatamente uma recomendada com o porquê. */
+function validarDecisao(v) {
+    const invalido = (detalhe) => new noctum_envelope_1.RecusaDoArco('noctum.envelope.invalido', `decisão em lote: ${detalhe}`);
+    if (!objeto(v))
+        throw invalido('precisa ser objeto');
+    const chaves = ['thread', 'acaoImpedida', 'dependentes', 'impacto', 'pergunta', 'alternativas'];
+    const sobra = Object.keys(v).filter(k => !chaves.includes(k));
+    if (sobra.length)
+        throw invalido(`campo fora do contrato: ${sobra.join(', ')} (a resposta é do dono, depois)`);
+    if (typeof v.thread !== 'string' || !ID_DE_THREAD.test(v.thread))
+        throw invalido('thread inválida');
+    for (const campo of ['acaoImpedida', 'impacto', 'pergunta']) {
+        if (!linhaCurta(v[campo], hitl_contract_1.TETOS_HITL_V2.pergunta))
+            throw invalido(`${campo} em uma linha, até ${hitl_contract_1.TETOS_HITL_V2.pergunta}`);
+    }
+    if (!Array.isArray(v.dependentes) || v.dependentes.length > 50 || v.dependentes.some(x => typeof x !== 'string' || !ID_DE_THREAD.test(x))) {
+        throw invalido('dependentes é lista de identificadores');
+    }
+    const alternativas = v.alternativas;
+    if (!Array.isArray(alternativas) || alternativas.length < hitl_contract_1.MINIMO_DE_ALTERNATIVAS_DE_CONDUCAO ||
+        alternativas.length > hitl_contract_1.MAXIMO_DE_ALTERNATIVAS_DE_CONDUCAO) {
+        throw invalido(`de ${hitl_contract_1.MINIMO_DE_ALTERNATIVAS_DE_CONDUCAO} a ${hitl_contract_1.MAXIMO_DE_ALTERNATIVAS_DE_CONDUCAO} alternativas`);
+    }
+    const lidas = alternativas.map((a, i) => {
+        if (!objeto(a) || a.letra !== hitl_contract_1.LETRAS_DE_ALTERNATIVA[i] || !linhaCurta(a.texto, hitl_contract_1.TETOS_HITL_V2.alternativaTexto) ||
+            !linhaCurta(a.consequencia, hitl_contract_1.TETOS_HITL_V2.consequencia) || Object.keys(a).some(k => !['letra', 'texto', 'consequencia', 'recomendada', 'porque'].includes(k))) {
+            throw invalido(`alternativa ${i + 1} fora do contrato`);
+        }
+        if (a.recomendada !== undefined && a.recomendada !== true)
+            throw invalido(`alternativa ${i + 1}: recomendada é true ou ausente`);
+        if (a.recomendada === true && !linhaCurta(a.porque, hitl_contract_1.TETOS_HITL_V2.porque))
+            throw invalido('a recomendada diz o porquê em uma linha');
+        if (a.recomendada !== true && a.porque !== undefined)
+            throw invalido('só a recomendada traz porquê');
+        return { letra: a.letra, texto: a.texto, consequencia: a.consequencia,
+            ...(a.recomendada === true ? { recomendada: true, porque: a.porque } : {}) };
+    });
+    if (lidas.filter(a => a.recomendada).length !== 1)
+        throw invalido('exatamente uma alternativa recomendada');
+    return { thread: v.thread, acaoImpedida: v.acaoImpedida, dependentes: [...v.dependentes],
+        impacto: v.impacto, pergunta: v.pergunta, alternativas: lidas };
+}
+/** Id estável: o mesmo arco, thread e ação impedida dão o mesmo id, em qualquer processo. */
+function idDaDecisao(arco, thread, acaoImpedida) {
+    return 'L-' + sha((0, noctum_envelope_1.canonico)([arco, thread, acaoImpedida])).slice(0, 12);
+}
+/**
+ * Guarda na fila do lote o que só o dono resolve. A recomendada não é aplicada e nenhum campo de
+ * resposta existe: a decisão fica pendente até o dono responder pelo ingresso, numa fatia futura.
+ * Vale também depois de revogação ou expiração, porque o lote vai no relatório de qualquer jeito.
+ */
+function enfileirarDecisao(raiz, arco, pedido, quando = new Date().toISOString()) {
+    const lido = validarDecisao(pedido);
+    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 nunca autorizado não tem lote');
+        const id = idDaDecisao(arco, lido.thread, lido.acaoImpedida);
+        const existente = d.decisoes.find(x => x.id === id);
+        if (existente)
+            return existente;
+        const decisao = { id, arco, enfileiradaEm: quando, estado: 'pendente', ...lido };
+        anexar(raiz, arco, log, { tipo: 'decisao_enfileirada', decisao }, quando);
+        return decisao;
+    });
+}
+/** O estado do arco, relido do disco e julgado no instante dado. `null` quando o arco não existe. */
+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,
+ * recibo do dono que não confere, hash diferente do vigente, janela e destino. Passar aqui é necessário
+ * e não suficiente: as provas do merge são da N5 e o consumo do orçamento é da N2 e da N6 (D8). O
+ * instante é parâmetro para os testes; o executor chama sem ele, com o relógio do processo.
+ */
+function conferirAntesDoEfeito(raiz, efeito, quando = new Date().toISOString()) {
+    const excluida = (0, noctum_envelope_1.recusaDeExclusao)(efeito?.acao);
+    if (excluida)
+        throw excluida;
+    const { vigente } = vigenteConferido(raiz, efeito.arco, efeito.envelopeSha256, lerLog(raiz, efeito.arco));
+    (0, noctum_envelope_1.avaliarEfeito)(vigente.conteudo, efeito, quando);
+    return { ok: true, arco: efeito.arco, versao: vigente.versao, envelopeSha256: vigente.envelopeSha256,
+        acao: efeito.acao, repositorio: efeito.repositorio, branch: efeito.branch, conferidoEm: quando, fim: vigente.conteudo.janela.fim };
+}
+/**
+ * A cadeia comum da conferência antes de um efeito (N1) e antes de um despacho (N2), na ordem da N1: cauda incompleta,
+ * linha adulterada, revogação, falta de autorização, recibo do dono que não confere ou não pode ser reconferido,
+ * conteúdo que diverge do hash e hash diferente do vigente. Relê só o que já foi lido do disco.
+ */
+function vigenteConferido(raiz, arco, envelopeSha256, log) {
+    // Cauda sem quebra pode ser a revogação que está sendo gravada: na dúvida, nenhum efeito passa.
+    if (!log.terminaEmQuebra)
+        throw adulterado('linha incompleta no fim do log (gravação abortada ou em curso); repita a conferência');
+    const d = derivar(log.linhas);
+    if (d.revogacao)
+        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') {
+        throw new noctum_envelope_1.RecusaDoArco('noctum.origem.sem-prova', 'a prova do dono não pode ser reconferida neste processo: falta a chave ou o verificador público do canal');
+    }
+    if (prova === 'falhou')
+        throw adulterado('o recibo do ingresso que autorizou o envelope não confere');
+    const vigente = d.propostas.get(d.autorizacao.versao);
+    if ((0, noctum_envelope_1.hashDoEnvelope)(vigente.conteudo) !== d.autorizacao.envelopeSha256)
+        throw adulterado('conteúdo vigente diverge do hash autorizado');
+    if (envelopeSha256 !== d.autorizacao.envelopeSha256) {
+        // Hash de uma emenda que o dono ainda não autorizou não é antigo: é envelope sem autorização.
+        const naoAutorizado = d.ultima !== null && d.ultima.versao > d.autorizacao.versao && d.ultima.envelopeSha256 === envelopeSha256;
+        throw new noctum_envelope_1.RecusaDoArco(naoAutorizado ? 'noctum.efeito.sem-autorizacao' : 'noctum.efeito.hash-antigo', `o envelope vigente é ${d.autorizacao.envelopeSha256}; o efeito trouxe ${String(envelopeSha256)}`);
+    }
+    return { d, vigente };
+}
+/** As fases que o arco da N2 nunca despacha: a entrega fica com a condutora (A2 do CHECK da ork-rm058n2). */
+const FASES_DA_ENTREGA = ['SHIP', 'MASTER'];
+/** A thread é a do trabalho de pedido? O item dela mais o sha256 do pedido guardado na criação. Ilegível não é. */
+function threadDoPedido(raiz, id, item, texto) {
+    try {
+        const t = (0, thread_1.lerThread)(raiz, id);
+        return t.roadmap === item && (0, thread_1.pedidoDaThread)(raiz, t)?.sha256 === (0, noctum_envelope_1.shaDoPedido)(texto);
+    }
+    catch {
+        return false;
+    }
+}
+/** As threads que já casam com o trabalho de pedido (o item mais o sha256 do pedido); `null` com thread ilegível. */
+function threadsDoTrabalho(raiz, item, texto) {
+    const sha = (0, noctum_envelope_1.shaDoPedido)(texto);
+    const achadas = [];
+    for (const id of (0, thread_1.listarIds)(raiz)) {
+        let t;
+        try {
+            t = (0, thread_1.lerThread)(raiz, id);
+        }
+        catch {
+            return null;
+        }
+        if (t.roadmap === item && t.pedido?.sha256 === sha)
+            achadas.push(id);
+    }
+    return achadas;
+}
+/**
+ * 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; 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.
+ */
+function reservarDespacho(raiz, pedido, quando = new Date().toISOString()) {
+    return comLockDoArco(raiz, pedido.arco, false, () => {
+        const log = lerLog(raiz, pedido.arco);
+        const { d, vigente } = vigenteConferido(raiz, pedido.arco, pedido.envelopeSha256, log);
+        const c = vigente.conteudo;
+        (0, noctum_envelope_1.avaliarJanela)(c, quando);
+        const fora = (detalhe) => new noctum_envelope_1.RecusaDoArco('noctum.despacho.fora-do-envelope', detalhe);
+        if (!(0, noctum_envelope_1.envelopeComTrabalhos)(c))
+            throw fora('o envelope vigente é v1, sem lista de trabalhos: só uma emenda v2 autorizada pelo dono despacha');
+        const t = c.trabalhos.find(x => x.id === pedido.trabalho);
+        if (!t)
+            throw fora(`o trabalho ${String(pedido.trabalho)} não está na lista do envelope`);
+        if (t.thread !== undefined && pedido.thread !== t.thread)
+            throw fora(`o trabalho ${t.id} é a thread ${t.thread}, não ${String(pedido.thread)}`);
+        // A2 do CHECK: a thread de um trabalho de pedido é a que o arco abriu para ele, nunca outra qualquer.
+        if (t.pedido !== undefined && pedido.thread !== null && !threadDoPedido(raiz, pedido.thread, t.item, t.pedido)) {
+            throw fora(`a thread ${String(pedido.thread)} não é a do trabalho ${t.id}: o vínculo é o item ${t.item} mais o sha256 do pedido do envelope`);
+        }
+        if (FASES_DA_ENTREGA.includes(pedido.fase)) {
+            throw fora(`a fase ${String(pedido.fase)} é entrega: a N2 não despacha SHIP nem MASTER, que ficam com a condutora`);
+        }
+        // S3 da rodada 2: abrir a thread de um trabalho de pedido é pelo GOAL, e só quando nenhuma casa com ele ainda.
+        if (t.pedido !== undefined && pedido.thread === null) {
+            if (pedido.fase !== 'GOAL')
+                throw fora(`o trabalho ${t.id} abre a thread pelo GOAL, não pelo ${String(pedido.fase)}`);
+            const ja = threadsDoTrabalho(raiz, t.item, t.pedido);
+            if (ja === null)
+                throw fora(`há thread ilegível no projeto, e ela pode ser a do trabalho ${t.id}: abrir outra a duplicaria`);
+            if (ja.length)
+                throw fora(`o trabalho ${t.id} já tem a thread ${ja.join(', ')}: o despacho vai por ela`);
+        }
+        const tetoDoRuntime = c.orcamento.porRuntime.find(x => x.runtime === pedido.runtime)?.teto;
+        if (!tetoDoRuntime || !c.capacidade.porRuntime.some(x => x.runtime === pedido.runtime)) {
+            throw fora(`o runtime ${String(pedido.runtime)} não está no envelope`);
+        }
+        const tetoDaConta = c.orcamento.porConta.find(x => x.conta === pedido.conta)?.teto;
+        if (!tetoDaConta || !c.capacidade.porConta.some(x => x.conta === pedido.conta)) {
+            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, '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') {
+                // 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`);
+            }
+        }
+        const reserva = { trabalho: t.id, thread: pedido.thread, fase: pedido.fase, runtime: pedido.runtime,
+            conta: pedido.conta, revisao: pedido.revisao === true, versao: vigente.versao, envelopeSha256: vigente.envelopeSha256 };
+        anexar(raiz, pedido.arco, log, { tipo: 'despacho_reservado', reserva }, quando);
+        const seq = log.linhas.length + 1;
+        const estado = confirmado(raiz, pedido.arco, quando, e => e.despachos.some(x => x.seq === seq && x.desfecho === 'pendente'), 'reserva do despacho');
+        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
+ * que já estava em voo, não um efeito novo.
+ */
+function concluirDespacho(raiz, arco, seq, desfecho, quando = new Date().toISOString()) {
+    return comLockDoArco(raiz, arco, false, () => {
+        const log = lerLog(raiz, arco), d = derivar(log.linhas);
+        const r = d.despachos.get(seq);
+        if (!r)
+            throw new noctum_envelope_1.RecusaDoArco('noctum.envelope.invalido', `reserva ${seq} inexistente neste arco`);
+        if (r.desfecho !== 'pendente')
+            return estadoDe(arco, d, quando);
+        const evento = 'motivo' in desfecho
+            ? { tipo: 'despacho_recusado', reserva: seq, motivo: String(desfecho.motivo).slice(0, 200) }
+            : { tipo: 'despacho_concluido', reserva: seq, thread: desfecho.thread, sessionId: desfecho.sessionId, idempotente: desfecho.idempotente };
+        anexar(raiz, arco, log, evento, quando);
+        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;
+}