@orkastery/cli 0.5.1 → 0.5.6

package/dist/noctum-execucao.js

@@ -0,0 +1,304 @@
+"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.ESPERA_DA_VEZ_DE_DESPACHAR_MS = void 0;
+exports.passoDoArco = passoDoArco;
+/**
+ * RM-058, fatia N2 (D11 da ork-rm058n2): o passo do arco.
+ *
+ * Um despacho por chamada, sempre pelo núcleo. Sob a trava do kernel de despacho da raiz de estado (um despachante por
+ * vez, entre todos os arcos desta raiz), o passo relê o arco e os fatos, monta a fila, escolhe o primeiro candidato que
+ * a capacidade admite, reserva o despacho com a conferência do envelope sob o lock do arco (`reservarDespacho`, que é a
+ * conferência imediatamente antes do efeito), abre a thread quando o trabalho é novo (`novaThread`) e despacha por
+ * `rodarFase`, que toma o lease de condução e é idempotente para a mesma fase e o mesmo prompt. O desfecho volta ao log do
+ * arco (`concluirDespacho`): a recusa do núcleo devolve a sessão ao orçamento.
+ *
+ * A baseline que o bloco com GO no codex pede nunca roda entre a reserva e o lançamento (A1 do CHECK da ork-rm058n2): o
+ * despacho recusa com `baseline.pendente`, a reserva volta, a trava de despacho é solta e só então a baseline é gravada;
+ * o passo seguinte confere o envelope de novo e despacha. A falha de um candidato antes de lançar (abrir a thread, ler o
+ * pedido) devolve a reserva e o passo segue para o próximo (A4). Do núcleo, só a recusa de antes do lançamento devolve a
+ * reserva: a recusa dos portões, e a da conta, do limite de uso ou do impedimento do dono quando nenhuma sessão foi dita.
+ * Quando o runtime pode ter aberto a sessão (a falha seca dele, o id dito antes da falha, o núcleo que voltou sem sessão
+ * nem recusa, ou a exceção de dentro do `rodarFase`), a reserva fica pendente e contada até a N4 reconciliar (B1 da rodada
+ * 2). A recusa tipada do arco, inclusive a do log adulterado, volta como resultado.
+ *
+ * A revogação nunca espera um despacho: ela usa o lock do arco, e a trava de despacho é outra. Quem chama decide quando
+ * chamar de novo (o vigia é da N4); a decisão da fila diz até quando esperar. Nada aqui liga o modo.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const board_1 = require("./board");
+const conducao_1 = require("./conducao");
+const ledger_1 = require("./ledger");
+const estado_thread_1 = require("./estado-thread");
+const fila_pesada_1 = require("./fila-pesada");
+const noctum_arco_1 = require("./noctum-arco");
+const noctum_capacidade_1 = require("./noctum-capacidade");
+const noctum_envelope_1 = require("./noctum-envelope");
+const noctum_fila_1 = require("./noctum-fila");
+const phase_1 = require("./phase");
+const runtime_profiles_1 = require("./runtime-profiles");
+const setup_1 = require("./setup");
+const thread_1 = require("./thread");
+const verify_1 = require("./verify");
+/** Quanto o passo espera a vez de despachar antes de devolver `aguardar`: o despacho de outro arco leva segundos. */
+exports.ESPERA_DA_VEZ_DE_DESPACHAR_MS = 30_000;
+const PAUSA_MS = 200;
+const pausa = new Int32Array(new SharedArrayBuffer(4));
+const dormir = (ms) => { if (ms > 0)
+    Atomics.wait(pausa, 0, 0, Math.ceil(ms)); };
+/** A trava de despacho da raiz de estado: o descritor, ou `null` quando outro passo não a soltou no prazo. */
+function vezDeDespachar(raiz, esperarMs) {
+    const principal = (0, estado_thread_1.raizDoEstado)(raiz);
+    (0, estado_thread_1.exigirEstadoSemLink)(principal, ['.orkastery', 'noctum']);
+    const dir = path.join(principal, '.orkastery', 'noctum');
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const prazo = Date.now() + esperarMs;
+    for (;;) {
+        const fd = (0, fila_pesada_1.tentarTravaExclusiva)(path.join(dir, 'despacho.lock'));
+        if (fd !== null)
+            return fd;
+        if (Date.now() >= prazo)
+            return null;
+        dormir(Math.min(PAUSA_MS, prazo - Date.now()));
+    }
+}
+/** O runtime que o `phase run` vai usar para a fase desta thread: o do bloco no setup, senão o do manifesto. */
+function runtimeDaFase(carregado, modo, fase) {
+    return (0, phase_1.resolverDespacho)(carregado.manifesto, {}, (0, setup_1.configDoBloco)((0, setup_1.lerSetup)(carregado.raiz), modo, fase)).runtime;
+}
+/** Os perfis do store que podem receber despacho agora; store ilegível é nenhum perfil (a fila espera, não chuta). */
+function perfisDisponiveis(raiz, agoraMs) {
+    try {
+        return (0, runtime_profiles_1.lerPerfis)(raiz).perfis.filter(p => (0, runtime_profiles_1.perfilDisponivel)(p, agoraMs)).map(p => ({ id: p.id, runtime: p.runtime }));
+    }
+    catch {
+        return [];
+    }
+}
+const aguardar = (decisao, fila) => ({ acao: 'aguardar', ate: decisao.ate, motivo: decisao.motivo, detalhe: fila.lacunas.join('; '), fila });
+/** O motivo que sobra quando nenhum candidato coube: a máquina cheia vale para todos, e o resto é do último tentado. */
+const MOTIVOS_DE_MAQUINA = ['capacidade.fonte-indisponivel', 'capacidade.projeto', 'capacidade.maquina'];
+/** As recusas da reserva que são só deste candidato (A4): a janela, a revogação, o hash e o log valem para todos. */
+const RECUSAS_DO_CANDIDATO = ['noctum.despacho.fora-do-envelope', 'noctum.orcamento.esgotado'];
+const mensagem = (e) => (e instanceof Error ? e.message : String(e)).slice(0, 500);
+/** Os eventos do ledger da thread, ou `null` quando ele não se lê. */
+function eventosDaThread(raiz, threadId) {
+    try {
+        return (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, threadId));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Um passo do arco: no máximo um despacho, pelo núcleo, com o envelope conferido imediatamente antes. Lança só o erro
+ * que não é recusa (disco, git); toda recusa tipada volta como resultado.
+ */
+function passoDoArco(carregado, arco, opcoes = {}) {
+    const quando = opcoes.quando ?? new Date().toISOString();
+    const { raiz } = carregado;
+    const cadencia = new Date(Date.parse(quando) + 60_000).toISOString();
+    if (!(0, fila_pesada_1.kernelDisponivel)()) {
+        return { acao: 'aguardar', ate: cadencia, motivo: 'sem-trava-do-kernel', fila: null,
+            detalhe: 'o arco só despacha com /usr/bin/flock: sem a trava do kernel, dois passos poderiam passar juntos dos limites' };
+    }
+    const fd = vezDeDespachar(raiz, opcoes.esperarVezMs ?? exports.ESPERA_DA_VEZ_DE_DESPACHAR_MS);
+    if (fd === null) {
+        return { acao: 'aguardar', ate: cadencia, motivo: 'despacho-em-curso', fila: null,
+            detalhe: 'outro passo de arco desta máquina segura a vez de despachar' };
+    }
+    let pendente = null;
+    try {
+        let fatos;
+        try {
+            fatos = (0, noctum_fila_1.fatosDaFila)(carregado, arco, { quando, maquina: opcoes.maquina, lerReservas: opcoes.lerReservas });
+        }
+        catch (e) {
+            // S6 do CHECK: a recusa tipada do arco (o log adulterado, por exemplo) volta como resultado, e não como exceção.
+            if (!(e instanceof noctum_envelope_1.RecusaDoArco))
+                throw e;
+            return { acao: 'aguardar', ate: cadencia, motivo: e.motivo, detalhe: e.message, fila: null };
+        }
+        const fila = (0, noctum_fila_1.montarFila)(fatos);
+        if (fila.decisao.acao === 'encerrar')
+            return { acao: 'encerrar', motivo: fila.decisao.motivo, fila };
+        if (fila.decisao.acao === 'aguardar')
+            return aguardar(fila.decisao, fila);
+        // A fila só decide despachar com o envelope v2 vigente; a guarda estreita o tipo e cobre o impossível.
+        const conteudo = fatos.estado?.conteudo;
+        if (!conteudo || !(0, noctum_envelope_1.envelopeComTrabalhos)(conteudo)) {
+            return { acao: 'aguardar', ate: cadencia, motivo: 'fonte-indisponivel', detalhe: 'o arco não tem envelope v2 vigente', fila };
+        }
+        const capacidade = (0, noctum_capacidade_1.fatosDeCapacidade)(carregado, { quando, consultar: opcoes.consultarSessoes });
+        const perfis = (opcoes.perfis ?? (() => perfisDisponiveis(raiz, Date.parse(quando))))();
+        let recusa = null;
+        let doCandidato = null;
+        for (const candidato of fila.candidatos) {
+            const fase = candidato.fase;
+            let thread, runtime;
+            try {
+                thread = candidato.thread ? (0, thread_1.lerThread)(raiz, candidato.thread) : null;
+                runtime = runtimeDaFase(carregado, thread?.modo ?? 'auto', fase);
+            }
+            catch (e) {
+                // A4 do CHECK: a thread que não se lê ou o bloco sem runtime são deste candidato; os outros seguem.
+                doCandidato = { acao: 'recusado', trabalho: candidato.id, thread: candidato.thread, fase, motivo: noctum_fila_1.MOTIVO_DO_ERRO_NO_DESPACHO,
+                    detalhe: mensagem(e), reserva: null, fila };
+                continue;
+            }
+            const doRuntime = perfis.filter(p => p.runtime === runtime).map(p => p.id);
+            // A conta com mais folga; sem folga em nenhuma, a primeira do envelope no runtime, para `admitir` dizer o motivo na
+            // ordem dele (a máquina cheia antes da conta).
+            const conta = (0, noctum_capacidade_1.escolherConta)(conteudo.capacidade, capacidade, doRuntime)
+                ?? conteudo.capacidade.porConta.find(c => doRuntime.includes(c.conta))?.conta ?? null;
+            const vaga = (0, board_1.vagaDoDespacho)(carregado, thread?.id ?? '', quando);
+            const admissao = conta === null
+                ? { ok: false, motivo: 'capacidade.conta-nao-autorizada',
+                    detalhe: `nenhuma conta do envelope é perfil disponível do runtime ${runtime}` }
+                : (0, noctum_capacidade_1.admitir)({ runtime, conta, revisao: fase === 'CHECK' }, conteudo.capacidade, capacidade, vaga);
+            if (!admissao.ok) {
+                recusa = admissao;
+                if (MOTIVOS_DE_MAQUINA.includes(admissao.motivo))
+                    break;
+                continue;
+            }
+            const r = despacharCandidato(carregado, arco, fila, { trabalho: candidato.id, thread, item: candidato.item, fase, runtime,
+                conta: conta, quando, pedido: conteudo.trabalhos.find(t => t.id === candidato.id)?.pedido ?? null }, opcoes);
+            if (r.acao === 'baseline') {
+                pendente = r;
+                break;
+            }
+            if ('seguir' in r) {
+                const { seguir: _seguir, ...recusado } = r;
+                doCandidato = recusado;
+                continue;
+            }
+            return r;
+        }
+        if (!pendente) {
+            // Sem vaga para ninguém, espera a vaga; sem vaga por erro de candidato, diz o erro.
+            if (doCandidato && !recusa)
+                return doCandidato;
+            return { acao: 'aguardar', ate: new Date(Math.min(Date.parse(quando) + 5 * 60_000, Date.parse(conteudo.janela.fim))).toISOString(),
+                motivo: recusa?.motivo ?? 'capacidade', detalhe: recusa?.detalhe ?? 'nenhum candidato coube', fila };
+        }
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    return baselineForaDaTrava(carregado, arco, pendente, cadencia, opcoes);
+}
+/**
+ * A1 do CHECK: a baseline que o despacho pediu, com a trava de despacho já solta (os outros arcos não esperam a suíte).
+ * Ela espera a fila de recursos pesados como todo verify; sem a vez, ou com a thread conduzida, o passo espera a cadência.
+ */
+function baselineForaDaTrava(carregado, arco, p, cadencia, opcoes) {
+    const conducao = { canal: (0, conducao_1.canalDoProcesso)(), correlacao: `noctum:${arco}` };
+    try {
+        (opcoes.gravarBaseline ?? ((k, t, c) => { (0, verify_1.gravarBaseline)(k, t, undefined, c, 'phase.run'); }))(carregado, p.thread, conducao);
+    }
+    catch (e) {
+        if (!(e instanceof fila_pesada_1.ErroDaFilaPesada) && !(e instanceof conducao_1.ErroDeConducao))
+            throw e;
+        return { acao: 'aguardar', ate: cadencia, motivo: 'baseline-pendente', detalhe: mensagem(e), fila: p.fila };
+    }
+    return { acao: 'aguardar', ate: new Date().toISOString(), motivo: 'baseline-gravada', fila: p.fila,
+        detalhe: `a baseline da thread ${p.thread} foi gravada fora da trava de despacho; o próximo passo confere o envelope e despacha` };
+}
+/** Reserva, abre a thread quando falta e despacha pelo núcleo; o desfecho volta ao log do arco. */
+function despacharCandidato(carregado, arco, fila, c, opcoes) {
+    const { raiz } = carregado;
+    let reserva;
+    try {
+        reserva = (opcoes.reservar ?? noctum_arco_1.reservarDespacho)(raiz, { arco, envelopeSha256: fila.envelopeSha256 ?? '', trabalho: c.trabalho,
+            thread: c.thread?.id ?? null, fase: c.fase, runtime: c.runtime, conta: c.conta, revisao: c.fase === 'CHECK' }, c.quando).seq;
+    }
+    catch (e) {
+        if (!(e instanceof noctum_envelope_1.RecusaDoArco))
+            throw e;
+        const r = { acao: 'recusado', trabalho: c.trabalho, thread: c.thread?.id ?? null, fase: c.fase, motivo: e.motivo,
+            detalhe: e.message, reserva: null, fila };
+        return RECUSAS_DO_CANDIDATO.includes(e.motivo) ? { ...r, seguir: true } : r;
+    }
+    const recusar = (motivo, detalhe, thread) => {
+        (0, noctum_arco_1.concluirDespacho)(raiz, arco, reserva, { motivo });
+        return { acao: 'recusado', trabalho: c.trabalho, thread, fase: c.fase, motivo, detalhe, reserva, fila };
+    };
+    let thread = c.thread;
+    let pedido;
+    try {
+        if (!thread) {
+            if (!c.pedido)
+                return { ...recusar('noctum.despacho.pedido-ausente', `o trabalho ${c.trabalho} não traz pedido para abrir a thread`, null), seguir: true };
+            thread = (opcoes.abrirThread ?? ((k, o) => (0, thread_1.novaThread)(k, o).thread))(carregado, { nome: `${c.item.toLowerCase()} ${c.trabalho}`,
+                modo: 'auto', roadmap: c.item, pedido: c.pedido, criarWorktree: true });
+        }
+        pedido = (0, thread_1.pedidoDaThread)(raiz, thread);
+    }
+    catch (e) {
+        // A4 do CHECK: a falha antes de lançar (abrir a thread, ler o pedido) é deste candidato: a reserva volta e o passo segue.
+        return { ...recusar(noctum_fila_1.MOTIVO_DO_ERRO_NO_DESPACHO, mensagem(e), thread?.id ?? null), seguir: true };
+    }
+    if (!pedido)
+        return { ...recusar('noctum.despacho.pedido-ausente', `a thread ${thread.id} não guardou o pedido`, thread.id), seguir: true };
+    // S5 do CHECK: a falha de dentro do núcleo pode ter aberto a sessão; ela sobe, e a reserva fica pendente e conta.
+    const antes = eventosDaThread(raiz, thread.id)?.length ?? 0;
+    const r = (opcoes.despachar ?? phase_1.rodarFase)(carregado, thread.id, { fase: c.fase, prompt: pedido.texto, perfil: c.conta,
+        canal: (0, conducao_1.canalDoProcesso)(), correlacao: `noctum:${arco}`, baselinePeloDespacho: false });
+    if (r.motivo === 'baseline.pendente') {
+        (0, noctum_arco_1.concluirDespacho)(raiz, arco, reserva, { motivo: 'baseline.pendente' });
+        return { acao: 'baseline', thread: thread.id, fila };
+    }
+    // A recusa dos portões do núcleo vem antes de chamar o runtime: nada abriu, e a sessão volta ao orçamento.
+    if (r.bloqueado)
+        return recusar(String(r.motivo ?? 'despacho.bloqueado'), r.erro ?? 'o núcleo recusou o despacho', thread.id);
+    if (r.sessionId || r.idempotente) {
+        (0, noctum_arco_1.concluirDespacho)(raiz, arco, reserva, { thread: thread.id, sessionId: r.sessionId, idempotente: r.idempotente === true });
+        return { acao: 'despachou', trabalho: c.trabalho, thread: thread.id, fase: c.fase, runtime: c.runtime, conta: c.conta,
+            sessionId: r.sessionId, idempotente: r.idempotente === true, reserva, fila };
+    }
+    // B1 da rodada 2: o núcleo chamou o runtime e voltou sem sessão. A conta, o limite de uso e o impedimento do dono recusam
+    // antes de rodar, e devolvem a sessão; mas a falha seca do runtime, o id dito antes da falha (o `claude --bg` que diz o id
+    // e sai com erro deixa a sessão aberta) e o núcleo que não diz nada deixam a reserva pendente e contada.
+    const novos = eventosDaThread(raiz, thread.id);
+    const idDaFalha = novos === null ? '(ledger ilegível)' : novos.slice(antes)
+        .filter(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.despachoFalhou && typeof e.sessionId === 'string').map(e => e.sessionId).at(-1) ?? null;
+    if (!idDaFalha && r.motivo && r.motivo !== 'runtime.unavailable')
+        return recusar(String(r.motivo), r.erro ?? 'o runtime recusou o despacho', thread.id);
+    return { acao: 'recusado', trabalho: c.trabalho, thread: thread.id, fase: c.fase, motivo: String(r.motivo ?? 'despacho.sem-sessao'),
+        detalhe: `${r.erro ?? 'o núcleo não abriu sessão'}; a sessão pode ter aberto${idDaFalha ? ` (${idDaFalha})` : ''}, e a reserva fica ` +
+            'pendente e contada até a N4 reconciliar', reserva, fila };
+}

package/dist/noctum-fila.js

@@ -0,0 +1,280 @@
+"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.
+ */
+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 });
+    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` };
+    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.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`);
+    }
+    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 bloqueado('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 bloqueado('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');
+    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');
+}
+/** 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;
+    if (estado.situacao === 'revogado' || estado.situacao === 'expirado')
+        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.
+    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;
+    }).map(t => t.id));
+    // S7 do CHECK: quem fechou sem entrega nunca mais entrega neste arco, nem quem depende dele, de qualquer distância.
+    const semSaida = new Set(conteudo.trabalhos.filter(t => {
+        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,
+        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;
+}