@orkastery/cli 0.5.6 → 0.6.1

package/dist/noctum-fechamento.js

@@ -0,0 +1,416 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessoesEmVooDoArco = exports.CONTRATO_FECHAMENTO = void 0;
+exports.condicaoDeFechamento = condicaoDeFechamento;
+exports.trabalhosDoArco = trabalhosDoArco;
+exports.lerFechamento = lerFechamento;
+exports.fecharSeDevido = fecharSeDevido;
+exports.textoDaParada = textoDaParada;
+/**
+ * RM-058, fatia N6 (D2, D6 e D8 da ork-rm058n6): o fechamento do arco por hora, por custo e por fila vazia.
+ *
+ * A tabela "Condição / Comportamento / Estado deixado para retomar" da página manda:
+ *
+ *  - hora final, ou envelope expirado ou revogado: parar admissões e efeitos novos e encerrar as sessões em voo de modo
+ *    controlado, deixando checkpoints, motivos de interrupção e as operações em voo para reconciliar;
+ *  - fila vazia confirmada: encerrar cedo, sem abrir escopo novo, com o retrato das fontes e dos itens concluídos;
+ *  - teto do arco: parar globalmente, sem retry nem troca de conta para contornar, com o consumo, as reservas em voo e a
+ *    reconciliação pendente identificados.
+ *
+ * O teto em `sessoes` conta cada sessão na reserva: alcançado, nenhuma reserva nova passa (`noctum.orcamento.esgotado`, em
+ * qualquer conta), e o arco fecha quando a última sessão admitida acaba, porque pará-las não protege o teto, só joga
+ * trabalho fora (a hora final para as que passarem do fim). Em unidade contínua, o consumo segue enquanto a sessão roda:
+ * a leitura que alcança o teto fecha o arco e para as sessões em voo.
+ *
+ * As condições valem nesta ordem: revogado, hora, a parada da supervisão da N4 (RM-058, integração, D7 da
+ * ork-rm058integra; a parada pelo teto do arco fica com a regra do custo e, sem sessão admitida em voo e com o consumo
+ * abaixo do teto, fecha pela supervisão: N2 do CHECK 2), custo, fila vazia (D8). Revogado, hora, a parada e o teto em sessões não dependem da fila nem da
+ * medição, e nenhuma falha delas segura esse fechamento. Com uma condição, o fechamento grava primeiro o
+ * `encerrado` no log do arco (`encerrarArco`): dali em diante nenhuma reserva de despacho nem efeito passa, e nenhuma
+ * reserva devolvida reabre o arco. Só depois vêm o retrato do fechamento e o pedido de parada de cada sessão em voo, no
+ * registro próprio da N6 (`fechamento.jsonl`). A parada é pedida uma vez por sessão, pelo controle da conta dela (o
+ * `pararSessao` do núcleo no claude-bg); o codex fica `sem-controle`, porque parar uma sessão dele exige o controller
+ * vinculado (limite da N4). A reserva pendente para pelo id que a falha do runtime disse no ledger da thread, quando
+ * disse; sem ele, não há o que parar. No tique seguinte, a listagem do runtime confirma a parada, ou a deixa
+ * `nao-confirmada`. O retrato é gravado uma vez; se o processo cair entre o `encerrado` e o registro, o tique seguinte o
+ * grava.
+ *
+ * Subteto de conta ou runtime esgotado não fecha o arco: a reserva por aquela conta ou runtime é recusada, e trocar para
+ * outra conta admitida é da N4. Consumo com lacuna também não fecha por custo (o teto não se prova alcançado); a admissão
+ * já recusa por falta de medida.
+ *
+ * Interfaces para as fatias que correm em paralelo (D6): a parada (`parar`) e a listagem das sessões (`listarSessoes`)
+ * são injetáveis; a N4 pluga o controle dela aí. Nada aqui despacha.
+ */
+const horario_1 = require("./horario");
+const ledger_1 = require("./ledger");
+const master_1 = require("./master");
+const noctum_arco_1 = require("./noctum-arco");
+const noctum_envelope_1 = require("./noctum-envelope");
+const noctum_fila_1 = require("./noctum-fila");
+const noctum_rede_1 = require("./noctum-rede");
+const noctum_medicao_1 = require("./noctum-medicao");
+const noctum_registro_1 = require("./noctum-registro");
+const noctum_supervisao_1 = require("./noctum-supervisao");
+const noctum_sessoes_em_voo_1 = require("./noctum-sessoes-em-voo");
+Object.defineProperty(exports, "sessoesEmVooDoArco", { enumerable: true, get: function () { return noctum_sessoes_em_voo_1.sessoesEmVooDoArco; } });
+const sessoes_contas_1 = require("./sessoes-contas");
+const sessoes_1 = require("./sessoes");
+const thread_1 = require("./thread");
+const util_1 = require("./util");
+exports.CONTRATO_FECHAMENTO = 'ork.noctum-fechamento/v1';
+/**
+ * A condição de fechamento no instante dado, pura, na ordem da D8. `null` quando o arco segue (ou nunca foi autorizado).
+ * O custo só fecha com o teto do arco provado alcançado: em `sessoes`, pelas reservas não recusadas e sem sessão admitida
+ * em voo (`emVoo`, as sessões e reservas pendentes que ainda podem rodar); em outra unidade, pelo consumo medido sem
+ * lacuna. A parada pelo teto do arco espera as sessões admitidas e, sem nenhuma em voo, fecha pelo custo com o consumo no
+ * teto, ou pela supervisão abaixo dele (a reserva devolvida, a emenda que subiu o teto depois da parada).
+ */
+function condicaoDeFechamento(estado, fila, medicao, quando, emVoo = 0, parada = null) {
+    if (!estado || !estado.autorizadoPor || !estado.conteudo)
+        return null;
+    if (estado.encerramento)
+        return { motivo: estado.encerramento.motivo, detalhe: estado.encerramento.detalhe };
+    if (estado.situacao === 'revogado')
+        return { motivo: 'revogado', detalhe: 'o dono revogou o arco pelo ingresso autenticado' };
+    const fim = estado.conteudo.janela.fim;
+    if (Date.parse(quando) >= Date.parse(fim)) {
+        return { motivo: 'hora', detalhe: `o fim do envelope chegou (${(0, horario_1.formatarDataHora)(fim, { fuso: estado.conteudo.janela.fuso, locale: 'pt-BR' })}, ` +
+                `${estado.conteudo.janela.fuso}); nada o prorroga` };
+    }
+    // RM-058, integração (D7): a supervisão parou o arco (o vigia nunca encerra; quem encerra é o fechamento, por ela). A
+    // parada pelo teto do arco em sessões é a regra do custo logo abaixo: as sessões admitidas terminam, e o arco fecha
+    // quando a última acaba (A1 do CHECK); fechar por ela pediria a parada de trabalho já contado no teto.
+    if (parada && parada.motivo !== 'teto-do-arco')
+        return { motivo: 'supervisao', detalhe: `a supervisão parou o arco (${parada.motivo}): ${parada.detalhe}` };
+    const teto = estado.conteudo.orcamento.arco;
+    if (teto.unidade === 'sessoes') {
+        // Cada sessão admitida já está contada no teto: o arco fecha quando a última acaba, não por cima dela.
+        if (estado.consumo.arco >= teto.valor && emVoo === 0) {
+            return { motivo: 'custo', detalhe: `o teto do arco é de ${teto.valor} sessoes e ${estado.consumo.arco} foram reservadas; nenhuma segue em voo` };
+        }
+    }
+    else if (medicao) {
+        const c = (0, noctum_medicao_1.consumoDoEscopoNaUnidade)(medicao, 'arco', teto.unidade);
+        if (c.valor !== null && Number.isFinite(c.valor) && c.valor >= teto.valor) {
+            return { motivo: 'custo', detalhe: `o teto do arco é de ${teto.valor} ${teto.unidade} e o consumo medido é ${(0, noctum_medicao_1.textoDoConsumo)(c)}` };
+        }
+    }
+    // N2 do CHECK 2: a parada pelo teto segue terminal com o consumo abaixo dele (a reserva devolvida, a emenda que subiu o teto
+    // depois da parada): sem sessão admitida em voo, o arco fecha pela supervisão, em vez de ficar parado e aberto até a hora.
+    if (parada && emVoo === 0) {
+        return { motivo: 'supervisao', detalhe: `a supervisão parou o arco (${parada.motivo}): ${parada.detalhe}; nenhuma sessão admitida segue em voo` };
+    }
+    if (estado.situacao === 'agendado')
+        return null;
+    if (fila?.situacao === 'vazia' && fila.decisao.acao === 'encerrar' && fila.decisao.motivo === 'fila-vazia') {
+        // A entrega registrada (`ship_done`) pode vir sem a prova do push; o relatório diz qual tem prova.
+        return { motivo: 'fila-vazia', detalhe: 'todo trabalho do envelope tem a entrega registrada (ship_done), fechou sem entrega ou depende ' +
+                'de um que fechou sem entrega; nada sobra para este arco' };
+    }
+    return null;
+}
+/**
+ * RM-058, integração (T4, D8): as threads que este arco entregou (o `ship_done` da entrega dele, com o arco na evidência) e
+ * cujo MASTER por omissão a entrega dele ainda faz, como em `noctum-entrega.ts`: o envelope `v2`, o trabalho sem isolamento,
+ * a thread aberta e sem MASTER ratificado. A thread que não se lê não segura o fechamento: a fila já a mostra.
+ */
+function mastersDevidos(raiz, estado, fila, sup) {
+    const devidos = [];
+    for (const t of fila.trabalhos) {
+        if (t.estado !== 'entregue' || !t.thread || sup.isolados.has(t.id))
+            continue;
+        try {
+            const doArco = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, t.thread)).some(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.shipConcluido &&
+                e.evidencia?.arco === estado.arco);
+            if (doArco && (0, thread_1.lerThread)(raiz, t.thread).status !== 'fechada' && !(0, master_1.masterRatificado)(raiz, t.thread))
+                devidos.push(t.thread);
+        }
+        catch { /* a leitura que falhou não prende o arco aberto */ }
+    }
+    return devidos;
+}
+const gitDoDisco = (cwd, args) => {
+    const r = (0, util_1.exec)('git', ['-C', cwd, ...args], undefined, 15_000);
+    return r.ok ? r.stdout.trim() : null;
+};
+/** As sessões vivas pelo `claude agents` e pelos rollouts de todas as contas que o `ork` conhece. */
+function sessoesDoRuntime(raiz) {
+    try {
+        const l = (0, sessoes_contas_1.consultarContas)(raiz);
+        return { lidas: l.fontes.every(f => f.ok), vivas: new Set(l.sessoes.filter(s => s.viva && !(0, sessoes_contas_1.encerradaNaLista)(s)).map(s => s.sessionId)) };
+    }
+    catch {
+        return { lidas: false, vivas: new Set() };
+    }
+}
+/** O controle de produção: o claude-bg para pela conta dele; o codex não tem controle sem o controller vinculado. */
+function pararPeloNucleo(raiz) {
+    return (s) => {
+        if (!s.sessionId)
+            return { ok: false, detalhe: 'sem id de sessão' };
+        const r = (0, sessoes_1.pararSessao)(s.sessionId, raiz);
+        return { ok: r.codigo === 0, detalhe: r.texto.slice(0, 300) };
+    };
+}
+function trabalhosNaRetomada(raiz, fila, git) {
+    return (fila?.trabalhos ?? []).map(t => {
+        let branch = null, ponta = null, arvoreLimpa = null;
+        if (t.thread) {
+            let wt = null;
+            try {
+                wt = (0, thread_1.lerThread)(raiz, t.thread).worktree ?? null;
+            }
+            catch {
+                wt = null;
+            }
+            if (wt) {
+                branch = git(wt, ['rev-parse', '--abbrev-ref', 'HEAD']);
+                ponta = git(wt, ['rev-parse', 'HEAD']);
+                const status = git(wt, ['status', '--porcelain']);
+                arvoreLimpa = status === null ? null : status.length === 0;
+            }
+        }
+        return { id: t.id, item: t.item, thread: t.thread, estado: t.estado, fase: t.fase, motivo: t.motivo, detalhe: t.detalhe,
+            entregueEm: t.entregueEm, branch, ponta, arvoreLimpa };
+    });
+}
+function instrucaoDeRetomada(arco, trabalhos, reservas, emVoo) {
+    const linhas = [`O arco ${arco} não reabre: o trabalho que sobrou volta num arco novo, com envelope vigente proposto por ` +
+            '`ork noctum propor` e autorizado pelo dono por ingresso autenticado.'];
+    if (reservas.length) {
+        linhas.push(`As reservas pendentes (${reservas.map(r => r.seq).join(', ')}) precisam ser reconciliadas antes do primeiro despacho do arco ` +
+            'novo, pela N4 ou pelo dono: o runtime pode ter aberto a sessão, e nada deve ser despachado por cima dela.');
+    }
+    for (const t of trabalhos.filter(x => x.thread && x.estado !== 'entregue' && x.estado !== 'encerrado-sem-entrega')) {
+        linhas.push(`A thread ${t.thread} (${t.id}) retoma pelo passo do arco novo${t.fase ? `, na fase ${t.fase}` : ''}, pela prova mais adiantada` +
+            `${t.arvoreLimpa === false ? '; a árvore tem mudanças não commitadas, que a sessão seguinte confere' : ''}.`);
+    }
+    if (emVoo.some(s => s.runtime === 'codex' && s.sessionId)) {
+        linhas.push('A sessão do codex em voo não tem controle de parada sem o controller vinculado: confira-a antes do arco novo.');
+    }
+    linhas.push('Commit, push ou merge de resultado incerto nunca se repete às cegas: quem retoma reconcilia antes de agir.');
+    return linhas;
+}
+/**
+ * A classificação de cada trabalho como se o arco estivesse vigente. `montarFila` não classifica nada num arco expirado,
+ * revogado ou encerrado (nada é candidato), e o retrato do fechamento e o relatório precisam saber onde cada trabalho
+ * parou justamente nesses arcos. A decisão desta fila não vale para despachar: só a classificação é lida.
+ */
+function trabalhosDoArco(fatos) {
+    const e = fatos.estado;
+    if (!e || !e.conteudo || !e.autorizadoPor || e.situacao === 'vigente')
+        return (0, noctum_fila_1.montarFila)(fatos);
+    return (0, noctum_fila_1.montarFila)({ ...fatos, estado: { ...e, situacao: 'vigente' } });
+}
+/** O retrato gravado e as paradas e conferências do registro do fechamento. */
+function lerFechamento(raiz, arco) {
+    const linhas = (0, noctum_registro_1.lerRegistro)(raiz, arco, 'fechamento');
+    const fechado = linhas.find(l => l.evento.tipo === 'fechado')?.evento;
+    return {
+        retrato: fechado?.tipo === 'fechado' ? fechado.retrato : null,
+        paradas: linhas.filter(l => l.evento.tipo === 'parada_pedida').map(l => l.evento.parada),
+        conferencias: linhas.filter(l => l.evento.tipo === 'parada_conferida').map(l => l.evento.conferencia),
+    };
+}
+/** O retrato do fechamento: o consumo, a fila e o estado de retomada, lidos no instante dado e gravados uma vez. */
+function gravarRetrato(carregado, arco, estado, encerramento, quando, o) {
+    const { raiz } = carregado;
+    let trabalhosDaFila = null;
+    try {
+        const rede = estado.conteudo && (0, noctum_envelope_1.envelopeMultimaquina)(estado.conteudo)
+            ? o.projecaoDaRede ?? (0, noctum_rede_1.lerRede)(carregado, arco, { quando, maquina: o.maquina, remoto: o.remoto, rede: o.redeDaCoordenacao }) : null;
+        const coordenacao = rede ? (0, noctum_rede_1.coordenacaoDaFila)(rede) : null;
+        trabalhosDaFila = rede?.lacuna ? null : trabalhosDoArco((0, noctum_fila_1.fatosDaFila)(carregado, arco, { quando, maquina: o.maquina, lerReservas: o.lerReservas, ...(coordenacao ? { coordenacao } : {}) }));
+    }
+    catch (e) {
+        if (!(e instanceof noctum_envelope_1.RecusaDoArco))
+            throw e;
+    }
+    let consumo;
+    try {
+        const medicao = o.medir(raiz, estado, quando);
+        consumo = Object.fromEntries(noctum_envelope_1.UNIDADES.map(u => [u, (0, noctum_medicao_1.consumoDoEscopoNaUnidade)(medicao, 'arco', u)]));
+    }
+    catch (e) {
+        const lacuna = `a medição falhou no fechamento (${e.message.slice(0, 200)})`;
+        consumo = Object.fromEntries(noctum_envelope_1.UNIDADES.map(u => [u, { unidade: u, valor: null, lacunas: [lacuna], parcial: false, tetoSuperior: false,
+                sessoes: 0 }]));
+    }
+    const emVoo = (0, noctum_sessoes_em_voo_1.sessoesEmVooDoArco)(raiz, estado);
+    const trabalhos = trabalhosNaRetomada(raiz, trabalhosDaFila, o.git);
+    const reservasEmVoo = estado.despachos.filter(d => d.desfecho === 'pendente')
+        .map(d => ({ seq: d.seq, trabalho: d.trabalho, thread: d.threadDespachada ?? d.thread }));
+    const ditaNaFalha = new Map(emVoo.filter(s => s.daReservaPendente && s.sessionId).map(s => [s.seq, s.sessionId]));
+    const retrato = {
+        contrato: exports.CONTRATO_FECHAMENTO, arco, motivo: encerramento.motivo, detalhe: encerramento.detalhe, em: encerramento.em,
+        versao: encerramento.versao, envelopeSha256: encerramento.envelopeSha256, consumo,
+        // A situação da fila como se o arco seguisse: a do arco encerrado é sempre vazia, e não diz onde o trabalho parou.
+        fila: { situacao: trabalhosDaFila?.situacao ?? null,
+            lacunas: trabalhosDaFila ? trabalhosDaFila.lacunas : ['a fila do arco não pôde ser lida no fechamento'], lida: !!trabalhosDaFila },
+        retomada: { trabalhos, reservasEmVoo,
+            reconciliacaoPendente: [...reservasEmVoo.map(r => ditaNaFalha.has(r.seq)
+                    ? `reserva ${r.seq} (${r.trabalho}): pendente, com a sessão ${ditaNaFalha.get(r.seq)} dita na falha do runtime`
+                    : `reserva ${r.seq} (${r.trabalho}): pendente, sem id de sessão`),
+                ...emVoo.filter(s => s.sessionId && !s.daReservaPendente).map(s => `sessão ${s.sessionId} (${s.trabalho}): em voo no fechamento`)],
+            instrucao: instrucaoDeRetomada(arco, trabalhos, reservasEmVoo, emVoo) },
+    };
+    (0, noctum_registro_1.comRegistro)(raiz, arco, 'fechamento', (linhas, anexar) => {
+        if (!linhas.some(l => l.evento.tipo === 'fechado'))
+            anexar({ tipo: 'fechado', retrato }, quando);
+    }, { esperarMs: 5_000 });
+}
+/**
+ * Fecha o arco se alguma condição vale, e confirma as paradas pendentes de um arco já fechado. Idempotente: o segundo
+ * chamado não grava outro retrato nem pede a mesma parada de novo. Lança só o erro que não é recusa tipada do arco.
+ */
+function fecharSeDevido(carregado, arco, opcoes = {}) {
+    const quando = opcoes.quando ?? new Date().toISOString();
+    const { raiz } = carregado;
+    const nada = (detalhe) => ({ fechado: false, agora: false, motivo: null, detalhe, retrato: null, paradas: [], conferencias: [] });
+    let estado;
+    try {
+        estado = (0, noctum_arco_1.lerArco)(raiz, arco, quando);
+    }
+    catch (e) {
+        if (e instanceof noctum_envelope_1.RecusaDoArco)
+            return nada(e.message);
+        throw e;
+    }
+    if (!estado)
+        return nada(`o arco ${arco} não tem proposta`);
+    if (!estado.autorizadoPor || !estado.conteudo)
+        return nada(`o arco ${arco} nunca foi autorizado pelo dono`);
+    const medir = opcoes.medir ?? ((r, e, q) => (0, noctum_medicao_1.medirArco)(r, e, { quando: q }));
+    const git = opcoes.git ?? gitDoDisco;
+    const parar = opcoes.parar ?? pararPeloNucleo(raiz);
+    const listar = opcoes.listarSessoes ?? (() => sessoesDoRuntime(raiz));
+    let agora = false;
+    if (!estado.encerramento) {
+        const emVooAgora = (0, noctum_sessoes_em_voo_1.sessoesEmVooDoArco)(raiz, estado).length;
+        const multimaquina = (0, noctum_envelope_1.envelopeMultimaquina)(estado.conteudo);
+        const rede = multimaquina
+            ? opcoes.projecaoDaRede ?? (0, noctum_rede_1.lerRede)(carregado, arco, { quando, maquina: opcoes.maquina, remoto: opcoes.remoto, rede: opcoes.redeDaCoordenacao })
+            : null;
+        // Com rede íntegra, o teto em sessões é global. Sem leitura, o consumo local ainda pode provar sozinho que o teto caiu.
+        const estadoDoCusto = rede && !rede.lacuna
+            ? { ...estado, consumo: { ...estado.consumo, arco: rede.consumo.arco } }
+            : estado;
+        // RM-058, integração (D7): a parada da supervisão; o log dela que não se lê não segura o fechamento pelas outras condições.
+        let sup = null;
+        try {
+            sup = (0, noctum_supervisao_1.lerSupervisao)(raiz, arco);
+        }
+        catch (e) {
+            if (!(e instanceof noctum_supervisao_1.RecusaDaSupervisao))
+                throw e;
+        }
+        const parada = sup?.parada ?? null;
+        // Revogado, hora, a parada e o teto em sessões vêm primeiro e sem a fila nem a medição: nenhuma falha delas segura esse fechamento.
+        let condicao = condicaoDeFechamento(estadoDoCusto, null, null, quando, emVooAgora, parada);
+        let falhaDaMedicao = '';
+        if (!condicao) {
+            let fila = null;
+            try {
+                const coordenacao = rede ? (0, noctum_rede_1.coordenacaoDaFila)(rede) : null;
+                fila = rede?.lacuna ? null : (0, noctum_fila_1.montarFila)((0, noctum_fila_1.fatosDaFila)(carregado, arco, { quando, maquina: opcoes.maquina, lerReservas: opcoes.lerReservas, ...(coordenacao ? { coordenacao } : {}) }));
+            }
+            catch (e) {
+                if (!(e instanceof noctum_envelope_1.RecusaDoArco))
+                    throw e;
+            }
+            let medicao = null;
+            if (estado.conteudo.orcamento.arco.unidade !== 'sessoes' && !rede?.lacuna) {
+                // A medição que falha não prova o teto alcançado: o custo não fecha, e a fila vazia ainda pode fechar.
+                try {
+                    medicao = medir(raiz, estado, quando);
+                }
+                catch (e) {
+                    falhaDaMedicao = `; a medição falhou (${e.message.slice(0, 200)})`;
+                }
+            }
+            condicao = condicaoDeFechamento(estadoDoCusto, fila, medicao, quando, emVooAgora, parada);
+            // RM-058, integração (T4, D8): a fila vazia não fecha o arco por cima do MASTER por omissão que a entrega dele ainda
+            // deve; o passo seguinte o faz, e o fechamento vem depois. A hora, a parada e o teto fecharam antes, sem esperar.
+            const devidos = condicao?.motivo === 'fila-vazia' && fila && sup ? mastersDevidos(raiz, estado, fila, sup) : [];
+            if (devidos.length) {
+                return nada(`o arco segue: a fila está vazia, mas a entrega do arco ainda faz o MASTER por omissão de ${devidos.join(', ')}`);
+            }
+        }
+        if (!condicao)
+            return nada(`o arco segue: nenhuma condição de fechamento vale agora${falhaDaMedicao}`);
+        // O terminal primeiro: daqui em diante nenhum despacho nem efeito passa.
+        estado = (0, noctum_arco_1.encerrarArco)(raiz, arco, condicao, quando);
+        agora = true;
+    }
+    const encerramento = estado.encerramento;
+    // O retrato do fechamento, uma vez: se o processo caiu entre o encerrado e o registro, o tique seguinte o grava.
+    if (!lerFechamento(raiz, arco).retrato)
+        gravarRetrato(carregado, arco, estado, encerramento, quando, { ...opcoes, medir, git });
+    // Pede a parada de cada sessão em voo uma vez, e confere as pedidas antes; tudo sob a trava do registro do fechamento.
+    const atual = (0, noctum_arco_1.lerArco)(raiz, arco, quando) ?? estado;
+    const emVoo = (0, noctum_sessoes_em_voo_1.sessoesEmVooDoArco)(raiz, atual);
+    const novas = [], conferidas = [];
+    (0, noctum_registro_1.comRegistro)(raiz, arco, 'fechamento', (linhas, anexar) => {
+        const pedidas = linhas.filter(l => l.evento.tipo === 'parada_pedida').map(l => l.evento.parada);
+        const jaConferidas = new Set(linhas.filter(l => l.evento.tipo === 'parada_conferida')
+            .map(l => l.evento.conferencia.sessionId));
+        const aConferir = pedidas.filter(p => p.resultado === 'pedida' && p.sessionId && !jaConferidas.has(p.sessionId));
+        if (aConferir.length && !agora) {
+            const lista = listar();
+            if (lista.lidas) {
+                for (const p of aConferir) {
+                    const conferencia = { sessionId: p.sessionId, confirmada: !lista.vivas.has(p.sessionId),
+                        detalhe: lista.vivas.has(p.sessionId) ? 'a sessão segue viva na listagem do runtime depois do pedido de parada'
+                            : 'a sessão não aparece viva na listagem do runtime' };
+                    anexar({ tipo: 'parada_conferida', conferencia }, quando);
+                    conferidas.push(conferencia);
+                }
+            }
+        }
+        const chave = (s) => s.sessionId ?? `reserva:${s.seq}`;
+        const jaPedidas = new Set(pedidas.map(chave));
+        for (const s of emVoo.filter(x => !jaPedidas.has(chave(x)))) {
+            let resultado, detalhe;
+            if (!s.sessionId) {
+                resultado = 'sem-id';
+                detalhe = 'reserva pendente: a sessão pode ter aberto sem id, e não há o que parar';
+            }
+            else if (s.runtime !== 'claude-bg') {
+                resultado = 'sem-controle';
+                detalhe = 'parar a sessão do codex exige o controller vinculado';
+            }
+            else {
+                let r;
+                try {
+                    r = parar(s);
+                }
+                catch (e) {
+                    r = { ok: false, detalhe: e.message.slice(0, 300) };
+                }
+                resultado = r.ok ? 'pedida' : 'falhou';
+                detalhe = r.detalhe || (r.ok ? 'o runtime aceitou o pedido de parada' : 'o runtime não aceitou o pedido de parada');
+            }
+            const parada = { seq: s.seq, sessionId: s.sessionId, trabalho: s.trabalho, thread: s.thread, runtime: s.runtime,
+                conta: s.conta, resultado, detalhe };
+            anexar({ tipo: 'parada_pedida', parada }, quando);
+            novas.push(parada);
+        }
+    }, { esperarMs: 5_000 });
+    const registro = lerFechamento(raiz, arco);
+    return { fechado: true, agora, motivo: encerramento.motivo, detalhe: encerramento.detalhe, retrato: registro.retrato,
+        paradas: registro.paradas, conferencias: registro.conferencias };
+}
+/** O que cada desfecho da parada quer dizer para o dono, sem o código. */
+const PARADA_EM_TEXTO = Object.freeze({
+    'sem-id': () => 'reserva pendente sem id de sessão, nada a parar; reconciliar antes do arco novo',
+    'sem-controle': (p) => `sem controle de parada no ${p.runtime}; conferir a sessão antes do arco novo`,
+    falhou: (p) => `o pedido de parada falhou (${p.detalhe})`,
+});
+/** Uma linha por parada, para o retrato e o relatório. */
+function textoDaParada(p, conferencias) {
+    const c = p.sessionId ? conferencias.find(x => x.sessionId === p.sessionId) : undefined;
+    const situacao = p.resultado !== 'pedida' ? PARADA_EM_TEXTO[p.resultado](p) : !c ? 'parada pedida, sem conferência ainda'
+        : c.confirmada ? 'parada confirmada' : 'parada não confirmada';
+    return `${p.sessionId ?? `reserva ${p.seq}`} (${p.trabalho}, ${p.runtime}): ${situacao}`;
+}

package/dist/noctum-fila.js

@@ -22,6 +22,11 @@ exports.fatosDaFila = fatosDaFila;
  * 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");
@@ -69,6 +74,16 @@ function classificar(t, posicao, f, fatos, entregues, semSaida, estado) {
     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 ((0, noctum_envelope_1.envelopeMultimaquina)(estado.conteudo) && fatos.coordenacao?.emOutraMaquina?.has(t.id)) {
+        return bloqueado('em-outra-maquina', 'o trabalho tem ordem viva em outra máquina do arco');
+    }
     if (!f)
         return bloqueado('thread-ilegivel', 'o trabalho não foi lido');
     if (f.ilegivel)
@@ -86,6 +101,10 @@ function classificar(t, posicao, f, fatos, entregues, semSaida, estado) {
         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));
@@ -95,6 +114,9 @@ function classificar(t, posicao, f, fatos, entregues, semSaida, estado) {
     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);
@@ -113,6 +135,12 @@ function classificar(t, posicao, f, fatos, entregues, semSaida, estado) {
     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'))
@@ -128,7 +156,7 @@ function classificar(t, posicao, f, fatos, entregues, semSaida, estado) {
     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 bloqueado('retomada', `o despacho da thread ${th.id} falhou depois de o runtime dizer o id da sessão; a retomada é da N4`);
+            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;
@@ -138,12 +166,12 @@ function classificar(t, posicao, f, fatos, entregues, semSaida, estado) {
         return { ...base, estado: 'despachavel', fase: passo.fase, detalhe: passo.porque };
     }
     if (passo?.acao === 'retomar')
-        return bloqueado('retomada', `${passo.porque}; a retomada é da N4`);
+        return paraAN4('retomada', `${passo.porque}; a retomada é da N4`);
     if (f.espera?.tipo === 'stop-sem-resultado')
-        return bloqueado('fim-de-turno-sem-resultado', 'o turno acabou sem o resultado da fase; quem decide é a N4');
+        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 bloqueado('sem-passo', passo?.porque ?? 'nenhum passo do condutor para a thread');
+    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) {
@@ -165,20 +193,28 @@ function montarFila(fatos) {
         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;
-    if (estado.situacao === 'revogado' || estado.situacao === 'expirado')
+    // 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; depois cada trabalho.
+    // 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 !!f && f.threads.length === 1 && !!f.entregueEm && f.threads[0].roadmap === t.item;
+        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.
+    // 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));
@@ -220,7 +256,8 @@ function fatosDaFila(carregado, arco, opcoes = {}) {
         ? { 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,
+        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;
@@ -244,7 +281,9 @@ function fatosDaFila(carregado, arco, opcoes = {}) {
         }
         else {
             const alvo = (0, noctum_envelope_1.shaDoPedido)(t.pedido);
-            casam = threads.filter(x => x.roadmap === t.item && x.pedido?.sha256 === alvo);
+            const ordem = opcoes.coordenacao?.ordens?.get(t.id);
+            casam = threads.filter(x => x.roadmap === t.item && x.pedido?.sha256 === alvo &&
+                (!ordem || x.assunto.endsWith(`o${ordem.numero}`)));
             // 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];