@orkastery/cli 0.5.6 → 0.6.1

package/dist/noctum-guarda.js

@@ -0,0 +1,333 @@
+"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.pedidoDoArco = exports.linhaDoArco = exports.MOTIVO_DA_REDE_ILEGIVEL = exports.MOTIVO_DO_ARCO_ILEGIVEL = exports.MOTIVO_DA_GUARDA = void 0;
+exports.lerArcosDaRaiz = lerArcosDaRaiz;
+exports.arcoDosEventos = arcoDosEventos;
+exports.arcoDoUltimoDespacho = arcoDoUltimoDespacho;
+exports.vinculosDaThread = vinculosDaThread;
+exports.guardaOsCaminhosManuais = guardaOsCaminhosManuais;
+exports.guardaDaThread = guardaDaThread;
+exports.arcoDoPasso = arcoDoPasso;
+/**
+ * RM-058, integração das fatias N1 a N6 (T1.1 da ork-rm058integra, D3 e D5): quem é thread de um arco #Noctum.
+ *
+ * O arco entrega as threads dele pelo passo da entrega da N5: a revisão independente, o verify no SHA, o envelope conferido
+ * antes de cada efeito e o MASTER por omissão. Os caminhos de fora do arco não sabiam disso: a sessão do bloco chegava ao
+ * SHIP e mesclava pelo `ork ship`, sem a revisão, e nada impedia o `ork ship registrar-pr` de gravar a entrega dela.
+ *
+ * A regra (D3) mora aqui, e os chamadores só leem as funções. É thread de um arco a que está:
+ *
+ * - na lista do envelope vigente ou na da proposta que espera o dono no prazo: a thread fixada no trabalho, ou a que casa
+ *   com o item e o sha256 do pedido do trabalho (a regra da fila e da supervisão);
+ * - no log de despachos do arco (a thread reservada e a que o despacho abriu);
+ * - ou cujo último `phase_dispatch` tem a correlação `noctum:<arco>`.
+ *
+ * Nos caminhos manuais (`ork ship`, o `ork_ship` do MCP, `ork ship publicar`, `ork ship registrar-pr` e
+ * `ork conducao atualizar`), guardam o arco agendado, o vigente e o proposto com a proposta no prazo. O proposto sem
+ * proposta no prazo (o nunca autorizado fica `proposto` para sempre), o expirado, o revogado e o encerrado não guardam. O
+ * arco que não se lê recusa só a thread cujo último despacho tem a correlação dele (`noctum.guarda.arco-ilegivel`); as
+ * outras seguem. Sem nenhum arco nesta raiz, nada é lido além da pasta dos arcos: quem não usa o #Noctum não paga nada.
+ *
+ * Nos caminhos automáticos (T1.2, D4), a batida, a varredura, a Sentinela e a máquina ociosa leem o campo `arco` do passo
+ * do condutor (`arcoDoPasso`): a guarda segura toda ação; a retenção, a do arco terminal que despachou a thread por último,
+ * segura o despacho, a retomada e o merge até um despacho fora do arco ou um arco novo, autorizado depois, que a liste.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const estado_thread_1 = require("./estado-thread");
+const ledger_1 = require("./ledger");
+const locale_1 = require("./locale");
+const manifest_1 = require("./manifest");
+const noctum_arco_1 = require("./noctum-arco");
+const noctum_sessoes_em_voo_1 = require("./noctum-sessoes-em-voo");
+const noctum_envelope_1 = require("./noctum-envelope");
+const thread_1 = require("./thread");
+exports.MOTIVO_DA_GUARDA = 'noctum.guarda.thread-do-arco';
+exports.MOTIVO_DO_ARCO_ILEGIVEL = 'noctum.guarda.arco-ilegivel';
+exports.MOTIVO_DA_REDE_ILEGIVEL = 'noctum.guarda.rede-ilegivel';
+/** A recusa com os três textos do catálogo, cada um remontável no locale de quem imprime. */
+function recusa(motivo, thread, arco, situacao, origem, detalhe, correcao) {
+    return { motivo, thread, arco, situacao, origem, detalhe: (0, locale_1.textoDoCatalogo)(detalhe), correcao: (0, locale_1.textoDoCatalogo)(correcao),
+        texto: (0, locale_1.textoDoCatalogo)((m) => `${detalhe(m)}; ${correcao(m)}`) };
+}
+/** Os nomes das pastas de arco desta raiz de estado (o `listarArcos` do modo, sem puxar o passo, a entrega e o relatório). */
+function nomesDosArcos(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 [];
+    }
+}
+/** Lê cada arco desta raiz uma vez. O arco que não se lê fica com o motivo, e os outros seguem. */
+function lerArcosDaRaiz(raiz, quando = new Date().toISOString()) {
+    const arcos = { quando, lidos: new Map(), ilegiveis: new Map(), redes: new Map(), redesIlegiveis: new Map() };
+    for (const arco of nomesDosArcos(raiz)) {
+        try {
+            const lido = (0, noctum_arco_1.lerArcoComProposta)(raiz, arco, quando);
+            if (lido)
+                arcos.lidos.set(arco, lido);
+        }
+        catch (e) {
+            arcos.ilegiveis.set(arco, e instanceof noctum_envelope_1.RecusaDoArco ? e.motivo : (e instanceof Error ? e.message : String(e)).split('\n')[0].slice(0, 160));
+        }
+    }
+    return arcos;
+}
+/** O arco da correlação `noctum:<arco>` do último `phase_dispatch` entre os eventos dados; `null` sem ele. */
+function arcoDosEventos(eventos) {
+    for (let i = eventos.length - 1; i >= 0; i--) {
+        if (eventos[i].tipo !== ledger_1.TIPOS_DE_EVENTO.faseDespachada)
+            continue;
+        const c = eventos[i].correlacao;
+        const arco = typeof c === 'string' && c.startsWith('noctum:') ? c.slice('noctum:'.length) : '';
+        return noctum_envelope_1.ID_DO_ARCO.test(arco) ? arco : null;
+    }
+    return null;
+}
+/** O arco da correlação `noctum:<arco>` do último `phase_dispatch` da thread; `null` sem despacho ou com outra correlação. */
+function arcoDoUltimoDespacho(raiz, thread) {
+    try {
+        return arcoDosEventos((0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, thread)));
+    }
+    catch {
+        return null;
+    }
+}
+/** A thread está na lista? A fixada no trabalho, ou a que casa com o item e o sha256 do pedido dele. */
+function naLista(conteudo, thread, dados) {
+    return !!trabalhoNaLista(conteudo, thread, dados);
+}
+/** O trabalho da thread na lista, pela fixação ou pelo pedido, quando existe. */
+function trabalhoNaLista(conteudo, thread, dados) {
+    return conteudo?.trabalhos?.find(w => w.thread !== undefined ? w.thread === thread
+        : w.pedido !== undefined && dados().roadmap === w.item && dados().pedido === (0, noctum_envelope_1.shaDoPedido)(w.pedido)) ?? null;
+}
+/** O id do trabalho que liga esta thread ao arco, na lista vigente ou no despacho mais recente. */
+function trabalhoDaThread(estado, thread, dados) {
+    const listado = trabalhoNaLista(estado.conteudo, thread, dados);
+    if (listado)
+        return listado.id;
+    for (let i = estado.despachos.length - 1; i >= 0; i--) {
+        const d = estado.despachos[i];
+        if (d.thread === thread || d.threadDespachada === thread)
+            return d.trabalho;
+    }
+    return null;
+}
+/** A rede do arco, uma vez por `ArcosDaRaiz`; falha inesperada também fica cacheada e falha fechada. */
+function redeDoArco(arco, arcos, ler) {
+    const pronta = arcos.redes.get(arco);
+    if (pronta)
+        return pronta;
+    const falha = arcos.redesIlegiveis.get(arco);
+    if (falha !== undefined)
+        return falha;
+    try {
+        const rede = ler(arco);
+        arcos.redes.set(arco, rede);
+        return rede;
+    }
+    catch (e) {
+        const detalhe = (e instanceof Error ? e.message : String(e)).split('\n')[0].slice(0, 200);
+        arcos.redesIlegiveis.set(arco, detalhe);
+        return detalhe;
+    }
+}
+/**
+ * A fila carrega a Sentinela, que carrega esta guarda. Resolver a projeção só quando uma thread de arco v3 encerrado
+ * realmente precisar dela evita o ciclo de inicialização fila -> guarda -> rede -> coordenação -> fila.
+ */
+function lerRedePadrao(raiz, arco, quando) {
+    const { lerRede } = require('./noctum-rede');
+    return lerRede((0, manifest_1.exigirManifesto)(raiz), arco, { quando });
+}
+/**
+ * Os vínculos da thread com os arcos lidos, um por arco, na ordem das origens: a lista do envelope vigente, a da proposta
+ * no prazo, o log de despachos e a correlação do último despacho (`ultimo`, quando o chamador já a leu).
+ */
+function vinculosDaThread(raiz, arcos, thread, ultimo) {
+    if (!arcos.lidos.size)
+        return [];
+    const doUltimo = ultimo === undefined ? arcoDoUltimoDespacho(raiz, thread) : ultimo;
+    let lidos = null;
+    const dados = () => {
+        if (!lidos) {
+            try {
+                const t = (0, thread_1.lerThread)(raiz, thread);
+                lidos = { roadmap: t.roadmap ?? null, pedido: t.pedido?.sha256 ?? null };
+            }
+            catch {
+                lidos = { roadmap: null, pedido: null };
+            }
+        }
+        return lidos;
+    };
+    const vinculos = [];
+    for (const [arco, { estado, proposta }] of arcos.lidos) {
+        const origem = naLista(estado.conteudo, thread, dados) ? 'envelope'
+            : naLista(proposta, thread, dados) ? 'proposta'
+                : estado.despachos.some(d => d.thread === thread || d.threadDespachada === thread) ? 'despacho'
+                    : doUltimo === arco ? 'correlacao' : null;
+        if (origem)
+            vinculos.push({ arco, situacao: estado.situacao, origem });
+    }
+    return vinculos;
+}
+/** D3: guardam os caminhos manuais o arco agendado, o vigente e o proposto pela proposta no prazo (a única que dá vínculo). */
+function guardaOsCaminhosManuais(v) {
+    return v.situacao === 'agendado' || v.situacao === 'vigente' || (v.situacao === 'proposto' && v.origem === 'proposta');
+}
+/**
+ * A guarda dos caminhos manuais: a recusa tipada quando a thread é trabalho de um arco que a guarda agora, ou `null`. O
+ * `doArco` é o arco que entrega pelo próprio passo (o da entrega da N5 publica com ele): a guarda dele não o recusa, e a de
+ * outro arco recusa. `arcos` reaproveita a leitura de quem confere várias threads de uma vez (o `registrar-pr --todas`).
+ */
+function guardaDaThread(raiz, thread, quando = new Date().toISOString(), opcoes = {}) {
+    const arcos = opcoes.arcos ?? lerArcosDaRaiz(raiz, quando);
+    if (!arcos.lidos.size && !arcos.ilegiveis.size)
+        return null;
+    const ultimo = arcoDoUltimoDespacho(raiz, thread);
+    const ilegivel = ultimo !== null && ultimo !== opcoes.doArco ? arcos.ilegiveis.get(ultimo) : undefined;
+    if (ultimo !== null && ilegivel !== undefined) {
+        return recusa(exports.MOTIVO_DO_ARCO_ILEGIVEL, thread, ultimo, null, 'correlacao', (m) => m.ship.guarda.arcoIlegivel(thread, ultimo, ilegivel), (m) => m.ship.guarda.arcoIlegivelCorrecao(ultimo));
+    }
+    const vinculos = vinculosDaThread(raiz, arcos, thread, ultimo);
+    const v = vinculos.find(x => x.arco !== opcoes.doArco && guardaOsCaminhosManuais(x));
+    if (!v) {
+        let dadosLidos = null;
+        const dados = () => {
+            if (dadosLidos)
+                return dadosLidos;
+            try {
+                const t = (0, thread_1.lerThread)(raiz, thread);
+                dadosLidos = { roadmap: t.roadmap ?? null, pedido: t.pedido?.sha256 ?? null };
+            }
+            catch {
+                dadosLidos = { roadmap: null, pedido: null };
+            }
+            return dadosLidos;
+        };
+        // Num v3 encerrado localmente, o trabalho pode seguir em outra máquina. A rede só é lida depois de provar o vínculo,
+        // e a leitura fica no `ArcosDaRaiz` para o registrar-pr --todas não consultar o mesmo arco de novo.
+        for (const t of vinculos.filter(x => x.arco !== opcoes.doArco && x.situacao === 'encerrado')) {
+            const lido = arcos.lidos.get(t.arco);
+            if (!lido?.estado.conteudo || !(0, noctum_envelope_1.envelopeMultimaquina)(lido.estado.conteudo))
+                continue;
+            const trabalho = trabalhoDaThread(lido.estado, thread, dados);
+            if (!trabalho)
+                continue;
+            const rede = redeDoArco(t.arco, arcos, opcoes.lerRede ?? ((arco) => lerRedePadrao(raiz, arco, arcos.quando)));
+            if (typeof rede === 'string' || rede.lacuna) {
+                const falha = typeof rede === 'string' ? rede : `${rede.lacuna.motivo}: ${rede.lacuna.detalhe}`;
+                return recusa(exports.MOTIVO_DA_REDE_ILEGIVEL, thread, t.arco, t.situacao, 'rede', (m) => m.ship.guarda.redeIlegivel(thread, t.arco, falha), (m) => m.ship.guarda.redeIlegivelCorrecao(t.arco));
+            }
+            const naRede = rede.trabalhos.find(x => x.id === trabalho);
+            if (!rede.revogada && naRede && naRede.estado !== 'entregue' && naRede.estado !== 'encerrado') {
+                return recusa(exports.MOTIVO_DA_GUARDA, thread, t.arco, t.situacao, 'rede', (m) => m.ship.guarda.redeDoArco(thread, t.arco, naRede.estado, trabalho), (m) => m.ship.guarda.redeDoArcoCorrecao(t.arco));
+            }
+        }
+        // A2 do CHECK: no arco que terminou (revogado, expirado ou encerrado), a sessão que ele despachou e que ainda conduz a
+        // thread não entrega fora dele; sem sessão dele em voo, a thread se entrega à mão, como antes.
+        for (const t of vinculos.filter(x => x.arco !== opcoes.doArco && TERMINAIS.includes(x.situacao))) {
+            const lido = arcos.lidos.get(t.arco);
+            const sessao = lido ? sessaoDoArcoEmVoo(raiz, thread, lido.estado) : null;
+            if (!sessao)
+                continue;
+            if ('seq' in sessao) {
+                return recusa(exports.MOTIVO_DA_GUARDA, thread, t.arco, t.situacao, t.origem, (m) => m.ship.guarda.reservaDoArco(thread, t.arco, m.ship.guarda.situacoes[t.situacao] ?? t.situacao, sessao.seq), (m) => m.ship.guarda.reservaDoArcoCorrecao(t.arco));
+            }
+            return recusa(exports.MOTIVO_DA_GUARDA, thread, t.arco, t.situacao, t.origem, (m) => m.ship.guarda.sessaoDoArco(thread, t.arco, m.ship.guarda.situacoes[t.situacao] ?? t.situacao, sessao.sessionId), (m) => m.ship.guarda.sessaoDoArcoCorrecao(t.arco));
+        }
+        return null;
+    }
+    return recusa(exports.MOTIVO_DA_GUARDA, thread, v.arco, v.situacao, v.origem, (m) => m.ship.guarda.doArco(thread, v.arco, m.ship.guarda.situacoes[v.situacao] ?? v.situacao, m.ship.guarda.origens[v.origem] ?? v.origem), (m) => m.ship.guarda.doArcoCorrecao(v.arco));
+}
+/** As situações do arco que já terminou: nada novo sai dele, e a retenção vale (D4). */
+const TERMINAIS = ['expirado', 'revogado', 'encerrado'];
+/**
+ * A2 do CHECK: a sessão que o arco despachou nesta thread e que ainda não acabou, ou `null`. É a conta do fechamento
+ * (`sessoesEmVooDoArco`): a sessão concluída sem resultado, morte nem superação no ledger, e a da reserva pendente, que o
+ * runtime abriu antes de o condutor morrer (N4 do CHECK 2), com o id que ele disse ou, sem id, a reserva (M3 do CHECK 3).
+ * O ledger que não se lê não prova o fim: a guarda falha fechada. Só os despachos desta thread entram, e a reserva pendente
+ * ainda sem thread gravada (M2 do CHECK 3): a guarda não lê os ledgers do arco inteiro a cada consulta.
+ */
+function sessaoDoArcoEmVoo(raiz, thread, estado) {
+    const despachos = estado.despachos.filter(d => (d.threadDespachada ?? d.thread) === thread || (d.desfecho === 'pendente' && !(d.threadDespachada ?? d.thread)));
+    const s = (0, noctum_sessoes_em_voo_1.sessoesEmVooDoArco)(raiz, { ...estado, despachos }).find(x => x.thread === thread);
+    return !s ? null : s.sessionId ? { sessionId: s.sessionId } : { seq: s.seq };
+}
+/**
+ * O arco que segura ou retém a thread nos caminhos automáticos, ou `null`. `eventos` é o ledger da thread que o chamador
+ * já leu (o passo do condutor lê todos), e `arcos` é a leitura única desta raiz.
+ */
+function arcoDoPasso(raiz, arcos, thread, eventos) {
+    if (!arcos.lidos.size && !arcos.ilegiveis.size)
+        return null;
+    const ultimo = arcoDosEventos(eventos);
+    const ilegivel = ultimo === null ? undefined : arcos.ilegiveis.get(ultimo);
+    if (ultimo !== null && ilegivel !== undefined) {
+        return { arco: ultimo, situacao: null, efeito: 'guarda', motivo: exports.MOTIVO_DO_ARCO_ILEGIVEL,
+            detalhe: (0, locale_1.textoDoCatalogo)((m) => m.ship.guarda.arcoIlegivel(thread, ultimo, ilegivel)) };
+    }
+    const vinculos = vinculosDaThread(raiz, arcos, thread, ultimo);
+    const g = vinculos.find(guardaOsCaminhosManuais);
+    if (g) {
+        return { arco: g.arco, situacao: g.situacao, efeito: 'guarda', motivo: exports.MOTIVO_DA_GUARDA,
+            detalhe: (0, locale_1.textoDoCatalogo)((m) => m.ship.guarda.doArco(thread, g.arco, m.ship.guarda.situacoes[g.situacao] ?? g.situacao, m.ship.guarda.origens[g.origem] ?? g.origem)) };
+    }
+    const doUltimo = ultimo === null ? undefined : arcos.lidos.get(ultimo);
+    if (ultimo === null || !doUltimo || !TERMINAIS.includes(doUltimo.estado.situacao))
+        return null;
+    // Um arco novo, autorizado depois deste, que lista a thread (na lista dele ou no log de despachos) acaba a retenção.
+    const desde = Date.parse(doUltimo.estado.autorizadoPor?.recebidoEm ?? '');
+    const novo = vinculos.some(v => v.arco !== ultimo && (v.origem === 'envelope' || v.origem === 'despacho') &&
+        Date.parse(arcos.lidos.get(v.arco)?.estado.autorizadoPor?.recebidoEm ?? '') > desde);
+    if (novo)
+        return null;
+    const situacao = doUltimo.estado.situacao;
+    return { arco: ultimo, situacao, efeito: 'retencao', motivo: exports.MOTIVO_DA_GUARDA,
+        detalhe: (0, locale_1.textoDoCatalogo)((m) => m.ship.guarda.retencao(thread, ultimo, m.ship.guarda.situacoes[situacao] ?? situacao)) };
+}
+/**
+ * D5: a linha que o passo do arco anexa ao pedido de toda sessão que ele despacha. Fixa e determinística: o mesmo arco dá
+ * o mesmo texto em toda chamada, e o `rodarFase` segue idempotente para a mesma fase e o mesmo prompt.
+ */
+const linhaDoArco = (arco) => `Esta thread é trabalho do arco \`${arco}\` do #Noctum: o SHIP e o MASTER dela são do arco; não faça push, não abra PR e não mescle.`;
+exports.linhaDoArco = linhaDoArco;
+/** O pedido da sessão do arco: o do dono e, no fim, a linha do arco. */
+const pedidoDoArco = (pedido, arco) => `${pedido.trimEnd()}\n\n${(0, exports.linhaDoArco)(arco)}`;
+exports.pedidoDoArco = pedidoDoArco;