@orkastery/cli 0.5.6 → 0.6.1

package/dist/noctum-resposta.js

@@ -0,0 +1,207 @@
+"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.perguntasDosArcos = perguntasDosArcos;
+exports.perguntasPendentes = perguntasPendentes;
+exports.perguntasPorCodigo = perguntasPorCodigo;
+exports.perguntasComRespostaSemEfeito = perguntasComRespostaSemEfeito;
+exports.rotuloDaPergunta = rotuloDaPergunta;
+exports.responderPerguntaDoArco = responderPerguntaDoArco;
+/**
+ * RM-057 (resposta curta, ork-rm057respost): a resposta curta do dono contra as perguntas dos arcos #Noctum.
+ *
+ * Quem chega aqui já provou a origem: o receptor do pulse conferiu o envelope assinado do Telegram, e o ingresso do
+ * terminal conferiu a origem da sessão. Este módulo só acha a pergunta (pelo código, ou a única que cabe), lê a escolha
+ * pela letra ou pela palavra do vocabulário fechado, chama o ato do arco com a prova e devolve a frase ao dono. Ele nunca
+ * escolhe pelo dono: ambígua, fora do vocabulário ou sem pergunta, a resposta volta como pergunta e nada é gravado.
+ *
+ * As alternativas b (adiar) e c (mudar algo) não gravam nada no arco (D13): a pergunta segue pendente até o prazo. Elas
+ * ficam só num registro à parte (GO-FIX 1, achado 3): depois de "b" ou "c", a palavra solta não responde mais àquela
+ * pergunta no terminal, e só o código dela vale.
+ */
+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 noctum_arco_1 = require("./noctum-arco");
+const noctum_envelope_1 = require("./noctum-envelope");
+const noctum_pergunta_1 = require("./noctum-pergunta");
+/** Os arcos desta raiz de estado, pelos nomes das pastas. */
+function arcosDaRaiz(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 [];
+    }
+}
+/** Todas as perguntas de todos os arcos, com a situação de cada uma no instante. Arco que não se lê fica de fora. */
+function perguntasDosArcos(raiz, quando) {
+    const todas = [];
+    for (const arco of arcosDaRaiz(raiz)) {
+        try {
+            todas.push(...(0, noctum_arco_1.perguntasDoArco)(raiz, arco, quando));
+        }
+        catch { /* arco ilegível não responde por pergunta */ }
+    }
+    return todas;
+}
+/** As perguntas que ainda esperam o dono agora. */
+function perguntasPendentes(raiz, quando) {
+    return perguntasDosArcos(raiz, quando).filter(p => p.situacao === 'pendente');
+}
+/** As perguntas com este código, em qualquer situação: a resposta atrasada ouve o porquê, e o código em dois lugares é ambíguo. */
+function perguntasPorCodigo(raiz, codigo, quando) {
+    const alvo = codigo.trim().toUpperCase();
+    return perguntasDosArcos(raiz, quando).filter(p => p.codigo === alvo);
+}
+const ARQUIVO_SEM_EFEITO = 'respostas-sem-efeito.jsonl';
+/**
+ * GO-FIX 1 (achado 3 da ork-rm057respost): as perguntas que já ouviram "b" ou "c" do dono, por qualquer canal. Não é prova
+ * nem ato do arco (D13 segue: b e c não gravam nada nele); é a regra de rota que tira a palavra solta do terminal dessas
+ * perguntas, para o "ok" dito depois de "adiar" nunca autorizar. `null` quando o registro existe e não se lê: quem lê
+ * trata como se todas tivessem ouvido (falha fechada).
+ */
+function perguntasComRespostaSemEfeito(raiz) {
+    const arquivo = path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'noctum', ARQUIVO_SEM_EFEITO);
+    let bruto;
+    try {
+        bruto = fs.readFileSync(arquivo, 'utf8');
+    }
+    catch (e) {
+        return e.code === 'ENOENT' ? new Set() : null;
+    }
+    const codigos = new Set();
+    for (const linha of bruto.split('\n').filter(Boolean)) {
+        try {
+            const v = JSON.parse(linha);
+            if (typeof v.codigo === 'string')
+                codigos.add(v.codigo);
+        }
+        catch {
+            return null;
+        }
+    }
+    return codigos;
+}
+function registrarSemEfeito(raiz, codigo, letra, canal, quando) {
+    const principal = (0, estado_thread_1.raizDoEstado)(raiz);
+    (0, estado_thread_1.exigirEstadoSemLink)(principal, ['.orkastery', 'noctum']);
+    const dir = path.join(principal, '.orkastery', 'noctum');
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    fs.appendFileSync(path.join(dir, ARQUIVO_SEM_EFEITO), JSON.stringify({ contrato: 'ork.noctum-sem-efeito/v1', codigo, letra, canal, em: quando }) + '\n', { mode: 0o600 });
+}
+/** O rótulo da pergunta para a lista de "qual?": o código e a letra, com o arco e o ato. */
+function rotuloDaPergunta(p) {
+    return `${p.codigo} a (arco ${p.arco}: ${p.ato === 'autorizar' ? 'autorizar' : 'revogar'})`;
+}
+const marca = (canal, tipo) => canal === 'telegram' ? (tipo === 'ok' ? '✅ ' : '⚠️ ') : (tipo === 'ok' ? '' : '! ');
+/** A frase de uma recusa tipada do arco, para o dono, sem caminho de máquina e sem mensagem interna crua. */
+function textoDaRecusa(raiz, p, e, o) {
+    const aviso = marca(o.canal, 'aviso');
+    const nada = p.ato === 'autorizar' ? 'nada foi autorizado' : 'nada foi revogado';
+    switch (e.motivo) {
+        case 'noctum.efeito.hash-antigo': {
+            const agora = (0, noctum_arco_1.perguntasDoArco)(raiz, p.arco, o.quando).find(q => q.situacao === 'pendente' && q.ato === p.ato);
+            return `${aviso}A proposta do arco ${p.arco} mudou desde a pergunta ${p.codigo}; ${nada}.` +
+                (agora ? ` A pergunta de agora é ${agora.codigo}: responda ${agora.codigo} a para a proposta ${agora.versao}.` : '');
+        }
+        case 'noctum.envelope.invalido':
+        case 'noctum.pergunta.vencida': {
+            const venceuAs = (0, horario_1.formatarHora)(p.prazo, { fuso: p.conteudo?.janela.fuso, agora: o.quando });
+            return `${aviso}A pergunta ${p.codigo} venceu às ${venceuAs}; ${nada}. ` +
+                (p.ato === 'autorizar' ? 'Para seguir, a proposta precisa sair de novo, com outra pergunta.' : 'Para revogar, peça a revogação de novo.');
+        }
+        case 'noctum.pergunta.substituida':
+            return `${aviso}A pergunta ${p.codigo} foi substituída por outra; ${nada}.`;
+        case 'noctum.efeito.expirado':
+            return `${aviso}O arco ${p.arco} já terminou; ${nada}.`;
+        case 'noctum.efeito.encerrado':
+            return `${aviso}O arco ${p.arco} está encerrado, e encerrado é terminal; ${nada}.`;
+        case 'noctum.efeito.revogado':
+            return `${aviso}O arco ${p.arco} foi revogado, e a revogação é terminal; ${nada}.`;
+        case 'noctum.origem.sem-prova':
+            return `${aviso}Não consegui provar que a resposta a ${p.codigo} veio de você, a tempo; ${nada}. Mande de novo.`;
+        default:
+            return `${aviso}Não consegui registrar a resposta a ${p.codigo} (${e.motivo}); ${nada}.`;
+    }
+}
+/**
+ * Responde à pergunta do arco com o trecho que o dono digitou. A prova é montada só depois de a letra ser lida, e o ato
+ * (autorizar ou revogar) confere tudo de novo sob o lock do arco: a pergunta de agora, o prazo, a janela e a prova.
+ */
+function responderPerguntaDoArco(raiz, p, trecho, o) {
+    const r = (0, noctum_pergunta_1.escolhaDaPergunta)(p, trecho);
+    const aviso = marca(o.canal, 'aviso');
+    if (r.tipo === 'detalhe')
+        return { tipo: 'detalhe', mensagem: (0, noctum_pergunta_1.detalhesDaPergunta)(p) };
+    if (r.tipo === 'ambigua' || r.tipo === 'nenhuma') {
+        const dito = trecho.tipo === 'intencao' ? trecho.palavra : trecho.tipo === 'letra' ? trecho.letra : String(trecho.numero);
+        return { tipo: 'recusada', motivo: r.tipo === 'ambigua' ? 'ambigua' : 'nao-entendida',
+            mensagem: `${aviso}${r.tipo === 'ambigua' ? `"${dito}" serve para mais de uma alternativa de ${p.codigo}` : `Não entendi "${dito}" para ${p.codigo}`}; ` +
+                `nada foi registrado. Responda com uma destas: ${(0, noctum_pergunta_1.opcoesDaPergunta)(p)}.` };
+    }
+    const alternativa = (0, noctum_pergunta_1.alternativasDaPergunta)(p)[r.indice];
+    if (alternativa.letra !== 'a') {
+        const hora = (0, horario_1.formatarHora)(p.prazo, { fuso: p.conteudo?.janela.fuso, agora: o.quando });
+        const seguir = alternativa.letra === 'b'
+            ? (p.ato === 'autorizar' ? `nada muda, e a proposta vence às ${hora} se você não autorizar antes.` : 'nada muda; o arco segue até o fim da janela.')
+            : (p.ato === 'autorizar' ? 'nada foi autorizado. Diga o que mudar, e uma proposta nova sai com outra pergunta.'
+                : 'nada foi revogado. Diga o que mudar, e uma emenda é proposta.');
+        // Sem o registro, o "ok" seguinte poderia valer no terminal: a falha de gravação sobe, e o dono manda de novo.
+        registrarSemEfeito(raiz, p.codigo, alternativa.letra, o.canal, o.quando);
+        return { tipo: 'sem-efeito', letra: alternativa.letra, mensagem: `${p.codigo} → ${alternativa.letra}) ${alternativa.texto}: ${seguir}` };
+    }
+    const info = { repetida: false, mesmaProva: false };
+    const prova = o.provar({ codigo: p.codigo, letra: 'a', ...(o.numero ? { numero: o.numero } : {}) });
+    try {
+        const estado = p.ato === 'autorizar'
+            ? (0, noctum_arco_1.autorizarPelaResposta)(raiz, p.arco, p.codigo, prova, o.quando, info)
+            : (0, noctum_arco_1.revogarPelaResposta)(raiz, p.arco, p.codigo, prova, o.quando, info);
+        const ok = marca(o.canal, 'ok');
+        const fim = estado.conteudo ? (0, horario_1.formatarHora)(estado.conteudo.janela.fim, { fuso: estado.conteudo.janela.fuso, agora: o.quando }) : '';
+        const mensagem = p.ato === 'autorizar'
+            ? (info.repetida ? `${p.codigo}: o arco ${p.arco} já estava autorizado; nada muda.`
+                : `${ok}${p.codigo} → a) ${alternativa.texto}: o arco ${p.arco} está autorizado (${estado.situacao}), até ${fim}.`)
+            : (info.repetida ? `${p.codigo}: o arco ${p.arco} já estava revogado; nada muda.`
+                : `${ok}${p.codigo} → a) ${alternativa.texto}: o arco ${p.arco} está revogado; nenhum efeito novo passa.`);
+        return { tipo: 'registrada', ato: p.ato, letra: 'a', repetida: info.repetida, mesmaProva: info.mesmaProva, mensagem };
+    }
+    catch (e) {
+        if (e instanceof noctum_envelope_1.RecusaDoArco)
+            return { tipo: 'recusada', motivo: e.motivo, mensagem: textoDaRecusa(raiz, p, e, o) };
+        throw e;
+    }
+}

package/dist/noctum-retomada-rede.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CARENCIA_DA_RETOMADA_MS = void 0;
+exports.retomadaNaRede = retomadaNaRede;
+const maquina_1 = require("./maquina");
+const noctum_arco_1 = require("./noctum-arco");
+const noctum_coordenacao_1 = require("./noctum-coordenacao");
+const noctum_envelope_1 = require("./noctum-envelope");
+/** O cancelamento exige duas carências de batida: uma partição de 15 min não transfere trabalho. */
+exports.CARENCIA_DA_RETOMADA_MS = 2 * noctum_coordenacao_1.BATIDA_VENCIDA_MS;
+const idadeDoSinal = (estado, maquina, quando) => {
+    const sinal = estado.sinais.get(maquina);
+    return sinal ? Date.parse(quando) - Date.parse(sinal) : Number.POSITIVE_INFINITY;
+};
+const canceladasDestaMaquina = (estado, maquina) => [...estado.ordens.values()].filter(o => o.maquina === maquina && o.estado === 'isolada' && !!o.cancelada)
+    .map(o => ({ ordem: o.ordem, trabalho: o.trabalho }));
+/**
+ * Executa no máximo uma mudança de coordenação por chamada. Releituras e corridas continuam sob as trocas atômicas da N3;
+ * uma recusa tipada vira lacuna do tique, nunca estado vazio.
+ */
+function retomadaNaRede(carregado, arco, opcoes = {}) {
+    const quando = opcoes.quando ?? new Date().toISOString();
+    const local = (0, noctum_arco_1.lerArco)(carregado.raiz, arco, quando);
+    if (!local?.conteudo || !(0, noctum_envelope_1.envelopeMultimaquina)(local.conteudo)) {
+        return { aplicavel: false, acoes: [], canceladasLocais: [], lacuna: null };
+    }
+    const eu = (0, maquina_1.nomeDaMaquina)(opcoes.maquina);
+    const acoes = [];
+    try {
+        let estado = (0, noctum_coordenacao_1.lerCoordenacao)(carregado, arco, { ...opcoes, quando });
+        const cessao = estado.autoridade ? estado.cessoes.get(estado.autoridade.geracao) : null;
+        if (estado.autoridade && estado.autoridade.maquina !== eu && cessao?.para === eu && local.situacao === 'vigente') {
+            (0, noctum_coordenacao_1.assumirAutoridade)(carregado, arco, { ...opcoes, quando });
+            acoes.push('autoridade-assumida-por-cessao');
+            estado = (0, noctum_coordenacao_1.lerCoordenacao)(carregado, arco, { ...opcoes, quando });
+        }
+        else if (estado.autoridade && estado.autoridade.maquina !== eu && local.situacao === 'vigente' &&
+            idadeDoSinal(estado, estado.autoridade.maquina, quando) > noctum_coordenacao_1.BATIDA_VENCIDA_MS) {
+            (0, noctum_coordenacao_1.assumirAutoridade)(carregado, arco, { ...opcoes, quando,
+                forcar: { motivo: 'noctum.retomada.autoridade-sem-sinal' } });
+            acoes.push('autoridade-tomada-sem-sinal');
+            estado = (0, noctum_coordenacao_1.lerCoordenacao)(carregado, arco, { ...opcoes, quando });
+        }
+        if (estado.autoridade?.maquina === eu && local.situacao === 'encerrado') {
+            const para = (estado.vigente.conteudo.maquinas ?? []).filter(m => m.nome !== eu)
+                .map(m => ({ nome: m.nome, em: estado.sinais.get(m.nome) ?? '' }))
+                .sort((a, b) => Date.parse(b.em || '1970-01-01') - Date.parse(a.em || '1970-01-01'))[0];
+            if (para && !estado.cessoes.has(estado.autoridade.geracao)) {
+                (0, noctum_coordenacao_1.cederAutoridade)(carregado, arco, para.nome, 'noctum.retomada.cessao-no-encerramento', { ...opcoes, quando });
+                acoes.push(`autoridade-cedida:${para.nome}`);
+                estado = (0, noctum_coordenacao_1.lerCoordenacao)(carregado, arco, { ...opcoes, quando });
+            }
+        }
+        else if (estado.autoridade?.maquina === eu && local.situacao === 'vigente') {
+            const presa = new Map((estado.vigente.conteudo.trabalhos ?? []).map(t => [t.id, t.maquina ?? null]));
+            const ordem = [...estado.ordens.values()].find(o => o.maquina !== eu && (0, noctum_coordenacao_1.ordemViva)(o) && !o.cancelada &&
+                presa.get(o.trabalho) !== o.maquina && idadeDoSinal(estado, o.maquina, quando) > exports.CARENCIA_DA_RETOMADA_MS);
+            if (ordem) {
+                (0, noctum_coordenacao_1.cancelarOrdem)(carregado, arco, ordem.ordem, 'noctum.retomada.maquina-sem-sinal', { ...opcoes, quando });
+                acoes.push(`ordem-cancelada:${ordem.ordem}`);
+                estado = (0, noctum_coordenacao_1.lerCoordenacao)(carregado, arco, { ...opcoes, quando });
+            }
+        }
+        return { aplicavel: true, acoes, canceladasLocais: canceladasDestaMaquina(estado, eu), lacuna: null };
+    }
+    catch (e) {
+        if (!(e instanceof noctum_envelope_1.RecusaDoArco))
+            throw e;
+        return { aplicavel: true, acoes, canceladasLocais: [], lacuna: { motivo: e.motivo, detalhe: e.message } };
+    }
+}

package/dist/noctum-sessoes-em-voo.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessoesEmVooDoArco = sessoesEmVooDoArco;
+/**
+ * RM-058, integração (N4 do CHECK 2 da ork-rm058integra): as sessões do arco que podem estar em voo, numa conta só para o
+ * fechamento (que pede a parada delas) e para a guarda das threads do arco (que não deixa a sessão do arco terminal entregar
+ * por fora). O módulo só lê o log do arco, os ledgers e as threads: a guarda o importa sem o ciclo
+ * `ship` -> `noctum-guarda` -> `noctum-fechamento` -> `master` -> `ship`, que deixava constantes do `ship` sem valor no
+ * carregamento.
+ */
+const ledger_1 = require("./ledger");
+const noctum_envelope_1 = require("./noctum-envelope");
+const thread_1 = require("./thread");
+const FIM_DA_SESSAO = ['phase_result', 'sessao_morta', 'session_superseded'];
+/**
+ * A thread de uma reserva: a do log do arco ou, no trabalho de pedido que o arco abriu depois de reservar, a única que
+ * casa com o item e o sha256 do pedido (a mesma regra da fila). Ambígua ou ilegível: nenhuma.
+ */
+function threadDaReserva(raiz, estado, d) {
+    const gravada = d.threadDespachada ?? d.thread;
+    if (gravada)
+        return gravada;
+    const t = estado.conteudo && (0, noctum_envelope_1.envelopeComTrabalhos)(estado.conteudo) ? estado.conteudo.trabalhos.find(x => x.id === d.trabalho) : undefined;
+    if (!t?.pedido)
+        return null;
+    const sha = (0, noctum_envelope_1.shaDoPedido)(t.pedido);
+    const casam = [];
+    for (const id of (0, thread_1.listarIds)(raiz)) {
+        try {
+            const th = (0, thread_1.lerThread)(raiz, id);
+            if (th.roadmap === t.item && th.pedido?.sha256 === sha)
+                casam.push(id);
+        }
+        catch {
+            return null;
+        }
+    }
+    return casam.length === 1 ? casam[0] : null;
+}
+/**
+ * As sessões do arco que podem estar em voo: a sessão concluída sem resultado no ledger e a reserva pendente. A reserva
+ * pendente leva o id que a falha do runtime disse depois dela (o `claude --bg` que diz o id e sai com erro deixa a sessão
+ * aberta), e fica sem id quando nada foi dito.
+ */
+function sessoesEmVooDoArco(raiz, estado) {
+    const vistas = new Set();
+    const emVoo = [];
+    const ledgers = new Map();
+    const eventosDe = (thread) => {
+        if (!thread)
+            return null;
+        if (!ledgers.has(thread)) {
+            let e;
+            try {
+                e = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, thread));
+            }
+            catch {
+                e = null;
+            }
+            ledgers.set(thread, e);
+        }
+        return ledgers.get(thread);
+    };
+    // Ledger que não se lê: a sessão pode estar em voo; o fechamento pede a parada em vez de presumir o fim.
+    const acabou = (eventos, sid) => !!eventos?.some(e => FIM_DA_SESSAO.includes(e.tipo) && e.sessionId === sid);
+    for (const d of estado.despachos) {
+        if (d.desfecho === 'recusado')
+            continue;
+        if (d.desfecho === 'pendente') {
+            const thread = threadDaReserva(raiz, estado, d);
+            const eventos = eventosDe(thread);
+            const dita = eventos?.filter(e => (e.tipo === ledger_1.TIPOS_DE_EVENTO.despachoFalhou || e.tipo === ledger_1.TIPOS_DE_EVENTO.faseDespachada) &&
+                typeof e.sessionId === 'string' && Date.parse(e.ts) >= Date.parse(d.reservadoEm)).at(-1);
+            const sessionId = typeof dita?.sessionId === 'string' ? dita.sessionId : null;
+            if (sessionId && (vistas.has(sessionId) || acabou(eventos, sessionId))) {
+                vistas.add(sessionId);
+                continue;
+            }
+            if (sessionId)
+                vistas.add(sessionId);
+            emVoo.push({ seq: d.seq, sessionId, trabalho: d.trabalho, thread, runtime: d.runtime, conta: d.conta, daReservaPendente: true });
+            continue;
+        }
+        if (!d.sessionId || vistas.has(d.sessionId))
+            continue;
+        vistas.add(d.sessionId);
+        const thread = d.threadDespachada ?? d.thread;
+        if (!acabou(eventosDe(thread), d.sessionId)) {
+            emVoo.push({ seq: d.seq, sessionId: d.sessionId, trabalho: d.trabalho, thread, runtime: d.runtime, conta: d.conta });
+        }
+    }
+    return emVoo;
+}