@orkastery/cli 0.5.6 → 0.6.0

package/dist/noctum-modo.js

@@ -0,0 +1,362 @@
+"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.GRAMATICA_DO_NOCTUM = exports.CONTRATO_TIQUE = exports.CONTRATO_RETRATO_DO_ARCO = exports.CONTRATO_INGRESSO_DO_ARCO = void 0;
+exports.listarArcos = listarArcos;
+exports.arcosVigentes = arcosVigentes;
+exports.aceitarModoNoctum = aceitarModoNoctum;
+exports.ehModoNoctum = ehModoNoctum;
+exports.tagNoctumNoPedido = tagNoctumNoPedido;
+exports.recusaDoModoNaThread = recusaDoModoNaThread;
+exports.responderAoArco = responderAoArco;
+exports.retratoDoArco = retratoDoArco;
+exports.textoDoRetrato = textoDoRetrato;
+exports.tiqueDoArco = tiqueDoArco;
+/**
+ * RM-058, fatia N6 (D1, D3, D12 e D13 da ork-rm058n6): o transporte que liga o modo #Noctum.
+ *
+ * O `#Noctum` é o modo de condução do arco, não de uma thread: as threads do arco são `#Auto`, e a lista delas é a do
+ * envelope que o dono autorizou (D1). Por isso `parseModo` e `MODOS_LEGADOS` continuam sem ele (o E9 da N1), e o aceite
+ * fica aqui, com estado: com algum arco vigente (autorizado, na janela e não encerrado), o pedido com `#Noctum` é aceito
+ * e o host recebe os arcos; sem nenhum, a tag é recusada com `noctum.modo.sem-envelope`, dizendo como abrir um arco. Uma
+ * thread nova em modo `#Noctum` nunca é criada: trabalho novo entra no arco por emenda do envelope, com prova nova do dono
+ * (`noctum.modo.lista-fechada`), porque item, prioridade e dependências são valores dele.
+ *
+ * O pedido de abertura chega ao núcleo pelo CLI (`ork noctum propor`), pela ferramenta do MCP (`ork_noctum_propor`) e
+ * pelos gateways; proposta não autoriza nada. A autorização e a revogação do dono vêm só por ingresso autenticado: o
+ * envelope assinado do gateway (`/ork noctum <arco> autorizar <sha256>` ou `revogar`, entregue a `ork noctum responder`
+ * pela entrada, conferido aqui com o `autorizarPeloIngresso` e o `revogarPeloIngresso` da N1) ou o diálogo nativo do host
+ * pelo MCP. Argumento de ferramenta e comando de terminal nunca são resposta do dono.
+ *
+ * O tique (D13) junta, nesta ordem, o fechamento, o vigia da N4 e o relatório (RM-058, integração, D7 da ork-rm058integra):
+ * o vigia reconcilia, aplica as paradas e, só com o condutor ausente, dá o passo do despacho; a parada que ele grava fecha
+ * o arco no mesmo tique, pelo fechamento, com o motivo `supervisao`. Os testes da N6 ainda passam o passo da N2 no lugar do
+ * vigia. É o que o cron do dono chama no piloto; nada aqui instala cron.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const estado_thread_1 = require("./estado-thread");
+const horario_1 = require("./horario");
+const modos_1 = require("./modos");
+const noctum_arco_1 = require("./noctum-arco");
+const noctum_envelope_1 = require("./noctum-envelope");
+const noctum_fechamento_1 = require("./noctum-fechamento");
+const noctum_fila_1 = require("./noctum-fila");
+const noctum_medicao_1 = require("./noctum-medicao");
+const noctum_relatorio_1 = require("./noctum-relatorio");
+const noctum_registro_1 = require("./noctum-registro");
+const noctum_supervisao_1 = require("./noctum-supervisao");
+const noctum_vigia_1 = require("./noctum-vigia");
+exports.CONTRATO_INGRESSO_DO_ARCO = 'ork.noctum-ingresso/v1';
+exports.CONTRATO_RETRATO_DO_ARCO = 'ork.noctum-retrato/v1';
+exports.CONTRATO_TIQUE = 'ork.noctum-tique/v1';
+/**
+ * D12: a gramática do comando dos gateways, com domicílio aqui. Os ingressos do Telegram do Hermes e do OpenClaw guardam
+ * uma cópia, e o teste dos gateways confere que as três continuam iguais. O endereço assinado é `noctum` / `arco:<arco>`.
+ */
+exports.GRAMATICA_DO_NOCTUM = '^/ork noctum ([a-z0-9][a-z0-9-]{0,62}) (autorizar [a-f0-9]{64}|revogar)$';
+/** Os arcos desta raiz de estado, pelos nomes das pastas; os que não têm nome de arco ficam de fora. */
+function listarArcos(raiz) {
+    try {
+        return fs.readdirSync(path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'noctum', 'arcos')).filter(n => noctum_envelope_1.ID_DO_ARCO.test(n)).sort();
+    }
+    catch {
+        return [];
+    }
+}
+/** Os arcos vigentes no instante: autorizados, dentro da janela e não encerrados. Arco que não se lê não conta. */
+function arcosVigentes(raiz, quando = new Date().toISOString()) {
+    const vigentes = [], ilegiveis = [];
+    for (const arco of listarArcos(raiz)) {
+        let e;
+        try {
+            e = (0, noctum_arco_1.lerArco)(raiz, arco, quando);
+        }
+        catch {
+            ilegiveis.push(arco);
+            continue;
+        }
+        if (e?.situacao === 'vigente' && e.conteudo && e.versao !== null && e.envelopeSha256) {
+            vigentes.push({ arco, versao: e.versao, envelopeSha256: e.envelopeSha256, fim: e.conteudo.janela.fim, fuso: e.conteudo.janela.fuso });
+        }
+    }
+    return { vigentes, ilegiveis };
+}
+// RM-057 (resposta curta, D9 da ork-rm057respost): a recusa diz como responder curto, nunca a linha com o hash.
+const COMO_ABRIR = 'abra um arco: proponha o envelope com ork noctum propor --arquivo <envelope.json> (ou a ferramenta ork_noctum_propor) ' +
+    'e o dono o autoriza respondendo à pergunta dele com a letra, em reply no Telegram, ou pelo diálogo do host';
+/** D1: o `#Noctum` só vale com algum arco vigente; sem nenhum, a recusa tipada diz como abrir um. */
+function aceitarModoNoctum(raiz, quando = new Date().toISOString()) {
+    const { vigentes, ilegiveis } = raiz ? arcosVigentes(raiz, quando) : { vigentes: [], ilegiveis: [] };
+    if (vigentes.length)
+        return vigentes;
+    throw new noctum_envelope_1.RecusaDoArco('noctum.modo.sem-envelope', `#Noctum só vale com um envelope vigente, e nenhum arco deste projeto está vigente` +
+        `${ilegiveis.length ? ` (não se leram: ${ilegiveis.join(', ')})` : ''}; ${COMO_ABRIR}`);
+}
+/** A entrada nomeia o modo `#Noctum` (`noctum`, `#Noctum`, `--modo noctum`)? */
+function ehModoNoctum(entrada) {
+    return (entrada ?? '').trim().replace(/^--?modo[= ]/i, '').replace(/^#/, '').toLowerCase() === 'noctum';
+}
+/** A primeira #TAG de modo do texto é `#Noctum`? A precedência é a de `extrairTagDoPedido`: a primeira tag vence. */
+function tagNoctumNoPedido(texto) {
+    const achada = new RegExp(`#(?:noctum|${modos_1.MODOS_LEGADOS.join('|')})\\b`, 'i').exec(texto);
+    return !!achada && achada[0].slice(1).toLowerCase() === 'noctum';
+}
+/** A recusa de `ork thread new --modo noctum`: sem arco vigente, o modo nem vale; com ele, a lista do arco é fechada. */
+function recusaDoModoNaThread(raiz, quando = new Date().toISOString()) {
+    try {
+        aceitarModoNoctum(raiz, quando);
+    }
+    catch (e) {
+        if (e instanceof noctum_envelope_1.RecusaDoArco)
+            return e;
+        throw e;
+    }
+    return new noctum_envelope_1.RecusaDoArco('noctum.modo.lista-fechada', '#Noctum conduz o arco, não uma thread: as threads do arco são #Auto e vêm da ' +
+        'lista do envelope que o dono autorizou; trabalho novo entra por emenda (ork noctum propor com a versão nova), autorizada pelo dono');
+}
+/**
+ * O ingresso dos gateways: o envelope assinado com `autorizar <sha256>` ou `revogar`, conferido pela N1 no endereço do
+ * arco (chave do canal, listas, conta e janela de 60 s). Devolve o recibo tipado que os gateways conferem.
+ */
+function responderAoArco(raiz, arco, envelope, quando = new Date().toISOString()) {
+    if (!noctum_envelope_1.ID_DO_ARCO.test(arco))
+        throw new noctum_envelope_1.RecusaDoArco('noctum.envelope.invalido', 'identificador de arco inválido');
+    const texto = typeof envelope?.resposta === 'string' ? envelope.resposta.trim() : '';
+    const autorizar = /^autorizar ([a-f0-9]{64})$/.exec(texto);
+    if (!autorizar && texto !== 'revogar') {
+        throw new noctum_envelope_1.RecusaDoArco('noctum.origem.sem-prova', 'o texto assinado precisa ser autorizar <sha256> ou revogar');
+    }
+    const recibo = (e, ato, repetida) => ({ ok: true, contrato: exports.CONTRATO_INGRESSO_DO_ARCO, arco, ato, situacao: e.situacao, versao: e.versao, envelopeSha256: e.envelopeSha256, repetida });
+    // O "já valia" é decidido sob o lock do arco: duas entregas do mesmo ato ao mesmo tempo dão uma confirmação só.
+    const info = { repetida: false };
+    if (autorizar)
+        return recibo((0, noctum_arco_1.autorizarPeloIngresso)(raiz, arco, autorizar[1], envelope, quando, info), 'autorizar', info.repetida);
+    return recibo((0, noctum_arco_1.revogarPeloIngresso)(raiz, arco, envelope, quando, info), 'revogar', info.repetida);
+}
+/** O retrato do arco no instante: situação, janela, consumo, fila, fechamento, relatório e lacunas. Só lê. */
+function retratoDoArco(carregado, arco, opcoes = {}) {
+    const quando = opcoes.quando ?? new Date().toISOString();
+    const { raiz } = carregado;
+    const estado = (0, noctum_arco_1.lerArco)(raiz, arco, quando);
+    if (!estado)
+        return null;
+    const lacunas = [];
+    const conteudo = estado.conteudo;
+    let consumo = [];
+    let fila = null;
+    if (conteudo && estado.autorizadoPor) {
+        // As unidades dos tetos só: com todos em sessões, nenhuma transcrição nem rollout é lido para o retrato.
+        const medicao = (0, noctum_relatorio_1.medidorDoRelatorio)(opcoes, conteudo)(raiz, estado, quando);
+        const o = conteudo.orcamento;
+        const linha = (escopo, unidade, teto, c) => ({ escopo, unidade, teto, texto: (0, noctum_medicao_1.textoDoConsumo)(c), valor: c.valor });
+        consumo = [linha('do arco', o.arco.unidade, o.arco.valor, (0, noctum_medicao_1.consumoDoEscopoNaUnidade)(medicao, 'arco', o.arco.unidade)),
+            ...o.porConta.map(s => linha(`da conta ${s.conta}`, s.teto.unidade, s.teto.valor, (0, noctum_medicao_1.consumoDoEscopoNaUnidade)(medicao, { conta: s.conta }, s.teto.unidade))),
+            ...o.porRuntime.map(s => linha(`do runtime ${s.runtime}`, s.teto.unidade, s.teto.valor, (0, noctum_medicao_1.consumoDoEscopoNaUnidade)(medicao, { runtime: s.runtime }, s.teto.unidade)))];
+        try {
+            const f = (0, noctum_fechamento_1.trabalhosDoArco)((0, noctum_fila_1.fatosDaFila)(carregado, arco, { quando, maquina: opcoes.maquina, lerReservas: opcoes.lerReservas }));
+            fila = { situacao: f.situacao, trabalhos: f.trabalhos.map(t => ({ id: t.id, item: t.item, thread: t.thread, estado: t.estado, fase: t.fase,
+                    motivo: t.motivo })) };
+            lacunas.push(...f.lacunas);
+        }
+        catch (e) {
+            if (!(e instanceof noctum_envelope_1.RecusaDoArco))
+                throw e;
+            lacunas.push(`a fila do arco não pôde ser lida (${e.motivo})`);
+        }
+    }
+    let fechamento = null;
+    if (estado.encerramento) {
+        let paradas = [];
+        try {
+            const r = (0, noctum_fechamento_1.lerFechamento)(raiz, arco);
+            paradas = r.paradas.map(p => (0, noctum_fechamento_1.textoDaParada)(p, r.conferencias));
+        }
+        catch (e) {
+            if (!(e instanceof noctum_registro_1.RecusaDoRegistro))
+                throw e;
+            lacunas.push(`o registro do fechamento não se lê (${e.motivo})`);
+        }
+        fechamento = { motivo: estado.encerramento.motivo, detalhe: estado.encerramento.detalhe, em: estado.encerramento.em, paradas };
+    }
+    const relatorio = (0, noctum_relatorio_1.retratoDoRelatorio)(raiz, arco, estado.autorizadoPor ? conteudo : null, quando);
+    lacunas.push(...relatorio.lacunas);
+    let supervisao = null;
+    try {
+        supervisao = (0, noctum_relatorio_1.fatosDaSupervisao)(raiz, arco, quando);
+    }
+    catch (e) {
+        if (!(e instanceof noctum_supervisao_1.RecusaDaSupervisao))
+            throw e;
+        lacunas.push(`a supervisão do arco não se lê (${e.motivo})`);
+    }
+    return { contrato: exports.CONTRATO_RETRATO_DO_ARCO, arco, quando, situacao: estado.situacao, versao: estado.versao, envelopeSha256: estado.envelopeSha256,
+        janela: conteudo ? { inicio: conteudo.janela.inicio, fim: conteudo.janela.fim, fuso: conteudo.janela.fuso } : null,
+        propostaPendente: estado.propostaPendente, consumo, fila, fechamento, relatorio, supervisao, decisoesPendentes: estado.decisoes.length, lacunas };
+}
+/** O retrato em texto para pessoa, em pt-BR, com os horários no fuso da janela. */
+function textoDoRetrato(r) {
+    const fuso = r.janela?.fuso;
+    // O nome com `formatar` deixa o lint do horário (horario-lint) ver que o campo ISO passa pelo formatador.
+    const formatarNoFuso = (iso) => (0, horario_1.formatarDataHora)(iso, { fuso, agora: r.quando, locale: 'pt-BR' });
+    const l = [`Arco ${r.arco}: ${r.situacao}${r.versao !== null ? `, versão ${r.versao}` : ''}${r.envelopeSha256 ? `, hash ${r.envelopeSha256.slice(0, 12)}` : ''}`];
+    if (r.janela)
+        l.push(`Janela de ${formatarNoFuso(r.janela.inicio)} a ${formatarNoFuso(r.janela.fim)} (${r.janela.fuso})`);
+    if (r.propostaPendente) {
+        l.push(`Proposta ${r.propostaPendente.versao} esperando o dono até ${formatarNoFuso(r.propostaPendente.prazo)}: hash ${r.propostaPendente.envelopeSha256}`);
+    }
+    if (r.consumo.length)
+        l.push('Consumo medido:', ...r.consumo.map(c => `  • teto ${c.escopo}: ${c.texto} de ${c.teto} ${c.unidade}`));
+    if (r.fila) {
+        l.push(`Fila: ${r.fila.situacao}`, ...r.fila.trabalhos.map(t => `  • ${t.id} (${t.item}): ${t.estado}${t.fase ? `, fase ${t.fase}` : ''}` +
+            `${t.thread ? `, thread ${t.thread}` : ''}${t.motivo ? ` (${t.motivo})` : ''}`));
+    }
+    if (r.fechamento) {
+        l.push(`Fechamento: ${r.fechamento.motivo} em ${formatarNoFuso(r.fechamento.em)}: ${r.fechamento.detalhe}`, ...r.fechamento.paradas.map(p => `  • ${p}`));
+    }
+    else if (r.situacao === 'vigente')
+        l.push('Fechamento: o arco segue');
+    const rel = r.relatorio;
+    if (rel.vencimentoEm) {
+        l.push(`Relatório da manhã: vence ${formatarNoFuso(rel.vencimentoEm)} pelo canal ${rel.canal}` +
+            (rel.versoes.length ? `; ${rel.versoes.map(v => `versão ${v.versao} ${v.entregue ? 'entregue' : 'sem recibo'}`).join(', ')}` : '; nenhuma versão ainda'));
+    }
+    const s = r.supervisao;
+    if (s && (s.parada || s.isolados.length || s.contasFora.length || s.retomadas?.length || s.sessoesParadas?.length)) {
+        l.push('Supervisão:', ...(s.parada ? [`  • parada: ${s.parada}`] : []), ...s.isolados.map(i => `  • isolado ${i.trabalho}: ${i.motivo}`), ...s.contasFora.map(c => `  • a conta ${c.conta} saiu do arco: ${c.motivo}`), ...(s.retomadas ?? []).map(x => `  • retomada autorizada: ${x}`), ...(s.sessoesParadas ?? []).map(x => `  • ${x}`));
+    }
+    if (r.decisoesPendentes)
+        l.push(`Decisões do dono no lote: ${r.decisoesPendentes} (ork noctum relatorio ${r.arco})`);
+    l.push(...(r.lacunas.length ? ['Lacunas:', ...r.lacunas.map(x => `  • ${x}`)] : ['Lacunas: nenhuma']));
+    return l.join('\n');
+}
+/**
+ * O arco terminal e quieto: nada pendente no log e o relatório entregue, ou a janela de entrega dele (24 h depois do
+ * vencimento) acabada, quando o relatório não tenta mais (A3 do CHECK: o canal sem transporte, o terminal nunca mostrado).
+ * O vigia não roda mais, e o log dele não cresce.
+ */
+function terminalQuieto(carregado, arco, estado, quando) {
+    if (!['expirado', 'revogado', 'encerrado'].includes(estado.situacao))
+        return false;
+    if (estado.despachos.some(d => d.desfecho === 'pendente'))
+        return false;
+    try {
+        const r = (0, noctum_relatorio_1.retratoDoRelatorio)(carregado.raiz, arco, estado.conteudo, quando);
+        if (r.versoes.at(-1)?.entregue === true)
+            return true;
+        return !!r.vencimentoEm && Date.parse(quando) >= Date.parse(r.vencimentoEm) + noctum_relatorio_1.JANELA_DE_ENTREGA_MS;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * D13: um tique do arco: o fechamento, o vigia e o relatório, nessa ordem (D7 da ork-rm058integra). O vigia reconcilia e
+ * aplica as paradas mesmo no arco que fechou (as reservas em voo); só com o arco vigente, a supervisão sem parada e o
+ * condutor ausente ele dá o passo do despacho. Antes da janela, e no arco terminal sem reserva pendente e com o relatório
+ * entregue, o vigia não roda. Se o vigia volta com a parada da supervisão, ou o passo encerra pela fila vazia, o
+ * fechamento roda de novo no mesmo tique: quem encerra é o fechamento, nunca o vigia. Com o `passo` do teste, ele roda no
+ * lugar do vigia, só no arco vigente, como na N6. Arco nunca autorizado recusa: o modo não vale. Cada etapa é isolada: a
+ * recusa tipada do fechamento, do vigia ou do passo (o registro do fechamento ou da supervisão adulterado ou ocupado, por
+ * exemplo) vira falha do tique, e o relatório da manhã sai assim mesmo; o erro que não é recusa sobe depois do relatório.
+ */
+function tiqueDoArco(carregado, arco, opcoes = {}) {
+    const quando = opcoes.quando ?? new Date().toISOString();
+    const { raiz } = carregado;
+    const estado = (0, noctum_arco_1.lerArco)(raiz, arco, quando);
+    if (!estado?.autorizadoPor) {
+        throw new noctum_envelope_1.RecusaDoArco('noctum.modo.sem-envelope', `o arco ${arco} nunca foi autorizado pelo dono: o #Noctum não vale; ${COMO_ABRIR}`);
+    }
+    const deFechamento = { quando, maquina: opcoes.maquina, lerReservas: opcoes.lerReservas, medir: opcoes.medir,
+        parar: opcoes.parar, listarSessoes: opcoes.listarSessoes, git: opcoes.git };
+    const falhas = [];
+    let erro = null;
+    const isolada = (etapa, fn) => {
+        try {
+            return fn();
+        }
+        catch (e) {
+            if (e instanceof noctum_envelope_1.RecusaDoArco || e instanceof noctum_registro_1.RecusaDoRegistro || e instanceof noctum_supervisao_1.RecusaDaSupervisao) {
+                falhas.push({ etapa, motivo: e.motivo, detalhe: e.message.slice(0, 300) });
+            }
+            else
+                erro ??= e;
+            return null;
+        }
+    };
+    const queFalhou = () => {
+        let e = null;
+        try {
+            e = (0, noctum_arco_1.lerArco)(raiz, arco, quando);
+        }
+        catch {
+            e = null;
+        }
+        return { fechado: !!e?.encerramento, agora: false, motivo: e?.encerramento?.motivo ?? null, retrato: null, paradas: [], conferencias: [],
+            detalhe: 'o fechamento não terminou neste tique; veja as falhas' };
+    };
+    let fechamento = isolada('fechamento', () => (0, noctum_fechamento_1.fecharSeDevido)(carregado, arco, deFechamento)) ?? queFalhou();
+    let passo = null;
+    let vigia = null;
+    const agora = erro === null && falhas.length === 0 ? (0, noctum_arco_1.lerArco)(raiz, arco, quando) : null;
+    if (opcoes.passo) {
+        if (!fechamento.fechado && agora?.situacao === 'vigente') {
+            passo = isolada('passo', () => opcoes.passo(carregado, arco, quando));
+            if (passo?.acao === 'encerrar')
+                fechamento = isolada('fechamento', () => (0, noctum_fechamento_1.fecharSeDevido)(carregado, arco, deFechamento)) ?? queFalhou();
+        }
+    }
+    else if (agora && agora.situacao !== 'agendado' && !terminalQuieto(carregado, arco, agora, quando)) {
+        const deVigia = { ...opcoes.opcoesDoVigia, quando, maquina: opcoes.maquina ?? opcoes.opcoesDoVigia?.maquina,
+            passo: { maquina: opcoes.maquina, lerReservas: opcoes.lerReservas, ...opcoes.opcoesDoPasso, ...opcoes.opcoesDoVigia?.passo } };
+        vigia = isolada('vigia', () => (opcoes.vigia ?? noctum_vigia_1.vigiarArco)(carregado, arco, deVigia));
+        const doVigia = vigia?.acao === 'tique' ? vigia.passo : null;
+        passo = doVigia && doVigia.acao !== 'parado' && doVigia.acao !== 'geracao-vencida' ? doVigia : null;
+        if (vigia?.acao === 'tique' && !fechamento.fechado && (vigia.parada || passo?.acao === 'encerrar')) {
+            fechamento = isolada('fechamento', () => (0, noctum_fechamento_1.fecharSeDevido)(carregado, arco, deFechamento)) ?? queFalhou();
+        }
+    }
+    let relatorio;
+    try {
+        relatorio = (0, noctum_relatorio_1.entregarRelatorioSeDevido)(carregado, arco, { quando, maquina: opcoes.maquina, lerReservas: opcoes.lerReservas,
+            medir: opcoes.medir, supervisao: opcoes.supervisao, enviar: opcoes.enviar });
+    }
+    catch (e) {
+        throw erro ?? e;
+    }
+    if (erro !== null)
+        throw erro;
+    return { contrato: exports.CONTRATO_TIQUE, arco, quando, fechamento, passo, vigia, relatorio, falhas };
+}

package/dist/noctum-pergunta-canal.js

@@ -0,0 +1,96 @@
+"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.comoResponderAoArco = comoResponderAoArco;
+exports.entregarPerguntaDoArco = entregarPerguntaDoArco;
+/**
+ * RM-057 (resposta curta, D4 da ork-rm057respost): a pergunta do arco #Noctum no canal do dono.
+ *
+ * A pergunta sai pelo transporte do pulse (`.orkastery/monitor/pulse-host.json`, local, fora do git), o mesmo canal que o
+ * onboarding grava para o dono, e entra no lote servido com número: o dono responde "a" ou "sim" em reply, "<código> a"
+ * de qualquer chat autorizado, a palavra solta no chat em que ela saiu, ou o número com a letra ("1a"). Sem transporte, a
+ * pergunta fica só no terminal de quem propôs. O registro só acontece com o recibo do transporte.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const estado_thread_1 = require("./estado-thread");
+const noctum_pergunta_1 = require("./noctum-pergunta");
+const pulse_delivery_1 = require("./pulse-delivery");
+const pulse_resposta_1 = require("./pulse-resposta");
+const transporte_do_canal_1 = require("./transporte-do-canal");
+/**
+ * RM-057 (resposta curta, D9 da ork-rm057respost): como o dono responde à pergunta do arco, sem linha para copiar. O
+ * `/ork noctum <arco> autorizar <sha256>` dos gateways segue aceito, mas não é mais ensinado.
+ */
+function comoResponderAoArco(p) {
+    const ato = p.ato === 'autorizar' ? 'autoriza' : 'revoga';
+    // GO-FIX 1 (achados 1 e 2): o reply vale só para a mensagem da pergunta; o texto ensina o que de fato vale. GO-FIX 2
+    // (D22): o terminal não grava resposta nenhuma, e o texto diz isso em vez de ensinar a digitar lá.
+    return [`Em reply à mensagem da pergunta ${p.codigo} no Telegram, responda com a letra (a ${ato}; b e c não mudam nada)`,
+        `De qualquer chat autorizado do Telegram, mande ${p.codigo} a`,
+        p.ato === 'autorizar' ? `No Claude Code ou em outro host com diálogo nativo: a janela de confirmação, pela ferramenta ork_noctum_autorizar com o arco ${p.arco}`
+            : `No Claude Code ou em outro host com diálogo nativo: a janela de confirmação, pela ferramenta ork_noctum_revogar com o arco ${p.arco}`,
+        'Digitar a resposta no terminal não grava nada: o ingresso do terminal está desligado'];
+}
+const semEntrega = (detalhe) => ({ numero: null, entregue: false, jaServida: false, host: null, destino: null, mensagens: [], detalhe });
+/** Entrega a pergunta ao canal do dono, uma vez, com o número no título; a mesma pergunta em aberto não sai de novo. */
+function entregarPerguntaDoArco(raiz, p, opcoes = {}) {
+    const quando = opcoes.quando ?? new Date().toISOString();
+    const dir = opcoes.estadoDir ?? path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'monitor');
+    const arquivo = path.join(dir, 'pulse-host.json');
+    if (!fs.existsSync(arquivo))
+        return semEntrega('sem transporte do canal (pulse-host.json): a pergunta fica no terminal');
+    let config;
+    try {
+        config = JSON.parse(fs.readFileSync(arquivo, 'utf8'));
+    }
+    catch {
+        return semEntrega('o transporte do canal não se lê');
+    }
+    const destinoDo = (host) => host === null ? null
+        : [config, ...(Array.isArray(config.alternativos) ? config.alternativos : [])].find(t => (0, transporte_do_canal_1.hostDoTransporte)(t) === host)?.destino ?? null;
+    try {
+        const r = (0, pulse_resposta_1.servirPerguntaDoArco)(raiz, p, { quando, estadoDir: dir, entregar: numero => {
+                const e = (0, pulse_delivery_1.entregarPeloTransporte)(raiz, (0, noctum_pergunta_1.textoDaPerguntaDoArco)(p, 'telegram', { quando, numero }), { dir, oQue: 'noctum-pergunta', quando });
+                // GO-FIX 1 (achado 2): os ids da mensagem entregue prendem o reply do dono a ESTA mensagem, e a nenhuma outra.
+                return { ok: e.ok, host: e.host, destino: destinoDo(e.host), mensagens: e.mensagens };
+            } });
+        return { ...r, detalhe: r.entregue ? `entregue pelo ${r.host}` : r.jaServida ? `já tinha saído como a pergunta ${r.numero}`
+                : 'o transporte do canal não confirmou a entrega' };
+    }
+    catch (e) {
+        return semEntrega(`não consegui entregar a pergunta: ${e.message.replace(/\s+/g, ' ').slice(0, 160)}`);
+    }
+}

package/dist/noctum-pergunta.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALTERNATIVAS_DE_REVOGAR = exports.ALTERNATIVAS_DE_AUTORIZAR = exports.CONTRATO_PERGUNTA_DO_ARCO = void 0;
+exports.alternativasDaPergunta = alternativasDaPergunta;
+exports.fraseDaPergunta = fraseDaPergunta;
+exports.textoDaPerguntaDoArco = textoDaPerguntaDoArco;
+exports.textoDoDialogoDoArco = textoDoDialogoDoArco;
+exports.detalhesDaPergunta = detalhesDaPergunta;
+exports.escolhaDaPergunta = escolhaDaPergunta;
+exports.opcoesDaPergunta = opcoesDaPergunta;
+/**
+ * RM-057 (resposta curta, ork-rm057respost): a pergunta do arco #Noctum ao dono, no contrato curto da RM-048.
+ *
+ * Até aqui, autorizar um arco exigia copiar `/ork noctum <arco> autorizar <sha256>` no Telegram: uma linha de 90
+ * caracteres, só num canal, o que a própria RM-057 proíbe, e duas propostas do piloto venceram assim em 20/10/2026. O
+ * dono decidiu: ele aprova onde estiver, com resposta curta. Autorizar e revogar viram perguntas com código curto e três
+ * alternativas, uma recomendada; o dono responde "a", "sim", "1a" ou "<código> a", em reply no Telegram, no terminal do
+ * Claude Code ou pelo diálogo nativo, e o núcleo resolve contra a pergunta pendente.
+ *
+ * O hash do envelope continua sendo o que é autorizado: ele mora na pergunta (a proposta do log do arco), nunca na
+ * resposta, e a resposta só vale para a pergunta de agora (a proposta que mudou tem outro código).
+ *
+ * Este módulo é puro: monta a pergunta, o texto e a escolha. Quem guarda a pergunta é o log do arco (`noctum-arco.ts`);
+ * quem resolve a resposta contra as pendentes é `noctum-resposta.ts`.
+ */
+const horario_1 = require("./horario");
+const hitl_curto_1 = require("./hitl-curto");
+const hitl_texto_livre_1 = require("./hitl-texto-livre");
+const noctum_envelope_1 = require("./noctum-envelope");
+exports.CONTRATO_PERGUNTA_DO_ARCO = 'ork.noctum-pergunta/v1';
+/** A recomendada é a primeira: a proposta é a que o dono pediu. Só ela age; b e c não gravam nada (D13). */
+exports.ALTERNATIVAS_DE_AUTORIZAR = Object.freeze([
+    { letra: 'a', texto: 'Autorizo', acao: 'aprovar', consequencia: 'o arco passa a valer na janela, com este envelope',
+        porque: 'é a proposta pedida, com os valores do envelope; revogar segue valendo a qualquer hora' },
+    { letra: 'b', texto: 'Adiar', acao: 'esperar', consequencia: 'nada muda; a proposta vence no prazo dela' },
+    { letra: 'c', texto: 'Mudar algo', acao: 'recusar', consequencia: 'nada é autorizado; diga o que mudar e uma proposta nova sai' },
+]);
+exports.ALTERNATIVAS_DE_REVOGAR = Object.freeze([
+    { letra: 'a', texto: 'Revogo agora', acao: 'aprovar', consequencia: 'nenhum efeito novo passa, e o arco não reabre',
+        porque: 'a revogação foi pedida, e ela é o ato de segurança do arco' },
+    { letra: 'b', texto: 'Manter o arco', acao: 'esperar', consequencia: 'nada muda; o arco segue até o fim da janela' },
+    { letra: 'c', texto: 'Mudar algo', acao: 'recusar', consequencia: 'nada é revogado; diga o que mudar e uma emenda é proposta' },
+]);
+function alternativasDaPergunta(p) {
+    return p.ato === 'autorizar' ? exports.ALTERNATIVAS_DE_AUTORIZAR : exports.ALTERNATIVAS_DE_REVOGAR;
+}
+/** A pergunta em uma frase. */
+function fraseDaPergunta(p) {
+    return p.ato === 'autorizar' ? `Autorizar o arco ${p.arco} (proposta ${p.versao})?` : `Revogar o arco ${p.arco}?`;
+}
+/** As duas linhas de contexto: o que o dono decide, sem o envelope inteiro (ele fica no detalhe). */
+function corpoDaPergunta(p, quando) {
+    const c = p.conteudo;
+    if (!c)
+        return [];
+    const fuso = c.janela.fuso;
+    const hora = (iso) => (0, horario_1.formatarHora)(iso, { fuso, agora: quando });
+    if (p.ato === 'revogar') {
+        return [`Vigente até ${hora(c.janela.fim)} (${fuso}), proposta ${p.versao}`,
+            'Revogar nega todo efeito novo na hora; o arco não reabre'];
+    }
+    const destinos = c.destinos.map(d => `${d.repositorio} (${d.base}): ${d.permissoes.join(', ')}`).join('; ');
+    const trabalhos = (0, noctum_envelope_1.envelopeComTrabalhos)(c) ? `; ${c.trabalhos.length} trabalho${c.trabalhos.length === 1 ? '' : 's'}` : '';
+    return [`Janela de ${hora(c.janela.inicio)} a ${hora(c.janela.fim)} (${fuso}); ${destinos}`,
+        `Teto do arco: ${c.orcamento.arco.valor} ${c.orcamento.arco.unidade}${trabalhos}; relatório às ${c.relatorio.horario} por ` +
+            `${c.relatorio.canal}`];
+}
+/** O que está parado e o que acontece sem resposta. Expirar nunca autoriza nem revoga. */
+function travaDaPergunta(p, quando) {
+    const prazo = (0, horario_1.formatarHora)(p.prazo, { fuso: p.conteudo?.janela.fuso, agora: quando });
+    return p.ato === 'autorizar'
+        ? `A proposta ${p.versao} vale até ${prazo}. Sem resposta, nada é autorizado.`
+        : `A pergunta vale até ${prazo}. Sem resposta, o arco segue como está.`;
+}
+/**
+ * O texto da pergunta no canal, no contrato curto: o título com o arco e o código, a pergunta, a trava, duas linhas de
+ * contexto, as três alternativas com a recomendada e o porquê, e a linha "responda a, b ou c". Nunca o hash, nunca um
+ * comando para copiar. Com o número do lote servido, ele vai na frente do título.
+ */
+function textoDaPerguntaDoArco(p, canal, opcoes) {
+    const curto = (0, hitl_curto_1.montarPedidoCurto)({
+        thread: null, fase: null, titulo: `arco ${p.arco} · ${p.codigo}`, pergunta: fraseDaPergunta(p), trava: travaDaPergunta(p, opcoes.quando),
+        corpo: corpoDaPergunta(p, opcoes.quando), prazo: p.prazo,
+        alternativas: alternativasDaPergunta(p).map(a => ({ chave: a.letra, texto: a.texto, consequencia: a.consequencia,
+            ...(a.porque ? { recomendada: { porque: a.porque } } : {}) })),
+    }, { quando: opcoes.quando, responder: { tipo: 'letras', codigo: p.codigo, ...(opcoes.numero ? { numero: opcoes.numero } : {}) } });
+    return (0, hitl_curto_1.textoDoPedidoCurto)(curto, canal);
+}
+/**
+ * O texto da pergunta no diálogo nativo do host (D7 da ork-rm057respost): o mesmo contrato curto, com a linha do diálogo no
+ * lugar da das letras. O código vai no título quando a pergunta tem um (a proposta de antes da resposta curta não tem).
+ */
+function textoDoDialogoDoArco(p, quando) {
+    return (0, hitl_curto_1.textoDoPedidoCurto)((0, hitl_curto_1.montarPedidoCurto)({
+        thread: null, fase: null, titulo: p.codigo ? `arco ${p.arco} · ${p.codigo}` : `arco ${p.arco}`, pergunta: fraseDaPergunta(p),
+        trava: travaDaPergunta(p, quando), corpo: corpoDaPergunta(p, quando), prazo: p.prazo,
+        alternativas: alternativasDaPergunta(p).map(a => ({ chave: a.letra, texto: a.texto, consequencia: a.consequencia,
+            ...(a.porque ? { recomendada: { porque: a.porque } } : {}) })),
+    }, { quando, responder: { tipo: 'dialogo' } }), 'terminal');
+}
+/** O detalhe a um pedido de distância ("<código> detalhes"): o envelope inteiro, com o hash, como o dono o autoriza. */
+function detalhesDaPergunta(p) {
+    if (!p.conteudo || !p.envelopeSha256)
+        return `A pergunta ${p.codigo} do arco ${p.arco} não tem envelope para mostrar.`;
+    return [`Envelope da pergunta ${p.codigo} (arco ${p.arco}, proposta ${p.versao}):`, ...(0, noctum_envelope_1.resumoDoEnvelope)(p.conteudo, p.envelopeSha256)].join('\n');
+}
+/** A escolha pela letra, pelo dígito ou pela palavra do vocabulário fechado, pelas ações. Ambígua volta como ambígua. */
+function escolhaDaPergunta(p, trecho) {
+    const alternativas = alternativasDaPergunta(p);
+    return (0, hitl_texto_livre_1.resolverTrecho)(trecho, alternativas.map(a => a.acao), alternativas.map(a => a.letra));
+}
+/** As alternativas reais em uma linha, para a resposta que não deu para registrar. */
+function opcoesDaPergunta(p) {
+    return alternativasDaPergunta(p).map(a => `${a.letra} (${a.texto})`).join(', ');
+}