@orkastery/cli 0.5.6 → 0.6.1

package/dist/noctum-cli.js

@@ -0,0 +1,539 @@
+"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.USO_DO_NOCTUM = void 0;
+exports.avisosDaProposta = avisosDaProposta;
+exports.conduzirPeloCli = conduzirPeloCli;
+exports.comandoNoctum = comandoNoctum;
+/**
+ * RM-058, fatia N6 (D1, D12 e D13 da ork-rm058n6): o comando `ork noctum`, a porta do CLI para o arco.
+ *
+ *   ork noctum propor --arquivo <envelope.json> [--json]   o pedido de abertura vira proposta e pergunta ao dono; nada é autorizado
+ *   ork noctum maquina [--json]                            a entrada desta máquina em `maquinas` do envelope `v3`: o nome, a
+ *                                                          chave pública e a impressão (RM-058, bloco B, D5)
+ *   ork noctum revogar <arco> [--json]                     a pergunta de revogação ao dono (RM-057); nada é revogado
+ *   ork noctum responder <arco> --resposta-stdin ...       o envelope assinado do gateway (autorizar ou revogar)
+ *   ork noctum terminal --hook-stdin                       o ingresso do terminal, que o hook UserPromptSubmit chama (RM-057);
+ *                                                          desligado (D22): só devolve o aviso de por onde responder
+ *   ork noctum status [<arco>] [--json]                    o retrato do arco, com as lacunas; sem arco, a lista
+ *   ork noctum tique <arco> [--json]                       fechamento, passo e relatório: o que o cron do dono chama
+ *   ork noctum relatorio <arco> [--json] [--reenviar C]    o relatório no terminal, ou o reenvio que o dono pede
+ *   ork noctum conduzir <arco> [--json]                    o condutor do arco (RM-058, integração, D9): o cron do piloto o
+ *                                                          relança, e a trava do kernel prova o vivo
+ *   ork noctum aceite <arco> [--json] [--injecoes A]       o aceite do piloto (D12): as medidas M1 a M10, os critérios e o
+ *        [--limiares A] [--publicar A]                     veredito, o arquivo completo no estado e o publicável
+ *
+ * Nenhum subcomando autoriza pelo terminal: o dono autoriza por ingresso autenticado (o gateway assinado, que chega
+ * aqui pelo `responder`, ou o diálogo nativo do host pelo MCP). Recusa tipada sai na saída de erro, com código 2.
+ */
+const fs = __importStar(require("node:fs"));
+const node_crypto_1 = require("node:crypto");
+const fila_pesada_1 = require("./fila-pesada");
+const hitl_gates_1 = require("./hitl-gates");
+const hitl_public_receipt_1 = require("./hitl-public-receipt");
+const impedimento_1 = require("./impedimento");
+const noctum_aceite_1 = require("./noctum-aceite");
+const horario_1 = require("./horario");
+const manifest_1 = require("./manifest");
+const noctum_arco_1 = require("./noctum-arco");
+const noctum_pergunta_1 = require("./noctum-pergunta");
+const noctum_pergunta_canal_1 = require("./noctum-pergunta-canal");
+const pulse_resposta_1 = require("./pulse-resposta");
+const noctum_envelope_1 = require("./noctum-envelope");
+const noctum_modo_1 = require("./noctum-modo");
+const noctum_relatorio_1 = require("./noctum-relatorio");
+const noctum_registro_1 = require("./noctum-registro");
+const noctum_supervisao_1 = require("./noctum-supervisao");
+const noctum_transporte_1 = require("./noctum-transporte");
+const noctum_vigia_1 = require("./noctum-vigia");
+const maquina_1 = require("./maquina");
+const runtime_profiles_1 = require("./runtime-profiles");
+const noctum_terminal_1 = require("./noctum-terminal");
+const transporte_do_canal_1 = require("./transporte-do-canal");
+exports.USO_DO_NOCTUM = 'uso: ork noctum propor --arquivo <envelope.json> | maquina [--json] | revogar <arco> [--json] | ' +
+    'responder <arco> --resposta-stdin ' +
+    '--origem O --canal C --por P --mensagem M [--conta X] | terminal --hook-stdin | status [<arco>] [--json] | tique <arco> [--json] | ' +
+    'relatorio <arco> [--json] [--reenviar <canal>] | conduzir <arco> [--json] | aceite <arco> [--json] [--injecoes <arquivo>] ' +
+    '[--limiares <arquivo>] [--outra-maquina <arquivo>[,<arquivo>]] [--publicar <arquivo>]';
+/** A linha da entrega da pergunta ao canal do dono, sem caminho de máquina. */
+function linhaDaEntrega(e) {
+    if (e.entregue)
+        return `A pergunta também saiu no canal do dono, como a pergunta ${e.numero} (${e.detalhe}).`;
+    if (e.jaServida)
+        return `A pergunta já tinha saído no canal do dono como a pergunta ${e.numero}.`;
+    return `A pergunta não saiu no canal do dono: ${e.detalhe}.`;
+}
+/** RM-057 (resposta curta): a entrada do hook `UserPromptSubmit` tem teto, como o envelope do ingresso. */
+const TETO_DA_ENTRADA_DO_HOOK = 64 * 1024;
+/** A entrada do hook pela entrada padrão, ou `null` quando ela passa do teto ou não é JSON. */
+function lerEntradaDoHookStdin() {
+    const partes = [];
+    let total = 0;
+    for (;;) {
+        const buf = Buffer.alloc(4096), n = fs.readSync(0, buf, 0, buf.length, null);
+        if (!n)
+            break;
+        total += n;
+        if (total > TETO_DA_ENTRADA_DO_HOOK)
+            return null;
+        partes.push(buf.subarray(0, n));
+    }
+    try {
+        return JSON.parse(Buffer.concat(partes).toString('utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** O pedido de abertura cabe numa leitura do dono: o envelope inteiro tem teto, como o pedido de cada trabalho. */
+const TETO_DO_ARQUIVO_DO_ENVELOPE = 64 * 1024;
+const texto = (v) => typeof v === 'string' ? v : undefined;
+/**
+ * RM-058, bloco B (D22): no `v3`, esta máquina só entra no arco se está em `maquinas` com o nome e a chave desta raiz,
+ * a mesma conferência do `euNaVersaoVigente`. O aviso só antecipa a recusa: a proposta segue.
+ */
+function avisosDaMaquina(maquinas, eu) {
+    const listada = maquinas.find(m => m.nome === eu.nome);
+    const correcao = 'rode ork noctum maquina --json nesta máquina e ponha a saída em maquinas do envelope';
+    if (!listada) {
+        return [{ motivo: 'noctum.proposta.maquina-ausente', correcao,
+                detalhe: `esta máquina (${eu.nome}) não está em maquinas do envelope v3: fica fora do arco, sem ordem, despacho nem entrega` }];
+    }
+    if (listada.chave === eu.chave)
+        return [];
+    return [{ motivo: 'noctum.proposta.maquina-outra-chave', correcao,
+            detalhe: `o envelope dá à máquina ${eu.nome} a chave de impressão ${(0, noctum_envelope_1.impressaoDaChave)(listada.chave)}, e a desta raiz é ` +
+                `${(0, noctum_envelope_1.impressaoDaChave)(eu.chave)}: a máquina fica fora do arco` }];
+}
+/**
+ * Pré-voo informativo da proposta: antecipa as causas que fariam o arco esperar, mas não autoriza nem bloqueia nada.
+ * As dependências opcionais deixam os testes usar perfis, trust e a identidade da máquina simulados sem ler contas reais.
+ */
+function avisosDaProposta(carregado, conteudo, opcoes = {}) {
+    if (!(0, noctum_envelope_1.envelopeComTrabalhos)(conteudo))
+        return [];
+    const avisos = (0, noctum_envelope_1.envelopeMultimaquina)(conteudo)
+        ? avisosDaMaquina(conteudo.maquinas, (opcoes.identidade ?? (() => (0, noctum_transporte_1.identidadeDaMaquina)(carregado.raiz)))()) : [];
+    let store = null;
+    try {
+        store = opcoes.store ?? (0, runtime_profiles_1.lerPerfisComContas)(carregado.raiz);
+    }
+    catch {
+        avisos.push({ motivo: 'noctum.proposta.contas-sem-leitura', detalhe: 'as contas do envelope não puderam ser conferidas',
+            correcao: 'rode ork accounts check e proponha de novo depois de corrigir a leitura' });
+    }
+    const confiar = opcoes.confianca ?? ((raiz, p) => (0, impedimento_1.impedimentoResolvido)('runtime.workspace-untrusted', { cwd: raiz, runtime: p.runtime, configDir: (0, runtime_profiles_1.diretorioDoPerfil)(p) }));
+    if (store) {
+        for (const { conta } of conteudo.capacidade.porConta) {
+            const p = store.perfis.find(x => x.id === conta);
+            if (!p || p.estado === 'sem-auth') {
+                avisos.push({ motivo: 'noctum.proposta.conta-sem-login',
+                    detalhe: `a conta ${conta} do envelope está sem login de assinatura conferido`,
+                    correcao: `refaça o login da conta ${conta} pelo próprio CLI e rode ork accounts check ${conta}` });
+            }
+            if (p?.runtime === 'claude-bg' && confiar(carregado.raiz, p) !== true) {
+                avisos.push({ motivo: 'noctum.proposta.workspace-untrusted',
+                    detalhe: `a conta ${conta} não tem o trust da pasta do projeto aceito no runtime; o despacho cairia em runtime.workspace-untrusted`,
+                    correcao: `abra o runtime da conta ${conta} na pasta do projeto e aceite a confiança` });
+            }
+        }
+    }
+    if (conteudo.capacidade.maquina - conteudo.capacidade.revisao === 1) {
+        avisos.push({ motivo: 'noctum.proposta.vaga-de-execucao-unica',
+            detalhe: `a capacidade da máquina (${conteudo.capacidade.maquina}) menos a revisão (${conteudo.capacidade.revisao}) deixa uma vaga de execução`,
+            correcao: 'confirme que uma única sessão de execução por vez é suficiente ou emende a capacidade' });
+    }
+    const hostLocal = () => {
+        try {
+            const lido = JSON.parse(fs.readFileSync((0, transporte_do_canal_1.caminhoDoPulseHost)(carregado.raiz), 'utf8'));
+            if (!(0, transporte_do_canal_1.transporteValido)(lido))
+                return null;
+            const host = (0, transporte_do_canal_1.hostDoTransporte)(lido);
+            return transporte_do_canal_1.HOSTS_DO_CANAL.includes(host) ? host : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    const host = opcoes.hostDoDono === undefined ? hostLocal() : opcoes.hostDoDono;
+    if (host && !(0, hitl_public_receipt_1.canVerifyPublicReceipt)(host, false, opcoes.env ?? process.env)) {
+        avisos.push({ motivo: 'noctum.proposta.sem-verificador-do-canal',
+            detalhe: `este processo não consegue reconferir a prova do dono recebida pelo ${host}`,
+            correcao: 'o cron do condutor e do tique precisa de ORK_RECEIPT_VERIFIERS com o verificador público gerado por publicHitlVerifiers; ' +
+                'a chave de ingresso nunca deve ir ao ambiente dos agentes' });
+    }
+    return avisos;
+}
+const TERMINAIS = ['expirado', 'revogado', 'encerrado'];
+/**
+ * O que o `ork noctum conduzir` roda: confere o arco antes da trava (o arco terminal, ou parado pela supervisão, sai 0 sem
+ * tomar a trava nem gravar geração) e então conduz pelo `conduzirArco`, com as dependências reais. Os testes passam as
+ * simuladas (o `dormir`, o `relogio`, o `maxPassos` e as do passo); o comando de terminal não tem opção de teste.
+ */
+function conduzirPeloCli(carregado, arco, opcoes = {}) {
+    const { raiz } = carregado;
+    if (!(0, fila_pesada_1.kernelDisponivel)())
+        return { acao: 'sem-kernel', detalhe: 'o condutor exige /usr/bin/flock', codigo: 2 };
+    const estado = (0, noctum_arco_1.lerArco)(raiz, arco);
+    if (!estado)
+        return { acao: 'sem-arco', detalhe: `o arco ${arco} não tem proposta`, codigo: 2 };
+    if (!estado.autorizadoPor) {
+        return { acao: 'nunca-autorizado', motivo: 'noctum.modo.sem-envelope', detalhe: `o arco ${arco} nunca foi autorizado pelo dono: o #Noctum não vale`,
+            codigo: 2 };
+    }
+    if (TERMINAIS.includes(estado.situacao)) {
+        return { acao: 'terminal', situacao: estado.situacao, detalhe: `o arco ${arco} está ${estado.situacao}: não há o que conduzir`, codigo: 0 };
+    }
+    let parada;
+    try {
+        parada = (0, noctum_supervisao_1.lerSupervisao)(raiz, arco).parada;
+    }
+    catch (e) {
+        if (e instanceof noctum_supervisao_1.RecusaDaSupervisao)
+            return { acao: 'supervisao-ilegivel', motivo: e.motivo, detalhe: e.message, codigo: 2 };
+        throw e;
+    }
+    if (parada)
+        return { acao: 'parado', motivo: parada.motivo, detalhe: `a supervisão parou o arco ${arco}: ${parada.detalhe}`, codigo: 0 };
+    const r = (0, noctum_vigia_1.conduzirArco)(carregado, arco, opcoes);
+    const codigo = r.acao === 'outro-condutor' ? 3 : r.acao === 'saiu' ? (r.ultimo?.acao === 'geracao-vencida' ? 4 : 0) : 2;
+    return { ...r, codigo };
+}
+/** A linha do condutor no terminal: o desfecho, com o motivo. */
+function textoDoCondutor(arco, r) {
+    if (r.acao !== 'saiu')
+        return `Condutor do arco ${arco}: ${r.acao}${'motivo' in r ? ` (${r.motivo})` : ''}: ${r.detalhe}`;
+    const u = r.ultimo;
+    const ultimo = !u ? 'nenhum passo' : `${u.acao}${'motivo' in u && u.motivo ? ` (${u.motivo})` : ''}${'detalhe' in u && u.detalhe ? `: ${u.detalhe}` : ''}`;
+    return `Condutor do arco ${arco}: saiu na geração ${r.geracao}, depois de ${r.passos} passo(s); o último: ${ultimo}`;
+}
+/** O aceite no terminal: o veredito, as marcas de simulação, as medidas, os critérios e onde ficou o arquivo completo. */
+function textoDoAceite(r, gravado) {
+    const valor = (v, unidade) => v === null ? 'lacuna' : `${v} ${unidade}`;
+    return [`Aceite do piloto do arco ${r.arco}: ${r.veredito} (sha256 ${gravado.sha256.slice(0, 12)})`,
+        ...(r.simulacao.simulado ? ['Simulado, nunca vale como piloto:', ...r.simulacao.marcas.map(x => `  • ${x}`)] : []),
+        'Medidas:', ...r.medidas.map(x => `  ${x.id} ${x.nome}: ${valor(x.valor, x.unidade)}${x.lacunas.length ? ` (lacunas: ${x.lacunas.join('; ')})` : ''}`),
+        'Critérios:', ...r.criterios.map(c => `  ${c.id} [${c.veredito}] ${c.texto}` +
+            `${c.limiar ? ` (limiar ${Object.entries(c.limiar).map(([k, v]) => `${k}=${v}`).join(', ')}, ${c.origemDoLimiar})` : ''}: ${c.detalhe}`),
+        `Arquivo completo: ${gravado.arquivo}`].join('\n');
+}
+function recusado(e) {
+    // A recusa da supervisão (o log adulterado ou ocupado no meio do laço do condutor) também é recusa: sai 2, como o contrato diz.
+    if (e instanceof noctum_envelope_1.RecusaDoArco || e instanceof noctum_registro_1.RecusaDoRegistro || e instanceof noctum_aceite_1.RecusaDoAceite || e instanceof noctum_supervisao_1.RecusaDaSupervisao) {
+        console.error(e.message);
+        return 2;
+    }
+    throw e;
+}
+function comandoNoctum(args) {
+    const sub = args.posicionais[1];
+    const json = args.opcoes.json === true;
+    try {
+        if (sub === 'propor') {
+            const arquivo = texto(args.opcoes.arquivo);
+            if (!arquivo || args.posicionais.length !== 2) {
+                console.error(exports.USO_DO_NOCTUM);
+                return 2;
+            }
+            let st;
+            try {
+                st = fs.statSync(arquivo);
+            }
+            catch {
+                console.error(`noctum.envelope.invalido: o pedido de abertura ${arquivo} não se lê`);
+                return 2;
+            }
+            if (!st.isFile() || st.size > TETO_DO_ARQUIVO_DO_ENVELOPE) {
+                console.error(`noctum.envelope.invalido: o pedido de abertura é um arquivo JSON de até ${TETO_DO_ARQUIVO_DO_ENVELOPE} bytes`);
+                return 2;
+            }
+            let pedido;
+            try {
+                pedido = JSON.parse(fs.readFileSync(arquivo, 'utf8'));
+            }
+            catch {
+                console.error('noctum.envelope.invalido: o pedido de abertura não é JSON');
+                return 2;
+            }
+            const carregado = (0, manifest_1.exigirManifesto)();
+            const { raiz } = carregado;
+            const quando = new Date().toISOString();
+            const r = (0, noctum_arco_1.proporEnvelope)(raiz, pedido, quando, (0, pulse_resposta_1.codigosEmUso)(raiz));
+            // Os avisos olham o envelope que o dono vai autorizar, já validado pelo proporEnvelope: o vigente (lerArco) só
+            // existe depois da autorização, e na primeira proposta os avisos sumiam (RM-058, bloco B).
+            const proposto = (0, noctum_envelope_1.validarPedidoDeAbertura)(pedido);
+            const fuso = proposto.janela.fuso;
+            const avisos = avisosDaProposta(carregado, proposto);
+            // RM-057 (resposta curta, D4 e D9): a proposta é a pergunta ao dono, que sai também pelo canal dele quando ele tem um.
+            const q = r.codigo ? (0, noctum_arco_1.perguntasDoArco)(raiz, r.arco, quando).find(x => x.codigo === r.codigo && x.situacao === 'pendente') : undefined;
+            const entrega = q ? (0, noctum_pergunta_canal_1.entregarPerguntaDoArco)(raiz, q, { quando }) : null;
+            const textoDaPergunta = q ? (0, noctum_pergunta_1.textoDaPerguntaDoArco)(q, 'terminal', { quando, ...(entrega?.numero ? { numero: entrega.numero } : {}) }) : null;
+            const instrucoes = q ? (0, noctum_pergunta_canal_1.comoResponderAoArco)(q) : [`O envelope ${r.envelopeSha256.slice(0, 12)} já vale no arco ${r.arco}: não há o que autorizar`];
+            if (json) {
+                console.log(JSON.stringify({ ...r, autorizado: false, avisos, comoAutorizar: instrucoes,
+                    pergunta: q ? { codigo: q.codigo, prazo: q.prazo, texto: textoDaPergunta, entrega } : null }, null, 2));
+            }
+            else {
+                console.log([...r.resumo, '',
+                    ...(avisos.length ? ['Avisos (não bloqueiam a proposta):', ...avisos.map(a => `• ${a.motivo}: ${a.detalhe}. Correção: ${a.correcao}.`), ''] : []),
+                    `Proposta ${r.versao} do arco ${r.arco}, vale até ${(0, horario_1.formatarDataHora)(r.prazo, { fuso, locale: 'pt-BR' })}.`,
+                    'Nada foi autorizado: o dono autoriza respondendo à pergunta, nunca por silêncio nem por este comando.',
+                    ...(textoDaPergunta ? ['', textoDaPergunta, '', linhaDaEntrega(entrega)] : instrucoes)].join('\n'));
+            }
+            return 0;
+        }
+        if (sub === 'maquina') {
+            // RM-058, bloco B (B4, D5): o que o dono copia de cada máquina para `maquinas` do envelope `v3`. O nome vem antes da
+            // chave: o recusado não cria a chave local. A chave privada nunca sai desta raiz.
+            if (args.posicionais.length !== 2) {
+                console.error(exports.USO_DO_NOCTUM);
+                return 2;
+            }
+            const { raiz } = (0, manifest_1.exigirManifesto)();
+            const nome = (0, maquina_1.nomeDaMaquina)();
+            if (!noctum_transporte_1.NOME_DE_MAQUINA.test(nome)) {
+                console.error(`noctum.maquina.nome-invalido: o nome desta máquina ("${nome}") não serve no envelope v3: letras, dígitos, ` +
+                    'ponto, _ ou -, até 64, começando por letra ou dígito. Correção: grave um nome válido em ~/.orkastery/maquina.json ' +
+                    '(o campo nome) ou defina ORK_MAQUINA em todo processo do ork desta máquina, o cron e os gateways inclusive');
+                return 2;
+            }
+            const { chave } = (0, noctum_transporte_1.identidadeDaMaquina)(raiz, nome);
+            const impressao = (0, noctum_envelope_1.impressaoDaChave)(chave);
+            if (json)
+                console.log(JSON.stringify({ nome, chave, impressao }, null, 2));
+            else {
+                console.log(['Esta máquina no envelope v3:', `  nome       ${nome}`, `  chave      ${chave}`, `  impressão  ${impressao}`, '',
+                    'A entrada para maquinas do envelope:', JSON.stringify({ nome, chave }), '',
+                    'A chave privada não sai desta raiz; o dono confere a impressão no resumo da proposta.'].join('\n'));
+            }
+            return 0;
+        }
+        if (sub === 'revogar') {
+            // RM-057 (resposta curta, D10): abre a pergunta de revogação e a entrega; quem revoga é a resposta do dono.
+            const arco = args.posicionais[2];
+            if (!arco || args.posicionais.length !== 3) {
+                console.error(exports.USO_DO_NOCTUM);
+                return 2;
+            }
+            const { raiz } = (0, manifest_1.exigirManifesto)();
+            const quando = new Date().toISOString();
+            const r = (0, noctum_arco_1.pedirRevogacao)(raiz, arco, quando, (0, pulse_resposta_1.codigosEmUso)(raiz));
+            const q = (0, noctum_arco_1.perguntasDoArco)(raiz, arco, quando).find(x => x.codigo === r.codigo);
+            const entrega = (0, noctum_pergunta_canal_1.entregarPerguntaDoArco)(raiz, q, { quando });
+            const textoDaPergunta = (0, noctum_pergunta_1.textoDaPerguntaDoArco)(q, 'terminal', { quando, ...(entrega.numero ? { numero: entrega.numero } : {}) });
+            if (json) {
+                console.log(JSON.stringify({ arco, revogado: false, comoRevogar: (0, noctum_pergunta_canal_1.comoResponderAoArco)(q),
+                    pergunta: { codigo: q.codigo, prazo: q.prazo, nova: r.nova, texto: textoDaPergunta, entrega } }, null, 2));
+            }
+            else {
+                console.log([textoDaPergunta, '', linhaDaEntrega(entrega), 'Nada foi revogado: o dono revoga respondendo à pergunta.'].join('\n'));
+            }
+            return 0;
+        }
+        if (sub === 'responder') {
+            const arco = args.posicionais[2];
+            if (!arco || args.posicionais.length !== 3 || args.opcoes['resposta-stdin'] !== true || args.opcoes.resposta !== undefined) {
+                console.error('noctum responder exige o arco, --resposta-stdin e o envelope do ingresso autenticado na entrada');
+                return 2;
+            }
+            // A entrada malformada ou o argv que diverge do envelope é recusa tipada, como a do núcleo, e nunca autoriza nada.
+            let envelope;
+            try {
+                envelope = (0, hitl_gates_1.lerRespostaStdin)({ por: texto(args.opcoes.por), mensagem: texto(args.opcoes.mensagem), origem: texto(args.opcoes.origem),
+                    canal: texto(args.opcoes.canal), conta: texto(args.opcoes.conta) });
+            }
+            catch (e) {
+                console.error(`noctum.origem.sem-prova: ${e.message.slice(0, 300)}`);
+                return 2;
+            }
+            console.log(JSON.stringify((0, noctum_modo_1.responderAoArco)((0, manifest_1.exigirManifesto)().raiz, arco, envelope)));
+            return 0;
+        }
+        if (sub === 'terminal') {
+            // RM-057 (resposta curta, D5): o ingresso do terminal, que o hook UserPromptSubmit do plugin chama. Sai 0 sempre: a
+            // decisão vai em JSON, e o hook só a transporta. GO-FIX 2 (D22): o ingresso está desligado, e este comando nunca o
+            // liga; a resposta curta a uma pergunta que espera o dono volta recusada, com o aviso de por onde responder.
+            if (args.opcoes['hook-stdin'] !== true || args.posicionais.length !== 2) {
+                console.error(exports.USO_DO_NOCTUM);
+                return 2;
+            }
+            const entrada = lerEntradaDoHookStdin();
+            let raiz = null;
+            try {
+                raiz = (0, manifest_1.exigirManifesto)().raiz;
+            }
+            catch {
+                raiz = null;
+            }
+            try {
+                console.log(JSON.stringify((0, noctum_terminal_1.responderPeloTerminal)(raiz, entrada, { env: process.env })));
+            }
+            catch (e) {
+                console.error(`noctum terminal: ${e.message.slice(0, 200)}`);
+                console.log(JSON.stringify({ contrato: noctum_terminal_1.CONTRATO_DO_TERMINAL, acao: 'ignorar', motivo: 'erro-interno' }));
+            }
+            return 0;
+        }
+        if (sub === 'status') {
+            const carregado = (0, manifest_1.exigirManifesto)();
+            const arco = args.posicionais[2];
+            if (!arco) {
+                const arcos = (0, noctum_modo_1.listarArcos)(carregado.raiz).map(a => {
+                    try {
+                        return { arco: a, situacao: (0, noctum_arco_1.lerArco)(carregado.raiz, a)?.situacao ?? 'sem-proposta' };
+                    }
+                    catch (e) {
+                        return { arco: a, situacao: 'ilegivel', detalhe: e.message.slice(0, 200) };
+                    }
+                });
+                if (json)
+                    console.log(JSON.stringify({ arcos }, null, 2));
+                else
+                    console.log(arcos.length ? arcos.map(x => `${x.arco}: ${x.situacao}`).join('\n') : 'Nenhum arco #Noctum neste projeto.');
+                return 0;
+            }
+            const r = (0, noctum_modo_1.retratoDoArco)(carregado, arco);
+            if (!r) {
+                console.error(`noctum.efeito.sem-autorizacao: o arco ${arco} não tem proposta`);
+                return 2;
+            }
+            console.log(json ? JSON.stringify(r, null, 2) : (0, noctum_modo_1.textoDoRetrato)(r));
+            return 0;
+        }
+        if (sub === 'tique') {
+            const arco = args.posicionais[2];
+            if (!arco || args.posicionais.length !== 3) {
+                console.error(exports.USO_DO_NOCTUM);
+                return 2;
+            }
+            const r = (0, noctum_modo_1.tiqueDoArco)((0, manifest_1.exigirManifesto)(), arco);
+            if (json)
+                console.log(JSON.stringify(r, null, 2));
+            else {
+                console.log([`Tique do arco ${arco}:`,
+                    `  fechamento: ${r.fechamento.fechado ? `${r.fechamento.motivo}${r.fechamento.agora ? ' (agora)' : ''}` : r.fechamento.detalhe}`,
+                    `  passo: ${r.passo ? `${r.passo.acao}${'motivo' in r.passo && r.passo.motivo ? ` (${r.passo.motivo})` : ''}` : 'nenhum'}`,
+                    `  relatório: ${r.relatorio.acao}: ${r.relatorio.detalhe}`,
+                    ...r.falhas.map(f => `  falha no ${f.etapa}: ${f.detalhe}`)].join('\n'));
+            }
+            // A falha de uma etapa não segura o relatório, mas o cron do dono a vê pela saída.
+            return r.falhas.length ? 1 : 0;
+        }
+        if (sub === 'relatorio') {
+            const arco = args.posicionais[2];
+            if (!arco || args.posicionais.length !== 3) {
+                console.error(exports.USO_DO_NOCTUM);
+                return 2;
+            }
+            const carregado = (0, manifest_1.exigirManifesto)();
+            const reenviar = texto(args.opcoes.reenviar);
+            if (args.opcoes.reenviar !== undefined) {
+                if (!reenviar || reenviar === 'terminal' || !noctum_envelope_1.CANAIS_DO_RELATORIO.includes(reenviar)) {
+                    console.error('noctum relatorio --reenviar exige o canal telegram ou openclaw');
+                    return 2;
+                }
+                const r = (0, noctum_relatorio_1.reenviarRelatorio)(carregado, arco, reenviar);
+                console.log(json ? JSON.stringify(r, null, 2) : `Reenvio pelo canal ${reenviar}: ${r.acao}, ${r.enviadas} página(s) confirmada(s). ${r.detalhe}`);
+                return r.acao === 'entregue' ? 0 : 1;
+            }
+            // O recibo do canal terminal só vem do terminal interativo, nunca de saída redirecionada nem do --json.
+            const r = (0, noctum_relatorio_1.relatorioNoTerminal)(carregado, arco, { interativo: !json && process.stdout.isTTY === true });
+            if (!r) {
+                console.error(`noctum.efeito.sem-autorizacao: o arco ${arco} não tem envelope autorizado`);
+                return 2;
+            }
+            console.log(json ? JSON.stringify(r, null, 2) : r.paginas.join('\n\n'));
+            return 0;
+        }
+        if (sub === 'conduzir') {
+            const arco = args.posicionais[2];
+            if (!arco || args.posicionais.length !== 3) {
+                console.error(exports.USO_DO_NOCTUM);
+                return 2;
+            }
+            const r = conduzirPeloCli((0, manifest_1.exigirManifesto)(), arco);
+            if (json)
+                console.log(JSON.stringify(r, null, 2));
+            else if (r.codigo === 2)
+                console.error(textoDoCondutor(arco, r));
+            else
+                console.log(textoDoCondutor(arco, r));
+            return r.codigo;
+        }
+        if (sub === 'aceite') {
+            const arco = args.posicionais[2];
+            const arquivo = (nome) => args.opcoes[nome] === undefined ? null : texto(args.opcoes[nome]) ?? false;
+            const [injecoes, limiares, outraMaquina, publicar] = [arquivo('injecoes'), arquivo('limiares'), arquivo('outra-maquina'), arquivo('publicar')];
+            if (!arco || args.posicionais.length !== 3 || injecoes === false || limiares === false || outraMaquina === false || publicar === false) {
+                console.error(exports.USO_DO_NOCTUM);
+                return 2;
+            }
+            let agenda = null, doDono = null;
+            const outrasMaquinas = [];
+            try {
+                if (injecoes)
+                    agenda = (0, noctum_aceite_1.lerInjecoes)(fs.readFileSync(injecoes, 'utf8'));
+                if (limiares)
+                    doDono = (0, noctum_aceite_1.lerLimiares)(JSON.parse(fs.readFileSync(limiares, 'utf8')));
+                for (const fonte of (outraMaquina ? outraMaquina.split(',') : []).map(x => x.trim()).filter(Boolean)) {
+                    const bruto = fs.readFileSync(fonte, 'utf8');
+                    outrasMaquinas.push({ fonte, sha256: (0, node_crypto_1.createHash)('sha256').update(bruto).digest('hex'), resultado: JSON.parse(bruto) });
+                }
+            }
+            catch (e) {
+                if (e instanceof noctum_aceite_1.RecusaDoAceite)
+                    throw e;
+                console.error(`noctum.aceite.arquivo: ${e.message.slice(0, 200)}`);
+                return 2;
+            }
+            const carregado = (0, manifest_1.exigirManifesto)();
+            // RM-058, integração (T8, D12): o arquivo completo fica no estado; o publicável vai aonde o dono pedir.
+            const r = (0, noctum_aceite_1.aceiteDoPiloto)(carregado, arco, { injecoes: agenda, limiares: doDono, outrasMaquinas });
+            const gravado = (0, noctum_aceite_1.gravarAceite)(carregado.raiz, r);
+            if (publicar)
+                fs.writeFileSync(publicar, `${JSON.stringify((0, noctum_aceite_1.publicavel)(r, gravado.sha256, (0, noctum_aceite_1.sensiveisDoArco)(carregado, arco)), null, 2)}\n`);
+            if (json)
+                console.log(JSON.stringify({ ...r, sha256: gravado.sha256, arquivo: gravado.arquivo }, null, 2));
+            else
+                console.log(textoDoAceite(r, gravado));
+            return r.veredito === 'aprovado' ? 0 : 1;
+        }
+    }
+    catch (e) {
+        return recusado(e);
+    }
+    console.error(exports.USO_DO_NOCTUM);
+    return 2;
+}