@orkastery/cli 0.5.3 → 0.6.0

package/dist/noctum-supervisao.js

@@ -0,0 +1,649 @@
+"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.correlacaoDoArco = exports.faseValida = exports.RecusaDaSupervisao = exports.MOTIVOS_DA_SUPERVISAO = exports.CONTRATO_SUPERVISAO = void 0;
+exports.parametrosPadrao = parametrosPadrao;
+exports.dirDaSupervisao = dirDaSupervisao;
+exports.gravarNaSupervisao = gravarNaSupervisao;
+exports.gravarComEstado = gravarComEstado;
+exports.assumirConducao = assumirConducao;
+exports.parametrosDoArco = parametrosDoArco;
+exports.lerSupervisao = lerSupervisao;
+exports.eventosDaSupervisao = eventosDaSupervisao;
+exports.retomadasDe = retomadasDe;
+exports.contaForaAgora = contaForaAgora;
+exports.threadsDoArco = threadsDoArco;
+exports.contasDoArco = contasDoArco;
+exports.alvosDaFase = alvosDaFase;
+exports.observarContas = observarContas;
+/**
+ * RM-058, fatia N4 (D1 a D4 da ork-rm058n4): os checkpoints da supervisão do arco.
+ *
+ * O histórico da supervisão mora num log append-only próprio, `.orkastery/noctum/arcos/<arco>/supervisao.jsonl`, na raiz
+ * do estado, ao lado do log do arco (N1 e N2) e com as mesmas garantias: cada linha leva o sha256 da anterior e um MAC de
+ * subchave derivada da chave local do núcleo, num domínio próprio (a chave do log do arco não serve aqui, nem o
+ * contrário). O limite também é o mesmo: a chave local é legível por qualquer processo com o mesmo usuário do sistema, que
+ * pode escrever linha nova ou truncar o log, como no ledger.
+ *
+ * O log do arco não ganha linha da supervisão (D1): a supervisão nunca autoriza, renova nem emenda o envelope, e a
+ * contabilidade da reserva continua no `concluirDespacho`. Aqui ficam as gerações de quem conduz, as batidas, os tiques do
+ * vigia, as retomadas autorizadas, as sessões paradas, as contas que o arco tirou da seleção, os trabalhos isolados, as
+ * recusas de ambiente, a parada, os efeitos de resultado incerto e os pedidos da fila de rate limit já tratados.
+ *
+ * Os parâmetros (cadência, carências, prazos e tetos) são gravados uma vez, na primeira linha (D2), e relidos dali: um
+ * processo novo, um manifesto mudado ou outra conta não mudam as regras de um arco que já começou, nem zeram nada. Nada
+ * fica em memória: toda leitura relê o disco.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const estado_thread_1 = require("./estado-thread");
+const fila_pesada_1 = require("./fila-pesada");
+const hitl_local_receipt_1 = require("./hitl-local-receipt");
+const horario_1 = require("./horario");
+const ledger_1 = require("./ledger");
+const noctum_envelope_1 = require("./noctum-envelope");
+const noctum_fila_1 = require("./noctum-fila");
+const ocupacao_1 = require("./ocupacao");
+const setup_1 = require("./setup");
+const thread_1 = require("./thread");
+const types_1 = require("./types");
+exports.CONTRATO_SUPERVISAO = 'ork.noctum-supervisao/v1';
+/** D1: tipo fechado próprio, fora do `MotivoGate` e do `MotivoDeRecusaDoArco`. */
+exports.MOTIVOS_DA_SUPERVISAO = [
+    'noctum.supervisao.adulterada', 'noctum.supervisao.invalida', 'noctum.supervisao.ocupada', 'noctum.supervisao.sem-kernel',
+];
+class RecusaDaSupervisao extends Error {
+    motivo;
+    constructor(motivo, detalhe) {
+        super(`${motivo}: ${detalhe}`);
+        this.motivo = motivo;
+        this.name = 'RecusaDaSupervisao';
+    }
+}
+exports.RecusaDaSupervisao = RecusaDaSupervisao;
+/** Os valores de partida; o teto de retomadas vem do `retry.max_tentativas` do manifesto no instante da gravação. */
+function parametrosPadrao(manifesto) {
+    return {
+        cadenciaMs: noctum_fila_1.CADENCIA_MS,
+        carenciaMs: ocupacao_1.CARENCIA_DO_TURNO_ENCERRADO_MIN * 60_000,
+        vigiaAusenteMs: 3 * noctum_fila_1.CADENCIA_MS,
+        interrupcoesQueParam: 3,
+        primeiroTurnoMs: 15 * 60_000,
+        semAvancoMs: 90 * 60_000,
+        tetoDeRetomadas: Math.max(1, manifesto.retry.max_tentativas),
+        retomadasSemPrimeiroTurno: 1,
+        recusasDeAmbienteQueParam: 2,
+        carenciaDaReservaMs: ocupacao_1.CARENCIA_DO_TURNO_ENCERRADO_MIN * 60_000,
+        leiturasDoEfeito: 2,
+        ausenciaMinimaMs: noctum_fila_1.CADENCIA_MS,
+    };
+}
+const TIPOS = ['parametros', 'conducao_assumida', 'batida', 'passo_em_espera', 'passo_recusado', 'passo_retomado',
+    'tique_iniciado', 'tique_concluido',
+    'vigia_interrompido', 'retomada_autorizada', 'sessao_parada', 'conta_fora', 'isolado', 'recusa_de_ambiente', 'parada',
+    'efeito_incerto', 'efeito_reconciliado', 'pedido_tratado'];
+const ZERO = '0'.repeat(64);
+const ARQUIVO = 'supervisao.jsonl';
+const TRAVA = 'supervisao.lock';
+/** A trava do log é curta: quem grava lê, confere e anexa algumas linhas. */
+const ESPERA_DA_TRAVA_MS = 10_000;
+const PAUSA_MS = 50;
+const sha = (s) => (0, node_crypto_1.createHash)('sha256').update(s).digest('hex');
+const objeto = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const adulterado = (detalhe) => new RecusaDaSupervisao('noctum.supervisao.adulterada', `${detalhe}; a supervisão do arco exige inspeção`);
+const dormir = (ms) => { if (ms > 0)
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, Math.ceil(ms)); };
+/** O diretório do arco na raiz do estado; a supervisão nunca o cria (o arco nasce da proposta da N1). */
+function dirDaSupervisao(raiz, arco) {
+    if (typeof arco !== 'string' || !noctum_envelope_1.ID_DO_ARCO.test(arco))
+        throw new RecusaDaSupervisao('noctum.supervisao.invalida', 'identificador de arco inválido');
+    const principal = (0, estado_thread_1.raizDoEstado)(raiz);
+    (0, estado_thread_1.exigirEstadoSemLink)(principal, ['.orkastery', 'noctum', 'arcos', arco]);
+    return path.join(principal, '.orkastery', 'noctum', 'arcos', arco);
+}
+/** Subchave própria da supervisão: o mesmo segredo do recibo local, separado por domínio do log do arco. */
+function chaveDaSupervisao(raiz, criar) {
+    return (0, node_crypto_1.createHmac)('sha256', (0, hitl_local_receipt_1.chaveLocal)(raiz, criar)).update(exports.CONTRATO_SUPERVISAO).digest();
+}
+/** Lê e confere o log inteiro; a cauda sem quebra de linha está sendo gravada e não conta. */
+function lerLog(raiz, arco) {
+    const file = path.join(dirDaSupervisao(raiz, arco), ARQUIVO);
+    let bruto;
+    try {
+        const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+        try {
+            const st = fs.fstatSync(fd);
+            if (!st.isFile() || st.nlink !== 1 || st.uid !== process.getuid?.() || (st.mode & 0o077) !== 0) {
+                throw adulterado('log da supervisão não é arquivo privado do núcleo');
+            }
+            bruto = fs.readFileSync(fd);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return { linhas: [], ultimaLinha: null, terminaEmQuebra: true, bytesCompletos: 0, bytesLidos: 0 };
+        if (e instanceof RecusaDaSupervisao)
+            throw e;
+        throw adulterado('log da supervisão ilegível');
+    }
+    const fim = bruto.lastIndexOf(0x0a) + 1;
+    const textos = bruto.subarray(0, fim).toString('utf8').split('\n').slice(0, -1);
+    const tamanhos = { terminaEmQuebra: fim === bruto.length, bytesCompletos: fim, bytesLidos: bruto.length };
+    if (!textos.length)
+        return { linhas: [], ultimaLinha: null, ...tamanhos };
+    let chave;
+    try {
+        chave = chaveDaSupervisao(raiz, false);
+    }
+    catch {
+        throw adulterado('chave do núcleo ausente para conferir o log');
+    }
+    let anterior = ZERO;
+    const linhas = textos.map((texto, i) => {
+        let l;
+        try {
+            l = JSON.parse(texto);
+        }
+        catch {
+            throw adulterado(`linha ${i + 1} não é JSON`);
+        }
+        if (!objeto(l) || Object.keys(l).sort().join(',') !== 'dados,mac' || typeof l.mac !== 'string' || !/^[a-f0-9]{64}$/.test(l.mac)) {
+            throw adulterado(`linha ${i + 1} fora do formato`);
+        }
+        const esperado = (0, node_crypto_1.createHmac)('sha256', chave).update(JSON.stringify(l.dados)).digest();
+        if (!(0, node_crypto_1.timingSafeEqual)(Buffer.from(l.mac, 'hex'), esperado))
+            throw adulterado(`linha ${i + 1} com MAC que não confere`);
+        const d = l.dados;
+        if (d.contrato !== exports.CONTRATO_SUPERVISAO || d.arco !== arco || d.seq !== i + 1 || d.anterior !== anterior) {
+            throw adulterado(`linha ${i + 1} fora da cadeia`);
+        }
+        if (!objeto(d.evento) || !TIPOS.includes(d.evento.tipo) || typeof d.em !== 'string' || !Number.isFinite(Date.parse(d.em))) {
+            throw adulterado(`linha ${i + 1} com evento desconhecido`);
+        }
+        // D2: os parâmetros são a primeira linha e só ela.
+        if ((d.evento.tipo === 'parametros') !== (i === 0))
+            throw adulterado(`linha ${i + 1}: os parâmetros são a primeira linha, e só ela`);
+        anterior = sha(texto);
+        return d;
+    });
+    return { linhas, ultimaLinha: textos.at(-1), ...tamanhos };
+}
+/**
+ * Grava uma linha, sob a trava, depois de `lerLog`. A cauda sem quebra é escrita abortada e sai antes da linha nova; a
+ * escrita curta volta o arquivo ao tamanho de antes e é acusada.
+ */
+function anexar(raiz, arco, log, evento, quando) {
+    const dados = { contrato: exports.CONTRATO_SUPERVISAO, arco, seq: log.linhas.length + 1,
+        anterior: log.ultimaLinha === null ? ZERO : sha(log.ultimaLinha), em: quando, evento };
+    const texto = JSON.stringify({ dados, mac: (0, node_crypto_1.createHmac)('sha256', chaveDaSupervisao(raiz, true)).update(JSON.stringify(dados)).digest('hex') });
+    const linha = Buffer.from(texto + '\n', 'utf8');
+    const file = path.join(dirDaSupervisao(raiz, arco), ARQUIVO);
+    const fd = fs.openSync(file, fs.constants.O_WRONLY | fs.constants.O_APPEND | fs.constants.O_CREAT | fs.constants.O_NOFOLLOW, 0o600);
+    try {
+        if (fs.fstatSync(fd).size !== log.bytesLidos)
+            throw adulterado('o log mudou entre a leitura e a escrita sob a trava');
+        if (log.bytesLidos !== log.bytesCompletos)
+            fs.ftruncateSync(fd, log.bytesCompletos);
+        const escritos = fs.writeSync(fd, linha);
+        if (escritos !== linha.length) {
+            fs.ftruncateSync(fd, log.bytesCompletos);
+            fs.fsyncSync(fd);
+            throw adulterado(`escrita curta no log (${escritos} de ${linha.length} bytes); nada foi gravado`);
+        }
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    const bytes = log.bytesCompletos + linha.length;
+    return { linhas: [...log.linhas, dados], ultimaLinha: texto, terminaEmQuebra: true, bytesCompletos: bytes, bytesLidos: bytes };
+}
+/** A trava do log: a do kernel, curta, com espera em passos. */
+function comTrava(raiz, arco, executar) {
+    if (!(0, fila_pesada_1.kernelDisponivel)())
+        throw new RecusaDaSupervisao('noctum.supervisao.sem-kernel', 'a supervisão do arco exige /usr/bin/flock');
+    const dir = dirDaSupervisao(raiz, arco);
+    if (!fs.existsSync(dir))
+        throw new RecusaDaSupervisao('noctum.supervisao.invalida', `arco ${arco} sem proposta`);
+    const prazo = Date.now() + ESPERA_DA_TRAVA_MS;
+    for (;;) {
+        const fd = (0, fila_pesada_1.tentarTravaExclusiva)(path.join(dir, TRAVA));
+        if (fd !== null) {
+            try {
+                return executar();
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+        }
+        if (Date.now() >= prazo)
+            throw new RecusaDaSupervisao('noctum.supervisao.ocupada', 'outro processo segura o log da supervisão');
+        dormir(Math.min(PAUSA_MS, prazo - Date.now()));
+    }
+}
+/**
+ * Grava eventos na supervisão do arco, na ordem, e devolve o estado relido do disco. Log vazio ganha antes a linha dos
+ * parâmetros (D2), com os valores de partida e o teto de retomadas do manifesto de agora; depois, vale o que foi gravado.
+ */
+function gravarNaSupervisao(carregado, arco, eventos, quando = new Date().toISOString()) {
+    return gravarComEstado(carregado, arco, () => eventos, quando);
+}
+/**
+ * A gravação que decide o que gravar a partir do estado lido sob a trava (a geração seguinte, o que ainda não foi
+ * gravado). O que seria gravado é conferido antes, com o estado inteiro (A4 do CHECK): uma linha que tornaria o log
+ * ilegível (uma geração fora de ordem, um efeito repetido) é recusada como inválida e não vai ao disco.
+ */
+function gravarComEstado(carregado, arco, montar, quando = new Date().toISOString()) {
+    const { raiz } = carregado;
+    return comTrava(raiz, arco, () => {
+        let log = lerLog(raiz, arco);
+        const eventos = montar(derivar(arco, log.linhas));
+        if (eventos.some(e => e.tipo === 'parametros'))
+            throw new RecusaDaSupervisao('noctum.supervisao.invalida', 'os parâmetros só a primeira gravação escreve');
+        const primeira = log.linhas.length ? [] : [{ tipo: 'parametros', parametros: parametrosPadrao(carregado.manifesto) }];
+        const novas = [...primeira, ...eventos].map((evento, i) => ({ contrato: exports.CONTRATO_SUPERVISAO, arco,
+            seq: log.linhas.length + 1 + i, anterior: '', em: quando, evento }));
+        try {
+            derivar(arco, [...log.linhas, ...novas]);
+        }
+        catch (e) {
+            if (!(e instanceof RecusaDaSupervisao))
+                throw e;
+            throw new RecusaDaSupervisao('noctum.supervisao.invalida', `a gravação deixaria o log ilegível (${e.message}); nada foi gravado`);
+        }
+        for (const e of [...primeira, ...eventos])
+            log = anexar(raiz, arco, log, e, quando);
+        const relido = lerLog(raiz, arco);
+        if (relido.linhas.length !== log.linhas.length || !relido.terminaEmQuebra)
+            throw adulterado('a gravação não ficou inteira no log');
+        return derivar(arco, relido.linhas);
+    });
+}
+/**
+ * D4 e A4 do CHECK: assume a condução com a geração seguinte, lida sob a trava do log (nunca de uma leitura de antes).
+ * Devolve o número da geração gravada.
+ */
+function assumirConducao(carregado, arco, quem, prova, quando = new Date().toISOString()) {
+    let numero = 0;
+    gravarComEstado(carregado, arco, (s) => {
+        numero = (s.geracao?.numero ?? 0) + 1;
+        return [{ tipo: 'conducao_assumida', geracao: numero, quem, prova: prova(s.geracao) }];
+    }, quando);
+    return numero;
+}
+/** Garante a linha dos parâmetros e devolve os que valem no arco. */
+function parametrosDoArco(carregado, arco, quando = new Date().toISOString()) {
+    const atual = lerSupervisao(carregado.raiz, arco);
+    if (atual.parametros)
+        return atual.parametros;
+    return gravarNaSupervisao(carregado, arco, [], quando).parametros;
+}
+/** O estado da supervisão, relido do disco. Arco sem log de supervisão devolve o estado vazio. */
+function lerSupervisao(raiz, arco) {
+    return derivar(arco, lerLog(raiz, arco).linhas);
+}
+/**
+ * RM-058, integração (T8 da ork-rm058integra, D12): os eventos do log da supervisão, conferidos como na leitura do estado,
+ * cada um com o instante dele. O aceite do piloto mede por eles a recuperação de cada falha injetada (a geração nova, a
+ * retomada, o vigia interrompido), que o estado derivado guarda só pela última.
+ */
+function eventosDaSupervisao(raiz, arco) {
+    return lerLog(raiz, arco).linhas.map(l => ({ em: l.em, evento: l.evento }));
+}
+function derivar(arco, linhas) {
+    const s = { contrato: exports.CONTRATO_SUPERVISAO, arco, linhas: linhas.length, parametros: null, geracao: null,
+        batidas: { condutor: null, vigia: null }, espera: null, recusaDoPasso: null, tiqueAberto: null, interrupcoesSeguidas: 0, retomadas: [], sessoesParadas: [],
+        contasFora: new Map(), isolados: new Map(), recusasDeAmbiente: [], parada: null, efeitos: new Map(), pedidos: new Map() };
+    for (const { evento: e, em } of linhas) {
+        switch (e.tipo) {
+            case 'parametros':
+                s.parametros = e.parametros;
+                break;
+            case 'conducao_assumida':
+                if (e.geracao !== (s.geracao?.numero ?? 0) + 1)
+                    throw adulterado(`geração ${e.geracao} fora de ordem`);
+                s.geracao = { numero: e.geracao, quem: e.quem, desde: em, prova: e.prova };
+                if (e.quem.papel === 'condutor')
+                    s.batidas.condutor = { em, quem: e.quem };
+                break;
+            case 'batida':
+                s.batidas[e.quem.papel] = { em, quem: e.quem };
+                break;
+            case 'passo_em_espera':
+                s.espera = { motivo: e.motivo, desde: em, papel: e.papel, ocupantes: e.ocupantes };
+                s.recusaDoPasso = null;
+                break;
+            case 'passo_recusado':
+                s.espera = null;
+                s.recusaDoPasso = { trabalho: e.trabalho, motivo: e.motivo, detalhe: e.detalhe, desde: em, papel: e.papel };
+                break;
+            case 'passo_retomado':
+                s.espera = null;
+                s.recusaDoPasso = null;
+                break;
+            case 'tique_iniciado':
+                s.tiqueAberto = { quem: e.quem, em };
+                s.batidas.vigia = { em, quem: e.quem };
+                break;
+            case 'tique_concluido':
+                if (s.tiqueAberto?.quem.instancia === e.quem.instancia)
+                    s.tiqueAberto = null;
+                s.interrupcoesSeguidas = 0;
+                s.batidas.vigia = { em, quem: e.quem };
+                break;
+            case 'vigia_interrompido':
+                if (s.tiqueAberto?.quem.instancia === e.interrompido)
+                    s.tiqueAberto = null;
+                s.interrupcoesSeguidas += 1;
+                break;
+            case 'retomada_autorizada':
+                s.retomadas.push({ trabalho: e.trabalho, thread: e.thread, fase: e.fase, tentativa: e.tentativa, motivo: e.motivo, sessao: e.sessao,
+                    prova: e.prova, em, aposReserva: typeof e.aposReserva === 'number' && Number.isSafeInteger(e.aposReserva) ? e.aposReserva : null });
+                break;
+            case 'sessao_parada':
+                s.sessoesParadas.push({ trabalho: e.trabalho, thread: e.thread, sessionId: e.sessionId, motivo: e.motivo, confirmada: e.confirmada === true,
+                    prova: e.prova, em });
+                break;
+            case 'conta_fora':
+                s.contasFora.set(e.conta, { conta: e.conta, runtime: e.runtime, motivo: e.motivo, ate: e.ate, prova: e.prova, em });
+                break;
+            case 'isolado':
+                // O primeiro isolamento vale: o trabalho não sai do isolamento sozinho neste arco.
+                if (!s.isolados.has(e.trabalho))
+                    s.isolados.set(e.trabalho, { trabalho: e.trabalho, thread: e.thread, motivo: e.motivo, detalhe: e.detalhe, em });
+                break;
+            case 'recusa_de_ambiente':
+                s.recusasDeAmbiente.push({ trabalho: e.trabalho, thread: e.thread, detalhe: e.detalhe, em });
+                break;
+            case 'parada':
+                if (!s.parada)
+                    s.parada = { motivo: e.motivo, detalhe: e.detalhe, em };
+                break;
+            case 'efeito_incerto':
+                if (s.efeitos.has(e.id))
+                    throw adulterado(`efeito ${e.id} registrado duas vezes`);
+                s.efeitos.set(e.id, { id: e.id, efeito: e.efeito, registradoEm: em, desfechos: [] });
+                break;
+            case 'efeito_reconciliado': {
+                const ef = s.efeitos.get(e.id);
+                if (!ef)
+                    throw adulterado(`desfecho do efeito ${e.id} sem registro`);
+                ef.desfechos.push({ desfecho: e.desfecho, prova: e.prova, em });
+                break;
+            }
+            case 'pedido_tratado':
+                s.pedidos.set(e.pedido, { thread: e.thread, acao: e.acao, motivo: e.motivo, em });
+                break;
+        }
+    }
+    return s;
+}
+/** Quantas retomadas o trabalho já teve nesta fase. É a tentativa de quem vem depois, menos um. */
+function retomadasDe(s, trabalho, fase) {
+    return s.retomadas.filter(r => r.trabalho === trabalho && r.fase === fase).length;
+}
+/** A conta que o arco tirou e que ainda está fora no instante dado: reset conhecido que passou devolve a conta. */
+function contaForaAgora(s, conta, quando) {
+    const f = s.contasFora.get(conta);
+    if (!f)
+        return null;
+    return f.ate !== null && Date.parse(f.ate) <= Date.parse(quando) ? null : f;
+}
+/** Uma fase do ciclo, para validar o que vem de fora (fixtures e ledgers). */
+const faseValida = (v) => typeof v === 'string' && types_1.FASES.includes(v);
+exports.faseValida = faseValida;
+/** As threads do arco: a de cada trabalho (a que o envelope diz, ou a que casa com o item e o sha256 do pedido) e as dos despachos. */
+function threadsDoArco(raiz, conteudo, estado) {
+    const porTrabalho = new Map();
+    const pedidos = conteudo.trabalhos.filter(t => t.pedido !== undefined);
+    const lidas = [];
+    if (pedidos.length)
+        for (const id of (0, thread_1.listarIds)(raiz)) {
+            try {
+                lidas.push((0, thread_1.lerThread)(raiz, id));
+            }
+            catch { /* ilegível: a fila diz a lacuna */ }
+        }
+    for (const t of conteudo.trabalhos) {
+        if (t.thread !== undefined) {
+            porTrabalho.set(t.id, t.thread);
+            continue;
+        }
+        const alvo = (0, noctum_envelope_1.shaDoPedido)(t.pedido);
+        const casam = lidas.filter(x => x.roadmap === t.item && x.pedido?.sha256 === alvo);
+        if (casam.length === 1)
+            porTrabalho.set(t.id, casam[0].id);
+    }
+    for (const d of estado.despachos) {
+        const th = d.threadDespachada ?? d.thread;
+        if (th && !porTrabalho.has(d.trabalho))
+            porTrabalho.set(d.trabalho, th);
+    }
+    return porTrabalho;
+}
+/** A correlação que o passo do arco grava em todo despacho dele. */
+const correlacaoDoArco = (arco) => `noctum:${arco}`;
+exports.correlacaoDoArco = correlacaoDoArco;
+/**
+ * D13: as contas que o passo pode usar. Só as do envelope (capacidade e orçamento), que o store dá como disponíveis (com o
+ * registro compartilhado da RM-040) e que o arco não tirou: a linha `conta_fora` do arco vale até o reset conhecido, e a
+ * sem reset vale pelo resto do arco. O subteto esgotado tira a conta; o teto do arco esgotado para o arco. `store` nulo é
+ * store ilegível: nenhuma conta, e a lacuna diz por quê.
+ */
+function contasDoArco(conteudo, estado, sup, store, quando) {
+    const agora = Date.parse(quando);
+    const lacunas = store ? [] : ['o store de perfis não pôde ser lido: nenhuma conta é dada como disponível'];
+    const tetoDoArco = conteudo.orcamento.arco;
+    const parada = tetoDoArco.unidade === 'sessoes' && estado.consumo.arco >= tetoDoArco.valor
+        ? { motivo: 'teto-do-arco', detalhe: `o teto do arco é de ${tetoDoArco.valor} sessoes e ${estado.consumo.arco} já foram reservadas` }
+        : null;
+    let provider = null;
+    const contas = conteudo.capacidade.porConta.map(({ conta }) => {
+        const p = store?.perfis.find(x => x.id === conta) ?? null;
+        const fora = (motivo, ate = null) => ({ conta, runtime: p?.runtime ?? null, disponivel: false, motivo, ate });
+        if (!store)
+            return fora('store-ilegivel');
+        if (!p)
+            return fora('perfil-ausente');
+        const doArco = contaForaAgora(sup, conta, quando);
+        if (doArco) {
+            if (doArco.ate === null && doArco.motivo !== 'auth')
+                lacunas.push(`conta ${conta}: reset desconhecido, fora pelo resto do arco (${doArco.prova})`);
+            return fora(doArco.motivo, doArco.ate);
+        }
+        const teto = conteudo.orcamento.porConta.find(x => x.conta === conta)?.teto;
+        if (teto?.unidade === 'sessoes' && (estado.consumo.porConta[conta] ?? 0) >= teto.valor)
+            return fora('subteto');
+        if (p.estado === 'ativo')
+            return { conta, runtime: p.runtime, disponivel: true, motivo: null, ate: null };
+        if (p.estado === 'esgotado' && p.esgotadoAte !== null && Date.parse(p.esgotadoAte) <= agora) {
+            return { conta, runtime: p.runtime, disponivel: true, motivo: null, ate: null };
+        }
+        if (p.estado === 'esgotado') {
+            // D13 (A1 do CHECK): o prazo do store pode ter sido estimado (a janela padrão), e sem a prova do arco o reset é
+            // desconhecido: lacuna. O vigia grava a conta fora do arco (`observarContas`), para valer depois que o store a devolver.
+            lacunas.push(`conta ${conta}: esgotada no store sem prova do arco do reset, fora do arco como lacuna`);
+            return fora('cota-sem-reset', null);
+        }
+        if (p.estado === 'provider-pago')
+            provider = conta;
+        return fora(p.estado);
+    });
+    // D15 (A2 do CHECK): uma conta do envelope que virou provider pago para o arco, como a recusa por custo.
+    const porCusto = provider ? { motivo: 'violacao-de-custo',
+        detalhe: `a conta ${provider} do envelope está com credencial de provider pago no store: o arco para, sem retry nem troca de conta` } : null;
+    return { perfis: contas.filter(c => c.disponivel && c.runtime).map(c => ({ id: c.conta, runtime: c.runtime })), contas, lacunas,
+        parada: parada ?? porCusto };
+}
+/**
+ * D14: os runtimes em que a fase pode sair, em ordem: o do bloco e depois a ordem de fallback do bloco (o modelo e o
+ * esforço de cada item), só os que o envelope admite (capacidade e orçamento) e com o subteto em `sessoes` ainda aberto.
+ */
+function alvosDaFase(carregado, conteudo, estado, fase, runtimeDoBloco, modo) {
+    let bloco = null;
+    try {
+        bloco = (0, setup_1.configDoBloco)((0, setup_1.lerSetup)(carregado.raiz), modo, fase);
+    }
+    catch {
+        bloco = null;
+    }
+    const doEnvelope = (r) => conteudo.capacidade.porRuntime.some(x => x.runtime === r) &&
+        conteudo.orcamento.porRuntime.some(x => x.runtime === r);
+    const aberto = (r) => {
+        const teto = conteudo.orcamento.porRuntime.find(x => x.runtime === r)?.teto;
+        return !teto || teto.unidade !== 'sessoes' || (estado.consumo.porRuntime[r] ?? 0) < teto.valor;
+    };
+    const lista = [{ runtime: runtimeDoBloco }, ...(0, setup_1.alvosDaOrdemDeFallback)(bloco?.fallback, runtimeDoBloco)
+            .map(a => ({ runtime: a.runtime, model: a.model, ...(a.effort ? { effort: a.effort } : {}) }))];
+    const vistos = new Set();
+    return lista.filter(a => { if (vistos.has(a.runtime))
+        return false; vistos.add(a.runtime); return doEnvelope(a.runtime) && aberto(a.runtime); });
+}
+/** O id do perfil de um evento de despacho (o `perfil` gravado pelo `phase run`: objeto com `id`, ou o id). */
+function perfilDoEvento(e) {
+    const p = e.perfil;
+    if (typeof p === 'string')
+        return p;
+    if (objeto(p) && typeof p.id === 'string')
+        return p.id;
+    return null;
+}
+/**
+ * D13 e D15: o que o arco sabe das contas, desde a autorização. Dos despachos do arco: a cota esgotada com o reset dito
+ * (fora até ele), a cota sem reset dito (fora pelo resto do arco), o login perdido e o limite de uso transitório (até o
+ * `liberaEm` do pedido da fila durável, dito ou estimado, como a fila B3). Da sessão do arco que viu a cota no meio do
+ * turno (`runtime_quota_detected`), o mesmo. Do store (A1 do CHECK): a conta esgotada sem a prova do arco do reset, e a
+ * sem login, ficam fora do arco, porque o reset é desconhecido e o login só o dono refaz. Devolve as linhas `conta_fora`
+ * novas (a decisão já gravada não se repete) e a parada por violação de custo, quando o núcleo recusou um despacho do
+ * arco por provider pago.
+ */
+function observarContas(raiz, arco, conteudo, estado, sup, store, quando) {
+    const desde = Date.parse(estado.autorizadoPor?.recebidoEm ?? conteudo.janela.inicio);
+    const agora = Date.parse(quando);
+    const correlacao = (0, exports.correlacaoDoArco)(arco);
+    // A falha mais nova de cada conta decide, entre todas as threads do arco.
+    const decisoes = new Map();
+    const decidir = (conta, evento, em) => {
+        if (!((decisoes.get(conta)?.em ?? -Infinity) > em))
+            decisoes.set(conta, { evento, em });
+    };
+    let parada = null;
+    for (const thread of new Set(threadsDoArco(raiz, conteudo, estado).values())) {
+        let eventos;
+        try {
+            eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, thread));
+        }
+        catch {
+            continue;
+        }
+        const sessoesDoArco = new Set(eventos.filter(e => e.tipo === 'phase_dispatch' && e.correlacao === correlacao).map(e => e.sessionId));
+        eventos.forEach((e, i) => {
+            if (!(Date.parse(e.ts) >= desde))
+                return;
+            if (e.tipo === 'runtime_quota_detected' && typeof e.sessionId === 'string' && sessoesDoArco.has(e.sessionId)) {
+                const conta = perfilDoEvento(e);
+                if (!conta)
+                    return;
+                const reset = typeof e.resetEm === 'string' && Date.parse(e.resetEm) > Date.parse(e.ts) ? e.resetEm : null;
+                decidir(conta, { tipo: 'conta_fora', conta, runtime: typeof e.runtime === 'string' ? e.runtime : '', motivo: reset ? 'cota' : 'cota-sem-reset',
+                    ate: reset, prova: `${thread}: runtime_quota_detected ${String(e.eventId ?? '')} da sessão ${e.sessionId}` }, Date.parse(e.ts));
+                return;
+            }
+            if (e.tipo !== 'phase_dispatch_failed' || e.correlacao !== correlacao)
+                return;
+            const conta = perfilDoEvento(e);
+            const runtime = typeof e.runtime === 'string' ? e.runtime : '';
+            // O que o núcleo gravou logo depois desta falha, até o próximo despacho: o gate tipado e o pedido da fila durável.
+            const depois = [];
+            for (const x of eventos.slice(i + 1)) {
+                if (x.tipo === 'phase_dispatch' || x.tipo === 'phase_dispatch_failed' || x.tipo === 'phase_prompt_recorded')
+                    break;
+                depois.push(x);
+            }
+            const gate = depois.find(x => x.tipo === 'gate_blocked');
+            const falha = objeto(gate?.falhaDeConta) ? gate.falhaDeConta : null;
+            const prova = `${thread}: ${gate ? `gate_blocked ${String(gate.motivo)}` : 'phase_dispatch_failed'} ${String((gate ?? e).eventId ?? '')}`.trim();
+            if (gate?.motivo === 'cost.violation') {
+                parada ??= { motivo: 'violacao-de-custo', detalhe: `o núcleo recusou um despacho do arco por custo (${prova}); sem retry nem troca de conta` };
+                return;
+            }
+            if (!conta)
+                return;
+            const fila = depois.find(x => x.tipo === 'rate_limit_queued');
+            const em = Date.parse(e.ts);
+            if (falha?.motivo === 'runtime.quota-exhausted') {
+                const reset = typeof falha.resetEm === 'string' && Date.parse(falha.resetEm) > Date.parse(e.ts) ? falha.resetEm : null;
+                decidir(conta, { tipo: 'conta_fora', conta, runtime, motivo: reset ? 'cota' : 'cota-sem-reset', ate: reset, prova }, em);
+            }
+            else if (falha?.motivo === 'runtime.auth-missing') {
+                decidir(conta, { tipo: 'conta_fora', conta, runtime, motivo: 'auth', ate: null, prova }, em);
+            }
+            else if (fila && typeof fila.liberaEm === 'string') {
+                decidir(conta, { tipo: 'conta_fora', conta, runtime, motivo: 'limite-de-uso', ate: fila.liberaEm,
+                    prova: `${thread}: rate_limit_queued ${String(fila.pedido ?? '')} (${fila.janelaEstimada === true ? 'janela estimada' : 'hora dita pelo runtime'})` }, em);
+            }
+        });
+    }
+    // A1 do CHECK: o que só o store sabe, sem decisão do arco valendo agora. A decisão do arco que já venceu (a cota com o
+    // reset dito no passado) não segura a do store (NS4 da rodada 2): senão a janela estimada do store voltaria a valer.
+    const valendo = (d) => !!d && (d.evento.ate === null || Date.parse(d.evento.ate) > agora);
+    for (const { conta } of conteudo.capacidade.porConta) {
+        const p = store?.perfis.find(x => x.id === conta);
+        if (!p || valendo(decisoes.get(conta)) || contaForaAgora(sup, conta, quando))
+            continue;
+        if (p.estado === 'esgotado' && p.esgotadoAte !== null && Date.parse(p.esgotadoAte) > agora) {
+            decisoes.set(conta, { em: agora, evento: { tipo: 'conta_fora', conta, runtime: p.runtime, motivo: 'cota-sem-reset', ate: null,
+                    prova: `o store de perfis dá a conta como esgotada até ${(0, horario_1.formatarDataHora)(p.esgotadoAte)}, prazo que pode ser estimado: sem a prova do arco, ` +
+                        'o reset é desconhecido' } });
+        }
+        else if (p.estado === 'sem-auth') {
+            decisoes.set(conta, { em: agora, evento: { tipo: 'conta_fora', conta, runtime: p.runtime, motivo: 'auth', ate: null,
+                    prova: 'o store de perfis dá a conta sem login: só o dono refaz o login' } });
+        }
+    }
+    // RA1 da rodada 3: a decisão que já venceu (a cota com o reset dito no passado) não se grava: senão ela trocaria, tique
+    // sim, tique não, a decisão do store gravada depois dela.
+    const eventos = [...decisoes.values()].map(d => d.evento)
+        .filter(d => d.ate === null || Date.parse(d.ate) > agora)
+        .filter(d => {
+        const atual = sup.contasFora.get(d.conta);
+        return !atual || atual.motivo !== d.motivo || atual.ate !== d.ate || atual.prova !== d.prova;
+    });
+    return { eventos, parada };
+}