@orkastery/cli 0.5.1 → 0.5.6

package/dist/noctum-capacidade.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fatosDeCapacidade = fatosDeCapacidade;
+exports.admitir = admitir;
+exports.escolherConta = escolherConta;
+const conducao_1 = require("./conducao");
+const ledger_1 = require("./ledger");
+const ocupacao_1 = require("./ocupacao");
+const sessoes_contas_1 = require("./sessoes-contas");
+const thread_1 = require("./thread");
+const TERMINAIS = ['done', 'completed', 'exited', 'stopped', 'failed'];
+/** O runtime mostra a sessão trabalhando agora: o claude-bg diz `running` ou `busy` (o watcher chama de `working`). */
+const TRABALHANDO = ['running', 'busy', 'working'];
+const estadoDe = (s) => String(s.state ?? s.status ?? '').trim().toLowerCase();
+/**
+ * O runtime prova que a sessão do lease acabou? Presente com estado terminal ou fantasma, sim. Ausente, só no
+ * claude-bg (o `claude agents` lista as sessões que o daemon da conta mantém), com todas as fontes lidas e a conta
+ * dela entre as consultadas. O codex lista só rollouts recentes: ausência lá não prova nada.
+ */
+function encerradaPeloRuntime(dono, leitura, porSessao, semLacuna) {
+    const vista = porSessao.get(dono.sessionId);
+    if (vista)
+        return vista.fantasma || TERMINAIS.includes(estadoDe(vista));
+    if (!semLacuna || dono.runtime !== 'claude-bg')
+        return false;
+    return leitura.contas.some(c => c.runtime === 'claude-bg' && (c.perfil?.id ?? null) === dono.perfil);
+}
+/**
+ * A ocupação desta máquina agora, relida a cada chamada. `consultar` é dependência dos testes; sem ela, as sessões de
+ * todas as contas pelo `consultarContas`, a mesma leitura do escalonador.
+ */
+function fatosDeCapacidade(carregado, opcoes = {}) {
+    const quando = opcoes.quando ?? new Date().toISOString();
+    const { raiz, manifesto } = carregado;
+    const staleMin = manifesto.concurrency.stale_after_min;
+    const leitura = (opcoes.consultar ?? (() => (0, sessoes_contas_1.consultarContas)(raiz, { staleMin })))();
+    const lacunas = leitura.fontes.filter(f => !f.ok).map(f => `${f.origem}: ${f.detalhe}`);
+    const porSessao = new Map(leitura.sessoes.map(s => [s.sessionId, s]));
+    const ocupantes = [];
+    const encerradasPeloRuntime = [];
+    const contadas = new Set();
+    // A sessão que a regra da vaga solta (turno encerrado, espera do dono, parada) não volta pela lista do runtime,
+    // a não ser que o runtime a mostre trabalhando agora (A8 do CHECK): a regra da vaga lê só o ledger.
+    const soltas = new Set();
+    for (const id of (0, thread_1.listarIds)(raiz)) {
+        let atual = null;
+        try {
+            atual = (0, conducao_1.conducaoDaThread)(raiz, id);
+        }
+        catch {
+            continue;
+        }
+        if (!atual)
+            continue;
+        if (atual.dono.tipo === 'processo' && (atual.operacao === 'phase.run' || atual.operacao === 'retry.run')) {
+            ocupantes.push({ sessionId: null, thread: id, runtime: null, conta: null, revisao: atual.fase === 'CHECK', origem: 'despacho' });
+            continue;
+        }
+        if (atual.dono.tipo !== 'sessao')
+            continue;
+        const dono = atual.dono;
+        const vista = porSessao.get(dono.sessionId);
+        try {
+            if ((0, ocupacao_1.sessaoLivreDaVaga)((0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, id)), atual.desde, quando, staleMin, dono.sessionId) &&
+                !(vista?.viva && TRABALHANDO.includes(estadoDe(vista)))) {
+                soltas.add(dono.sessionId);
+                continue;
+            }
+        }
+        catch { /* ledger ilegível: a condução viva continua contando, como no portão do phase run */ }
+        if (encerradaPeloRuntime(dono, leitura, porSessao, lacunas.length === 0)) {
+            encerradasPeloRuntime.push(dono.sessionId);
+            continue;
+        }
+        contadas.add(dono.sessionId);
+        // A5 do CHECK: o despacho sem `--perfil` grava o lease sem conta; a conta é a que o runtime atribui à sessão.
+        ocupantes.push({ sessionId: dono.sessionId, thread: id, runtime: dono.runtime, conta: dono.perfil ?? vista?.perfil ?? null,
+            revisao: atual.fase === 'CHECK', origem: 'conducao' });
+    }
+    for (const s of leitura.sessoes) {
+        if (!s.viva || contadas.has(s.sessionId) || soltas.has(s.sessionId) || encerradasPeloRuntime.includes(s.sessionId))
+            continue;
+        contadas.add(s.sessionId);
+        ocupantes.push({ sessionId: s.sessionId, thread: null, runtime: s.runtime, conta: s.perfil, revisao: false, origem: 'runtime' });
+    }
+    return { quando, ocupantes, lacunas, encerradasPeloRuntime };
+}
+const limiteDe = (lista, chave, nome) => lista.find(x => x[chave] === nome)?.sessoes ?? null;
+/**
+ * Cabe mais esta sessão? Todos os limites ao mesmo tempo, na ordem: leitura completa, conta e runtime autorizados,
+ * o projeto (o portão do `phase run`, que o chamador consulta para a thread), a máquina, a margem de revisão (a
+ * execução não usa os slots reservados ao CHECK), a conta e o runtime.
+ */
+function admitir(pedido, limites, fatos, vagaDoProjeto) {
+    if (fatos.lacunas.length) {
+        return { ok: false, motivo: 'capacidade.fonte-indisponivel', detalhe: `sessões sem leitura: ${fatos.lacunas.join('; ')}` };
+    }
+    const limiteDoRuntime = limiteDe(limites.porRuntime, 'runtime', pedido.runtime);
+    if (limiteDoRuntime === null) {
+        return { ok: false, motivo: 'capacidade.runtime-nao-autorizado', detalhe: `o runtime ${pedido.runtime} não está no envelope` };
+    }
+    const limiteDaConta = limiteDe(limites.porConta, 'conta', pedido.conta);
+    if (limiteDaConta === null) {
+        return { ok: false, motivo: 'capacidade.conta-nao-autorizada', detalhe: `a conta ${pedido.conta} não está no envelope` };
+    }
+    if (vagaDoProjeto)
+        return { ok: false, motivo: 'capacidade.projeto', detalhe: vagaDoProjeto.detalhe };
+    const total = fatos.ocupantes.length;
+    if (total >= limites.maquina) {
+        return { ok: false, motivo: 'capacidade.maquina', detalhe: `${total} sessão(ões) nesta máquina e o limite do envelope é ${limites.maquina}` };
+    }
+    const execucao = fatos.ocupantes.filter(o => !o.revisao).length;
+    if (!pedido.revisao && execucao >= limites.maquina - limites.revisao) {
+        return { ok: false, motivo: 'capacidade.revisao', detalhe: `${execucao} sessão(ões) de execução e ${limites.revisao} slot(s) ` +
+                `reservado(s) à revisão de ${limites.maquina}: só o CHECK usa o que sobra` };
+    }
+    const naConta = fatos.ocupantes.filter(o => o.conta === pedido.conta).length;
+    if (naConta >= limiteDaConta) {
+        return { ok: false, motivo: 'capacidade.conta', detalhe: `${naConta} sessão(ões) na conta ${pedido.conta} e o limite é ${limiteDaConta}` };
+    }
+    const noRuntime = fatos.ocupantes.filter(o => o.runtime === pedido.runtime).length;
+    if (noRuntime >= limiteDoRuntime) {
+        return { ok: false, motivo: 'capacidade.runtime', detalhe: `${noRuntime} sessão(ões) no ${pedido.runtime} e o limite é ${limiteDoRuntime}` };
+    }
+    return { ok: true };
+}
+/**
+ * A conta do despacho: entre as do envelope que são perfis do runtime (`perfisDoRuntime`, do store de contas), a com
+ * mais folga no limite dela; empate pela ordem do envelope. `null` quando nenhuma tem vaga.
+ */
+function escolherConta(limites, fatos, perfisDoRuntime) {
+    let melhor = null;
+    for (const { conta, sessoes } of limites.porConta) {
+        if (!perfisDoRuntime.includes(conta))
+            continue;
+        const folga = sessoes - fatos.ocupantes.filter(o => o.conta === conta).length;
+        if (folga > 0 && (!melhor || folga > melhor.folga))
+            melhor = { conta, folga };
+    }
+    return melhor?.conta ?? null;
+}