@orkastery/cli 0.5.3 → 0.6.0

package/dist/noctum-fila.js

@@ -0,0 +1,314 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOTIVO_DO_ERRO_NO_DESPACHO = exports.ERROS_SEGUIDOS_QUE_BLOQUEIAM = exports.BACKOFF_MAXIMO_MS = exports.CADENCIA_MS = exports.CONTRATO_FILA = void 0;
+exports.montarFila = montarFila;
+exports.fatosDaFila = fatosDaFila;
+/**
+ * RM-058, fatia N2 (D2 a D6 da ork-rm058n2): a fila do arco.
+ *
+ * O que entra: os trabalhos do envelope `v2` vigente, cada um uma thread (a que já existe, ou a que o arco abre com o
+ * pedido do dono), com o item reservado por esta máquina e trabalho possível. A ordem: só com as dependências entregues,
+ * depois a prioridade do dono, a prova mais adiantada (a fase a despachar mais adiante primeiro; abrir thread por último),
+ * a posição no envelope e o id. O passo de cada thread aberta é o da Sentinela (`passoDaThread`, pela prova mais adiantada
+ * que a sessão do bloco deixou): o bloco inteiro numa sessão só, cujo `phase_result` sai com a fase do despacho, não ganha
+ * um PLAN repetido (aprendizado 3 de 12/10).
+ *
+ * Quando a fila acaba: vazia (todo trabalho entregue, encerrado ou preso a uma dependência que fechou sem entrega)
+ * encerra cedo; só bloqueada, ou com fonte que não foi lida, espera com backoff até o fim da janela; com sessão em curso,
+ * espera a cadência de 5 min. Lacuna nunca vira fila vazia. O trabalho cujo despacho falhou no núcleo, antes de lançar,
+ * três vezes seguidas fica bloqueado (`erro-repetido`), e o que pode ter uma sessão aberta (reserva pendente no log do arco,
+ * ou thread nunca despachada cuja falha disse o id da sessão) vai para a retomada da N4: o passo não insiste no mesmo erro a
+ * noite toda nem abre outra sessão por cima de uma que pode estar aberta. A falha que não abriu nada (a conta sem cota, sem
+ * id) deixa o trabalho na fila, e o despacho seguinte sai por outra conta. Fechar o arco e o relatório são da N6.
+ *
+ * `fatosDaFila` relê o disco a cada chamada; `montarFila` é pura sobre os fatos e o instante. Nada aqui despacha nem grava.
+ *
+ * RM-058, fatia N4 (D8 e D21 da ork-rm058n4): a fila respeita, quando vem, o que a supervisão do arco decidiu. O trabalho
+ * isolado não sai sozinho neste arco; o trabalho bloqueado para a N4 sem reserva pendente (a falha com id antes do primeiro
+ * despacho, o passo de retomar, o fim de turno sem resultado e o que ficou sem passo depois da sessão morta) volta à fila
+ * na fase da retomada que o vigia autorizou. A reserva pendente nunca é sobreposta. Sem a supervisão, nada muda.
+ */
+const roadmap_reservas_1 = require("./roadmap-reservas");
+const branch_de_estado_1 = require("./branch-de-estado");
+const parado_no_condutor_1 = require("./parado-no-condutor");
+const conducao_sentinela_1 = require("./conducao-sentinela");
+const ledger_1 = require("./ledger");
+const maquina_1 = require("./maquina");
+const noctum_arco_1 = require("./noctum-arco");
+const noctum_envelope_1 = require("./noctum-envelope");
+const thread_1 = require("./thread");
+const types_1 = require("./types");
+exports.CONTRATO_FILA = 'ork.noctum-fila/v1';
+/** A cadência do vigia (D3 do dono): a espera da fila em curso e o menor passo do backoff. */
+exports.CADENCIA_MS = 5 * 60 * 1000;
+/** O maior passo do backoff da fila bloqueada. */
+exports.BACKOFF_MAXIMO_MS = 60 * 60 * 1000;
+/** Quantas falhas seguidas do núcleo no despacho de um trabalho o bloqueiam (A4 do CHECK da ork-rm058n2). */
+exports.ERROS_SEGUIDOS_QUE_BLOQUEIAM = 3;
+/** O motivo que o passo grava no log do arco quando o despacho de um candidato falha antes de lançar a sessão. */
+exports.MOTIVO_DO_ERRO_NO_DESPACHO = 'noctum.despacho.erro';
+/** Bloqueio que vem de fonte não lida, e não de um fato: vira lacuna, nunca trabalho a menos. */
+const DE_LACUNA = ['reserva-sem-leitura', 'thread-ilegivel', 'thread-ambigua'];
+const adiante = (t) => t.estado === 'abrir' ? -1 : t.fase ? types_1.FASES.indexOf(t.fase) : -1;
+/** D3: prioridade do dono, prova mais adiantada, posição no envelope e id. */
+function antes(a, b) {
+    return a.prioridade - b.prioridade || adiante(b) - adiante(a) || a.posicao - b.posicao || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+}
+const FASES_DA_ENTREGA = ['SHIP', 'MASTER'];
+/** As falhas seguidas do núcleo antes de lançar, nos despachos mais recentes do trabalho, contadas do último para trás. */
+function errosSeguidos(trabalho, despachos) {
+    let n = 0;
+    for (const d of despachos.filter(x => x.trabalho === trabalho).sort((a, b) => b.seq - a.seq)) {
+        if (d.desfecho !== 'recusado' || d.motivo !== exports.MOTIVO_DO_ERRO_NO_DESPACHO)
+            break;
+        n += 1;
+    }
+    return n;
+}
+/**
+ * O estado de um trabalho do envelope pelos fatos; `entregues` são os ids já entregues (para as dependências) e
+ * `semSaida` os que nunca mais entregam neste arco (fecharam sem entrega, ou dependem de quem fechou).
+ */
+function classificar(t, posicao, f, fatos, entregues, semSaida, estado) {
+    const decisoes = estado.decisoes;
+    const base = { id: t.id, item: t.item, prioridade: t.prioridade, posicao, thread: null, fase: null,
+        motivo: null, entregueEm: null };
+    const bloqueado = (motivo, detalhe) => ({ ...base, estado: 'bloqueado', motivo, detalhe });
+    // N3: a entrega em outra máquina do arco vale aqui, até sem thread nesta raiz.
+    const naRede = fatos.coordenacao?.entregues.get(t.id);
+    if (naRede)
+        return { ...base, thread: f?.threads[0]?.id ?? null, estado: 'entregue', entregueEm: naRede, detalhe: 'entregue em outra máquina do arco' };
+    if (fatos.coordenacao?.encerrados?.has(t.id)) {
+        return { ...base, thread: f?.threads[0]?.id ?? null, estado: 'encerrado-sem-entrega', detalhe: 'encerrado sem entrega em outra máquina do arco' };
+    }
+    if (!f)
+        return bloqueado('thread-ilegivel', 'o trabalho não foi lido');
+    if (f.ilegivel)
+        return bloqueado('thread-ilegivel', `a thread ${f.ilegivel} não pôde ser lida`);
+    if (f.threads.length > 1) {
+        return bloqueado('thread-ambigua', `${f.threads.map(x => x.id).join(', ')} casam com o item e o pedido; o arco não escolhe por ninguém`);
+    }
+    const th = f.threads[0] ?? null;
+    base.thread = th?.id ?? null;
+    if (t.thread !== undefined && !th)
+        return bloqueado('thread-ausente', `a thread ${t.thread} não existe neste projeto`);
+    if (th && th.roadmap !== t.item)
+        return bloqueado('item-divergente', `a thread ${th.id} é do item ${th.roadmap ?? 'nenhum'}, não do ${t.item}`);
+    if (th && f.entregueEm)
+        return { ...base, estado: 'entregue', entregueEm: f.entregueEm, detalhe: `ship_done da thread ${th.id}` };
+    if (th && th.status === 'fechada')
+        return { ...base, estado: 'encerrado-sem-entrega', detalhe: `a thread ${th.id} fechou sem ship_done` };
+    // RM-058 N4 (D16): o trabalho isolado pela supervisão não sai sozinho neste arco, nem com uma sessão de fora rodando nele.
+    const isolado = fatos.supervisao?.isolados.get(t.id);
+    if (isolado !== undefined)
+        return bloqueado('isolado', isolado);
+    if (th && f.passo?.conduzida)
+        return { ...base, estado: 'em-curso', detalhe: `a thread ${th.id} está sendo conduzida agora` };
+    const mortas = t.dependeDe.filter(d => semSaida.has(d));
+    if (mortas.length) {
+        return bloqueado('dependencia-encerrada', `depende de ${mortas.join(', ')}, que não entrega mais neste arco (fechou sem entrega)`);
+    }
+    const faltam = t.dependeDe.filter(d => !entregues.has(d));
+    if (faltam.length)
+        return bloqueado('dependencia', `depende de ${faltam.join(', ')}, ainda não entregue(s)`);
+    if (fatos.coordenacao && !fatos.coordenacao.trabalhos.has(t.id)) {
+        return bloqueado('sem-ordem', 'o trabalho não tem ordem aceita desta máquina no ramo de coordenação do arco');
+    }
+    if (fatos.reservas.leitura === 'sem-copia')
+        return bloqueado('reserva-sem-leitura', 'esta máquina não tem cópia da branch de reservas');
+    const reserva = fatos.reservas.porItem.get(t.item);
+    if (!reserva)
+        return bloqueado('reserva-ausente', `o item ${t.item} não está reservado; tomar reserva é da N3`);
+    if (reserva.maquina !== fatos.maquina)
+        return bloqueado('reserva-de-outra-maquina', `o item ${t.item} está com a máquina ${reserva.maquina}`);
+    if (th && decisoes.some(d => d.thread === th.id || d.dependentes.includes(th.id))) {
+        return bloqueado('decisao-no-lote', `a thread ${th.id} espera uma decisão do dono no lote do arco`);
+    }
+    // B1 da rodada 2 e A1 da rodada 3: a reserva pendente é um lançamento incerto; despachar de novo abriria outra sessão.
+    if (estado.despachos.some(d => d.trabalho === t.id && d.desfecho === 'pendente')) {
+        return bloqueado('retomada', 'um despacho deste trabalho ficou pendente, e o runtime pode ter aberto a sessão; a retomada é da N4');
+    }
+    const erros = errosSeguidos(t.id, estado.despachos);
+    if (erros >= exports.ERROS_SEGUIDOS_QUE_BLOQUEIAM) {
+        return bloqueado('erro-repetido', `os ${erros} últimos despachos falharam no núcleo antes de lançar; quem decide é a N4 ou o dono`);
+    }
+    // RM-058 N4 (D8): o bloqueio que a N2 deixou para a N4 vira a retomada que o vigia autorizou, na fase dela.
+    const retomada = fatos.supervisao?.retomadas.get(t.id);
+    const paraAN4 = (motivo, detalhe) => retomada
+        ? { ...base, estado: 'despachavel', fase: retomada.fase,
+            detalhe: `retomada autorizada pela supervisão (tentativa ${retomada.tentativa}, ${retomada.motivo}) no lugar de: ${detalhe}` }
+        : bloqueado(motivo, detalhe);
+    if (!th) {
+        // A4 do CHECK: abrir a thread num projeto que não deixa criar #Auto falharia toda noite; o arco nem tenta.
+        if (!fatos.modosPermitidos.includes('auto'))
+            return bloqueado('modo', 'o projeto não deixa criar thread #Auto (conduction.allowed_modes)');
+        return { ...base, estado: 'abrir', fase: 'GOAL', detalhe: `abre a thread do item ${t.item} com o pedido do dono` };
+    }
+    if (th.modo !== 'auto')
+        return bloqueado('modo', `a thread ${th.id} está em ${th.modo}; o arco só conduz #Auto`);
+    if (f.doDono)
+        return bloqueado('dono', `a thread ${th.id} espera o dono (${f.doDono})`);
+    if (!f.pedidoGuardado)
+        return bloqueado('pedido-ausente', `a thread ${th.id} não guardou o pedido na criação; o arco não inventa um`);
+    if (!f.despachada) {
+        // B1 da rodada 2: a falha disse o id da sessão, que pode estar aberta; despachar de novo abriria outra.
+        if (f.despachoFalho)
+            return paraAN4('retomada', `o despacho da thread ${th.id} falhou depois de o runtime dizer o id da sessão; a retomada é da N4`);
+        return { ...base, estado: 'despachavel', fase: th.faseAtual, detalhe: `a thread ${th.id} nunca foi despachada` };
+    }
+    const passo = f.passo;
+    if (passo?.acao === 'despachar' && passo.fase) {
+        if (FASES_DA_ENTREGA.includes(passo.fase))
+            return { ...base, estado: 'aguardando-entrega', detalhe: `${passo.porque}; a entrega é da N5` };
+        return { ...base, estado: 'despachavel', fase: passo.fase, detalhe: passo.porque };
+    }
+    if (passo?.acao === 'retomar')
+        return paraAN4('retomada', `${passo.porque}; a retomada é da N4`);
+    if (f.espera?.tipo === 'stop-sem-resultado')
+        return paraAN4('fim-de-turno-sem-resultado', 'o turno acabou sem o resultado da fase; quem decide é a N4');
+    if (f.espera?.tipo === 'concluida')
+        return { ...base, estado: 'aguardando-entrega', detalhe: `${passo?.porque ?? 'fase concluída'}; a entrega é da N5` };
+    return paraAN4('sem-passo', passo?.porque ?? 'nenhum passo do condutor para a thread');
+}
+/** O último progresso do arco: a autorização, um despacho ou uma entrega. O backoff conta a partir dele. */
+function ultimoProgresso(estado, trabalhos) {
+    const instantes = [estado.autorizadoPor?.recebidoEm, ...estado.despachos.flatMap(d => [d.reservadoEm, d.concluidoEm]),
+        ...trabalhos.map(t => t.entregueEm)].map(x => typeof x === 'string' ? Date.parse(x) : NaN).filter(Number.isFinite);
+    return instantes.length ? Math.max(...instantes) : Date.parse(estado.conteudo?.janela.inicio ?? '');
+}
+/**
+ * A fila e a decisão no instante dos fatos. Fora da janela, ou sem envelope `v2` autorizado, nada é candidato; o
+ * resto segue a D6 da ork-rm058n2.
+ */
+function montarFila(fatos) {
+    const { arco, quando, estado } = fatos;
+    const agora = Date.parse(quando);
+    const vazia = (situacao, decisao, lacunas = []) => ({ contrato: exports.CONTRATO_FILA, arco, envelopeSha256: estado?.envelopeSha256 ?? null, quando, situacao, trabalhos: [], candidatos: [],
+        lacunas, decisao });
+    const daqui = (ms, limite) => new Date(Math.min(agora + ms, limite ? Date.parse(limite) : Number.POSITIVE_INFINITY)).toISOString();
+    if (!estado || !estado.conteudo || estado.situacao === 'proposto') {
+        return vazia('fonte-indisponivel', { acao: 'aguardar', motivo: 'sem-autorizacao', ate: daqui(exports.CADENCIA_MS) }, ['o arco não tem envelope autorizado']);
+    }
+    const conteudo = estado.conteudo;
+    // RM-058 N6: o arco encerrado (hora, custo ou fila vazia) também acabou: nada é candidato.
+    if (estado.situacao === 'revogado' || estado.situacao === 'expirado' || estado.situacao === 'encerrado') {
+        return vazia('vazia', { acao: 'encerrar', motivo: 'arco-encerrado' });
+    }
+    if (estado.situacao === 'agendado')
+        return vazia('bloqueada', { acao: 'aguardar', motivo: 'agendado', ate: conteudo.janela.inicio });
+    if (!(0, noctum_envelope_1.envelopeComTrabalhos)(conteudo)) {
+        return vazia('fonte-indisponivel', { acao: 'aguardar', motivo: 'fonte-indisponivel', ate: daqui(exports.CADENCIA_MS, conteudo.janela.fim) }, ['o envelope vigente é v1, sem lista de trabalhos']);
+    }
+    // Primeiro quem já foi entregue, para as dependências (aqui ou, no arco entre máquinas, em outra); depois cada trabalho.
+    const entregues = new Set(conteudo.trabalhos.filter(t => {
+        const f = fatos.porTrabalho.get(t.id);
+        return fatos.coordenacao?.entregues.has(t.id) || (!!f && f.threads.length === 1 && !!f.entregueEm && f.threads[0].roadmap === t.item);
+    }).map(t => t.id));
+    // S7 do CHECK: quem fechou sem entrega nunca mais entrega neste arco, nem quem depende dele, de qualquer distância. No arco
+    // entre máquinas (B1 e S1 da rodada 3 da ork-rm058n3), a rede decide antes da thread local: o entregue lá nunca fica sem
+    // saída por uma thread antiga fechada aqui, e o encerrado lá fica sem saída aqui também.
+    const semSaida = new Set(conteudo.trabalhos.filter(t => {
+        if (fatos.coordenacao?.entregues.has(t.id))
+            return false;
+        if (fatos.coordenacao?.encerrados?.has(t.id))
+            return true;
+        const f = fatos.porTrabalho.get(t.id);
+        return !!f && f.threads.length === 1 && !f.entregueEm && f.threads[0].status === 'fechada' && f.threads[0].roadmap === t.item;
+    }).map(t => t.id));
+    for (let mudou = true; mudou;) {
+        mudou = false;
+        for (const t of conteudo.trabalhos) {
+            if (!semSaida.has(t.id) && !entregues.has(t.id) && t.dependeDe.some(d => semSaida.has(d))) {
+                semSaida.add(t.id);
+                mudou = true;
+            }
+        }
+    }
+    const trabalhos = conteudo.trabalhos.map((t, i) => classificar(t, i, fatos.porTrabalho.get(t.id), fatos, entregues, semSaida, estado));
+    const candidatos = trabalhos.filter(t => t.estado === 'despachavel' || t.estado === 'abrir').sort(antes);
+    // Thread ilegível só é lacuna quando pode ser a de um trabalho (S7 do CHECK): a classificação já a pôs no trabalho.
+    const lacunas = trabalhos.filter(t => t.motivo && DE_LACUNA.includes(t.motivo)).map(t => `trabalho ${t.id}: ${t.detalhe}`);
+    const terminal = (t) => t.estado === 'entregue' || t.estado === 'encerrado-sem-entrega' ||
+        t.motivo === 'dependencia-encerrada';
+    const situacao = candidatos.length ? 'com-trabalho' : trabalhos.some(t => t.estado === 'em-curso') ? 'em-curso'
+        : lacunas.length ? 'fonte-indisponivel' : trabalhos.every(terminal) ? 'vazia' : 'bloqueada';
+    const fim = conteudo.janela.fim;
+    const backoff = Math.min(exports.BACKOFF_MAXIMO_MS, Math.max(exports.CADENCIA_MS, Math.floor((agora - ultimoProgresso(estado, trabalhos)) / 2)));
+    const decisao = situacao === 'com-trabalho' ? { acao: 'despachar' }
+        : situacao === 'vazia' ? { acao: 'encerrar', motivo: 'fila-vazia' }
+            : situacao === 'em-curso' ? { acao: 'aguardar', motivo: 'em-curso', ate: daqui(exports.CADENCIA_MS, fim) }
+                : { acao: 'aguardar', motivo: situacao, ate: daqui(backoff, fim) };
+    return { contrato: exports.CONTRATO_FILA, arco, envelopeSha256: estado.envelopeSha256, quando, situacao, trabalhos, candidatos, lacunas, decisao };
+}
+/**
+ * Os fatos da fila, relidos do disco: o arco, as threads de cada trabalho, o passo do condutor delas, as reservas da
+ * última cópia local (sem rede) e o lote. `lerReservas` é dependência dos testes.
+ */
+function fatosDaFila(carregado, arco, opcoes = {}) {
+    const quando = opcoes.quando ?? new Date().toISOString();
+    const { raiz } = carregado;
+    const estado = (0, noctum_arco_1.lerArco)(raiz, arco, quando);
+    const maquina = (0, maquina_1.nomeDaMaquina)(opcoes.maquina);
+    const lidas = (opcoes.lerReservas ?? (() => (0, branch_de_estado_1.pontaLocal)(raiz, roadmap_reservas_1.REMOTO_PADRAO, roadmap_reservas_1.BRANCH_DE_RESERVAS) === null
+        ? { leitura: 'sem-copia', reservas: [] }
+        : { leitura: 'copia-local', reservas: (0, roadmap_reservas_1.reservasLocais)(raiz) }))();
+    const fatos = { arco, quando, maquina, estado, porTrabalho: new Map(), threadsIlegiveis: [],
+        modosPermitidos: carregado.manifesto.conduction.allowed_modes, ...(opcoes.coordenacao ? { coordenacao: opcoes.coordenacao } : {}),
+        ...(opcoes.supervisao ? { supervisao: opcoes.supervisao } : {}),
+        reservas: { leitura: lidas.leitura, porItem: new Map(lidas.reservas.map(r => [r.item, { maquina: r.maquina, thread: r.thread }])) } };
+    if (!estado?.conteudo || !(0, noctum_envelope_1.envelopeComTrabalhos)(estado.conteudo))
+        return fatos;
+    const threads = [];
+    for (const id of (0, thread_1.listarIds)(raiz)) {
+        try {
+            threads.push((0, thread_1.lerThread)(raiz, id));
+        }
+        catch {
+            fatos.threadsIlegiveis.push(id);
+        }
+    }
+    const passos = new Map((0, conducao_sentinela_1.passosDoCondutor)(carregado, { quando }).map(p => [p.thread, p]));
+    for (const t of estado.conteudo.trabalhos) {
+        let casam;
+        let ilegivel = null;
+        if (t.thread !== undefined) {
+            casam = threads.filter(x => x.id === t.thread);
+            if (!casam.length && fatos.threadsIlegiveis.includes(t.thread))
+                ilegivel = t.thread;
+        }
+        else {
+            const alvo = (0, noctum_envelope_1.shaDoPedido)(t.pedido);
+            casam = threads.filter(x => x.roadmap === t.item && x.pedido?.sha256 === alvo);
+            // Sem casar e com thread ilegível, ela pode ser a do trabalho: abrir outra duplicaria a thread.
+            if (!casam.length && fatos.threadsIlegiveis.length)
+                ilegivel = fatos.threadsIlegiveis[0];
+        }
+        const th = casam.length === 1 ? casam[0] : null;
+        let eventos = [];
+        try {
+            eventos = th ? (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, th.id)) : [];
+        }
+        catch {
+            ilegivel = th.id;
+        }
+        let pedidoGuardado = false;
+        try {
+            pedidoGuardado = !!th && (0, thread_1.pedidoDaThread)(raiz, th) !== null;
+        }
+        catch {
+            pedidoGuardado = false;
+        }
+        fatos.porTrabalho.set(t.id, {
+            threads: casam, ilegivel,
+            entregueEm: eventos.find(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.shipConcluido)?.ts ?? null,
+            despachada: eventos.some(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.faseDespachada),
+            despachoFalho: !eventos.some(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.faseDespachada) &&
+                eventos.some(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.despachoFalhou && typeof e.sessionId === 'string'),
+            pedidoGuardado,
+            passo: th ? passos.get(th.id) ?? null : null,
+            espera: th && th.status !== 'fechada' ? (0, parado_no_condutor_1.esperaDoCondutor)(th, eventos, quando) : null,
+            doDono: th && th.status !== 'fechada' ? (0, parado_no_condutor_1.pendenciaDoDono)(th, eventos, quando) : null,
+        });
+    }
+    return fatos;
+}

package/dist/noctum-guarda.js

@@ -0,0 +1,256 @@
+"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_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 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';
+/** 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() };
+    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 !!conteudo?.trabalhos?.some(w => w.thread !== undefined ? w.thread === thread
+        : w.pedido !== undefined && dados().roadmap === w.item && dados().pedido === (0, noctum_envelope_1.shaDoPedido)(w.pedido));
+}
+/**
+ * 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) {
+        // 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;