@orkastery/cli 0.5.3 → 0.5.6

package/dist/noctum-arco.js

@@ -0,0 +1,911 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRAZO_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.autorizarPeloIngresso = autorizarPeloIngresso;
+exports.revogarPeloIngresso = revogarPeloIngresso;
+exports.criarDialogoDoArco = criarDialogoDoArco;
+exports.idDaDecisao = idDaDecisao;
+exports.enfileirarDecisao = enfileirarDecisao;
+exports.lerArco = lerArco;
+exports.conferirAntesDoEfeito = conferirAntesDoEfeito;
+exports.reservarDespacho = reservarDespacho;
+exports.concluirDespacho = concluirDespacho;
+/**
+ * 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 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;
+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));
+        }
+    }
+}
+function derivar(linhas) {
+    const d = { propostas: new Map(), ultima: null, autorizacao: null, revogacao: null, decisoes: [], usadas: new Set(),
+        despachos: new Map() };
+    const usar = (i) => {
+        const prova = i.origem === 'mcp-local' ? `mcp-local:${i.solicitacao}` : `${i.origem}:${i.mensagem}`;
+        // 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 === 'proposto') {
+            const p = { versao: e.versao, envelopeSha256: e.envelopeSha256, conteudo: e.conteudo, prazo: e.prazo };
+            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`);
+            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';
+    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.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,
+        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) };
+}
+/** 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()) {
+    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');
+        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();
+        anexar(raiz, conteudo.arco, log, { tipo: 'proposto', versao, envelopeSha256, conteudo, prazo }, quando);
+        return { arco: conteudo.arco, versao, envelopeSha256, prazo, resumo };
+    });
+}
+/**
+ * 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');
+    }
+}
+/** 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.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 } : {}) };
+}
+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';
+    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. */
+function autorizarPeloIngresso(raiz, arco, envelopeSha256, envelope, quando = new Date().toISOString()) {
+    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);
+        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). */
+function revogarPeloIngresso(raiz, arco, envelope, quando = new Date().toISOString()) {
+    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)
+            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);
+}
+/**
+ * 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]);
+            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 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 { 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 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 { 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;
+}
+/**
+ * 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`);
+    // 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, 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
+ * 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],
+            [`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) {
+            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');
+            }
+            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);
+}
+/**
+ * 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);
+}