@orkastery/cli 0.5.0 → 0.5.3

package/dist/session-watcher-claude.js

@@ -38,6 +38,7 @@ exports.normalizarNativo = normalizarNativo;
 exports.stopCorrelacionado = stopCorrelacionado;
 exports.bloqueioPendente = bloqueioPendente;
 exports.classificarSessaoClaude = classificarSessaoClaude;
+exports.ultimoErroDeApi = ultimoErroDeApi;
 exports.falhaDeContaDaTranscricao = falhaDeContaDaTranscricao;
 exports.comFalhaDeConta = comFalhaDeConta;
 exports.processoNativo = processoNativo;
@@ -268,22 +269,27 @@ function textoDoErroDeApi(e) {
     const codigo = typeof e.error === 'string' ? e.error : '';
     return (0, hitl_1.redigirSegredos)([codigo, textos.filter(Boolean).join(' ')].filter(Boolean).join(': ')).slice(0, 4096);
 }
+const UUID = /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i;
+/** A transcricao da sessao no diretorio do perfil (ou no implicito, sem perfil); `null` com sessao que nao e uuid. */
+function arquivoDaTranscricao(perfil, cwd, sessionId) {
+    if (!UUID.test(sessionId))
+        return null;
+    return path.join((0, runtime_profiles_1.diretorioEfetivo)('claude-bg', perfil), 'projects', path.resolve(cwd).replace(/[^a-zA-Z0-9-]/g, '-'), `${sessionId}.jsonl`);
+}
 /**
- * I-33 (D11b): falha de conta registrada pelo proprio Claude Code na transcricao da sessao, no
- * diretorio do perfil (ou no implicito, sem perfil). So entram linhas marcadas como erro de API
- * (`isApiErrorMessage` ou campo `error`): texto do agente nunca vira motivo. Leitura limitada
- * da cauda, sem seguir link; ausencia de transcricao e ausencia de evidencia. Vale o ULTIMO erro de API
- * (N3), o que encerrou a sessao. O codigo `rate_limit`
- * do Claude Code cobre tanto o limite do plano quanto o 429 transitorio ("Request rejected (429)",
- * "not your usage limit"): quem separa e o criterio unico da D16 (`naturezaDoLimite`), pela frase.
+ * I-33 (D11b): o erro de API que o proprio Claude Code gravou na transcricao da sessao. So entram linhas marcadas
+ * como erro de API (`isApiErrorMessage` ou campo `error`): texto do agente nunca vira motivo. Leitura limitada da
+ * cauda, sem seguir link; ausencia de transcricao e ausencia de evidencia. Vale o ULTIMO erro de API (N3), o que
+ * encerrou a sessao. RM-037 (fatia 5): com ele vem o instante da linha, que e a ancora da hora dita.
  */
-function falhaDeContaDaTranscricao(perfil, cwd, sessionId, agoraMs = Date.now()) {
-    if (!/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(sessionId))
+function ultimoErroDeApi(perfil, cwd, sessionId) {
+    const arquivo = arquivoDaTranscricao(perfil, cwd, sessionId);
+    if (!arquivo)
         return null;
-    const arquivo = path.join((0, runtime_profiles_1.diretorioEfetivo)('claude-bg', perfil), 'projects', path.resolve(cwd).replace(/[^a-zA-Z0-9-]/g, '-'), `${sessionId}.jsonl`);
     let fd;
+    // O_NONBLOCK: um FIFO no lugar da transcricao nao trava o observador no open (sugestao da rodada 1 do CHECK).
     try {
-        fd = fs.openSync(arquivo, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+        fd = fs.openSync(arquivo, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
     }
     catch {
         return null;
@@ -300,7 +306,7 @@ function falhaDeContaDaTranscricao(perfil, cwd, sessionId, agoraMs = Date.now())
     finally {
         fs.closeSync(fd);
     }
-    const erros = [];
+    let ultimo = null;
     for (const linha of cauda.split('\n')) {
         let e;
         try {
@@ -311,14 +317,82 @@ function falhaDeContaDaTranscricao(perfil, cwd, sessionId, agoraMs = Date.now())
         }
         if (!e || typeof e !== 'object' || (e.isApiErrorMessage !== true && e.error === undefined))
             continue;
-        erros.push(textoDoErroDeApi(e));
+        const ms = typeof e.timestamp === 'string' ? Date.parse(e.timestamp) : NaN;
+        ultimo = { texto: textoDoErroDeApi(e), em: Number.isFinite(ms) ? new Date(ms).toISOString() : null,
+            uuid: typeof e.uuid === 'string' && UUID.test(e.uuid) ? e.uuid.toLowerCase() : null };
     }
-    if (!erros.length)
-        return null;
-    // I-33 (N3): o criterio roda sobre o erro que encerrou a sessao (o ultimo erro de API), nunca sobre os
-    // anteriores juntos: um 429 transitorio do meio nao esconde o limite que matou a sessao, e um
-    // esgotamento ja superado nao tira o perfil do rodizio por causa de um 429 transitorio no fim.
-    return (0, claude_bg_1.parseFalhaDeConta)(erros[erros.length - 1], agoraMs);
+    return ultimo;
+}
+/**
+ * I-33 (D11b): falha de conta registrada pelo Claude Code na transcricao da sessao. O codigo `rate_limit` do
+ * Claude Code cobre tanto o limite do plano quanto o 429 transitorio ("Request rejected (429)", "not your usage
+ * limit"): quem separa e o criterio unico da D16 (`naturezaDoLimite`), pela frase. I-33 (N3): o criterio roda
+ * sobre o erro que encerrou a sessao, nunca sobre os anteriores juntos. RM-037 (fatia 5): a hora dita e ancorada
+ * no instante da mensagem; sem instante na linha, no relogio de quem le, como antes.
+ */
+function falhaDeContaDaTranscricao(perfil, cwd, sessionId, agoraMs = Date.now()) {
+    return falhaDoErro(ultimoErroDeApi(perfil, cwd, sessionId), agoraMs);
+}
+function falhaDoErro(erro, agoraMs) {
+    return erro ? (0, claude_bg_1.parseFalhaDeConta)(erro.texto, erro.em ? Date.parse(erro.em) : agoraMs) : null;
+}
+/**
+ * RM-037 (fatia 5): a cota vista com a sessao viva. Em 02/10/2026 as sessoes de uma conta pararam as 06:00Z no
+ * limite de gasto ("your session limit resets 4:40am (<fuso>)"), sem Stop e com o processo vivo por mais uma
+ * hora; o perfil so saiu do rodizio as 07:15Z, quando o processo morreu, e o redespacho das 06:14Z caiu na mesma
+ * conta. Aqui, a cada volta com a transcricao maior que na anterior, o ultimo erro de API depois do despacho passa
+ * pelo criterio unico da D16; esgotamento com prazo futuro marca o perfil ate a hora dita (ou a janela padrao
+ * contada da mensagem) e grava `runtime_quota_detected` uma vez por erro. A fase nao fecha e a conducao nao muda:
+ * a sessao continua viva, e o fecho segue o caminho de sempre, sem marcar de novo o mesmo erro.
+ */
+function cotaAoVivo(ctx, perfil, cwd, cursor, erroDaTranscricao, gravar) {
+    const { sessao, dir } = ctx;
+    const arquivo = arquivoDaTranscricao(perfil, cwd, sessao.sessionId);
+    let tamanho;
+    try {
+        const st = arquivo ? fs.lstatSync(arquivo) : null;
+        // Link, FIFO ou diretorio no lugar da transcricao nao e transcricao: nada a ler.
+        tamanho = st?.isFile() ? st.size : NaN;
+    }
+    catch {
+        return;
+    }
+    if (!Number.isFinite(tamanho) || cursor.transcricaoBytes === tamanho)
+        return;
+    cursor.transcricaoBytes = tamanho;
+    const erro = erroDaTranscricao();
+    const erroMs = erro?.em ? Date.parse(erro.em) : NaN;
+    // Linha sem instante, ou de antes deste despacho (sessao retomada), nao prova que a cota e deste turno.
+    if (!erro || !Number.isFinite(erroMs) || erroMs < Date.parse(sessao.despachadaEm))
+        return;
+    const falha = falhaDoErro(erro, ctx.agoraMs);
+    if (falha?.motivo !== 'runtime.quota-exhausted' || !ctx.carregado)
+        return;
+    const esgotadoAte = (0, ratelimit_1.prazoDaCotaVista)(ctx.carregado.manifesto, falha, erroMs, ctx.agoraMs);
+    if (!esgotadoAte)
+        return;
+    // A chave do erro: o uuid da linha ou, sem ele, o instante e o trecho (dado de maquina, nunca texto).
+    const sensorEventId = (0, node_crypto_1.createHash)('sha256')
+        .update(JSON.stringify([sessao.sessionId, sessao.despachadaEm, erro.uuid ?? [erro.em, falha.trecho]])).digest('hex');
+    (0, session_events_1.comLockDeSessao)(dir, () => {
+        if ((0, ledger_1.lerLedger)(dir).some(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.cotaVistaNaTranscricao && e.sensorEventId === sensorEventId))
+            return;
+        if (perfil) {
+            try {
+                (0, ratelimit_1.marcarContaDaFalha)(ctx.carregado, perfil, falha, ctx.agoraMs, esgotadoAte);
+            }
+            catch {
+                // Store ocupado ou invalido: a proxima volta le a transcricao de novo e tenta outra vez.
+                delete cursor.transcricaoBytes;
+                return;
+            }
+        }
+        gravar(ledger_1.TIPOS_DE_EVENTO.cotaVistaNaTranscricao, { fase: sessao.fase, sessionId: sessao.sessionId, despachoEm: sessao.despachadaEm,
+            runtime: 'claude-bg', sensorEventId, motivo: falha.motivo, erroEm: erro.em, resetEm: falha.resetEm, fonteDoPrazo: falha.fonte,
+            // O trecho ja vem redigido e numa linha; sem controle, como no store de perfis.
+            esgotadoAte, trecho: falha.trecho.replace(/\p{Cc}/gu, ' '), perfil: perfil ? { id: perfil.id, runtime: perfil.runtime } : null,
+            perfilMarcado: !!perfil, origem: 'sessions.watch' });
+    });
 }
 /**
  * I-33 (D11): precedencia entre a prova da I-34 e a falha de conta. Com Stop correlacionado vale
@@ -360,8 +434,10 @@ function estadoDoArtefato(raiz, threadId, arquivo) {
     const file = path.join((0, thread_1.dirThread)(raiz, threadId), arquivo);
     const vazio = { sha256: null, mtimeMs: null, texto: null };
     let fd;
+    // RM-037 (fatia 5, sugestao da rodada 2 do CHECK): O_NONBLOCK, como na transcricao, para um FIFO no lugar do
+    // artefato nao travar o observador no open; o `isFile` abaixo o recusa.
     try {
-        fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+        fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
     }
     catch (erro) {
         return erro.code === 'ENOENT' ? vazio : { ...vazio, invalido: true };
@@ -600,9 +676,13 @@ function observarClaudeSobLock(ctx) {
     const registro = consulta.ok ? consulta.registros.find(s => s.sessionId === sessao.sessionId && s.cwd === fonte.cwd) ?? null : null;
     const artefato = saidaDoArtefato(raiz, thread.id, sessao, fonte, eventos);
     let prova;
+    // RM-037 (fatia 5): o ultimo erro de API da transcricao, lido no maximo uma vez por volta, serve a cota ao vivo
+    // e ao fecho.
+    let erroLido;
+    const erroDaTranscricao = () => erroLido !== undefined ? erroLido : (erroLido = ultimoErroDeApi(perfil, fonte.cwd, sessao.sessionId));
     const { c, falha } = comFalhaDeConta(classificarSessaoClaude({ sessao, eventos, consulta, registro, cursor, agoraMs: ctx.agoraMs,
         limiteMs: ctx.limiteMs, pausaAoFim: (0, thread_1.pausaNaThread)(thread, sessao.fase),
-        prova: () => prova ??= provaDoOrk(raiz, thread.id, sessao, eventos, fonte), processo: processoNativo }), () => falhaDeContaDaTranscricao(perfil, fonte.cwd, sessao.sessionId, ctx.agoraMs));
+        prova: () => prova ??= provaDoOrk(raiz, thread.id, sessao, eventos, fonte), processo: processoNativo }), () => falhaDoErro(erroDaTranscricao(), ctx.agoraMs));
     (0, codex_runner_1.gravarAtomico)(arquivoCursor, cursor);
     // GO-FIX 3 (achado 1): cursor gravado numa thread que sumiu durante a consulta é desfeito aqui;
     // as pastas criadas pela observação, pelo `session-watcher`.
@@ -610,6 +690,12 @@ function observarClaudeSobLock(ctx) {
         fs.rmSync(arquivoCursor, { force: true });
         throw new Error(exports.THREAD_REMOVIDA);
     }
+    if (!c.terminal) {
+        const lidos = cursor.transcricaoBytes;
+        cotaAoVivo(ctx, perfil, fonte.cwd, cursor, erroDaTranscricao, gravar);
+        if (cursor.transcricaoBytes !== lidos)
+            (0, codex_runner_1.gravarAtomico)(arquivoCursor, cursor);
+    }
     if (!c.terminal && c.inconclusivo)
         return (0, session_events_1.comLockDeSessao)(dir, () => {
             const diagnosticoId = `${resultadoId}:inconclusivo`;
@@ -649,8 +735,12 @@ function observarClaudeSobLock(ctx) {
             observadoEm, gate: 'phase.dispatch', origem: 'sessions.watch' };
         if (!atuais.some(e => e.tipo === c.classificacao && e.sensorResultId === resultadoId))
             gravar(c.classificacao, dados);
-        // I-33 (D12): o perfil sai do rodizio na primeira gravacao do resultado, onde a evidencia esta.
-        if (falha && perfil && ctx.carregado && !atuais.some(e => e.tipo === 'phase_result' && e.sensorResultId === resultadoId)) {
+        // I-33 (D12): o perfil sai do rodizio na primeira gravacao do resultado, onde a evidencia esta. RM-037 (fatia 5):
+        // o erro que a cota ao vivo ja marcou nao marca de novo; depois do prazo dito, marcar de novo tiraria do
+        // rodizio uma conta que ja voltou.
+        const jaVista = !!erroLido?.em && atuais.some(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.cotaVistaNaTranscricao &&
+            e.sessionId === sessao.sessionId && e.despachoEm === sessao.despachadaEm && e.erroEm === erroLido.em);
+        if (falha && perfil && ctx.carregado && !jaVista && !atuais.some(e => e.tipo === 'phase_result' && e.sensorResultId === resultadoId)) {
             try {
                 (0, ratelimit_1.marcarContaDaFalha)(ctx.carregado, perfil, falha, ctx.agoraMs);
             }

package/dist/sessoes-contas.js

@@ -0,0 +1,187 @@
+"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.pidVivo = pidVivo;
+exports.ehFantasma = ehFantasma;
+exports.contasDeSessoes = contasDeSessoes;
+exports.consultarContas = consultarContas;
+exports.estadosNasContas = estadosNasContas;
+exports.sessoesVivasPorPerfil = sessoesVivasPorPerfil;
+/**
+ * RM-056 (D4, D5): as sessoes desta maquina em TODAS as contas que o `ork` conhece.
+ *
+ * O `claude agents` e o `~/.codex/sessions` so respondem pela conta do ambiente de quem consulta:
+ * com perfis (`ork accounts`), uma sessao despachada pelo perfil X so aparece consultando com o
+ * `CLAUDE_CONFIG_DIR`/`CODEX_HOME` de X. Aqui a consulta passa pela conta do processo e por cada
+ * perfil do store, sem repetir diretorio, e cada sessao volta com o id do perfil dela (nunca o
+ * diretorio nem nada de dentro dele).
+ *
+ * Fantasma (D5): sessao claude-bg com estado nao terminal sem pid, ou com pid sem processo. O
+ * `claude agents` guarda o registro, mas nao ha quem trabalhe: ela nao ocupa vaga, e
+ * `ork sessions limpar-fantasmas` solta o vinculo do `ork` sem tocar no runtime.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const claude_bg_1 = require("./adapters/claude-bg");
+const codex_1 = require("./adapters/codex");
+const runtime_profiles_1 = require("./runtime-profiles");
+const TERMINAIS = ['done', 'completed', 'exited', 'stopped', 'failed'];
+const estadoDe = (s) => String(s.state ?? s.status ?? '').trim().toLowerCase();
+/** O processo existe? `EPERM` e processo de outro usuario: existe. */
+function pidVivo(pid) {
+    if (typeof pid !== 'number' || !Number.isSafeInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === 'EPERM';
+    }
+}
+/** D5: fantasma e so claude-bg (o codex nao expoe pid na fonte), em estado nao terminal. */
+function ehFantasma(runtime, s, vivo = pidVivo) {
+    return runtime === 'claude-bg' && !TERMINAIS.includes(estadoDe(s)) && !vivo(s.pid);
+}
+const real = (dir) => { try {
+    return fs.realpathSync(dir);
+}
+catch {
+    return path.resolve(dir);
+} };
+/**
+ * D4: as contas a consultar. Os perfis do store vem primeiro (inclusive desativado, que ainda pode
+ * ter sessao viva), para a sessao levar o id do perfil quando a conta do processo e a mesma pasta.
+ */
+function contasDeSessoes(raiz, env = process.env) {
+    const contas = [], fontes = [];
+    const vistos = new Set();
+    const incluir = (runtime, perfil, dir) => {
+        const chave = `${runtime}:${real(dir)}`;
+        if (vistos.has(chave))
+            return;
+        vistos.add(chave);
+        contas.push({ runtime, perfil, dir });
+    };
+    if (raiz) {
+        try {
+            for (const p of (0, runtime_profiles_1.lerPerfis)(raiz).perfis) {
+                const d = (0, runtime_profiles_1.perfilDeDespacho)(p);
+                incluir(d.runtime, d, (d.configDir ?? d.codexHome));
+            }
+        }
+        catch (e) {
+            fontes.push({ origem: 'perfis de conta (ork accounts)', ok: false, detalhe: e.message });
+        }
+    }
+    for (const runtime of runtime_profiles_1.RUNTIMES_COM_PERFIL)
+        incluir(runtime, null, (0, runtime_profiles_1.diretorioImplicito)(runtime, env));
+    return { contas, fontes };
+}
+const rotulo = (c) => c.perfil ? `perfil ${c.perfil.id}` : 'conta do processo';
+/**
+ * D4: as sessoes de todas as contas. Consulta que falha vira fonte `ok: false`, nunca "zero
+ * sessoes". `staleMin` e a janela de atividade que torna viva uma sessao codex (D3).
+ */
+function consultarContas(raiz, opcoes = {}) {
+    const base = opcoes.contas ? { contas: opcoes.contas, fontes: [] } : contasDeSessoes(raiz);
+    const fontes = [...base.fontes];
+    const sessoes = [];
+    const agoraMs = opcoes.agoraMs ?? Date.now();
+    const janelaMs = (opcoes.staleMin ?? 30) * 60_000;
+    for (const conta of base.contas) {
+        const perfil = conta.perfil?.id ?? null;
+        if (conta.runtime === 'claude-bg') {
+            let ambiente;
+            try {
+                ambiente = (0, claude_bg_1.ambienteDoPerfil)(conta.perfil);
+            }
+            catch (e) {
+                fontes.push({ origem: `claude agents (${rotulo(conta)})`, ok: false, detalhe: e.message });
+                continue;
+            }
+            const r = (0, claude_bg_1.consultarSessoes)(undefined, opcoes.todas, ambiente);
+            const origem = `claude agents --json${opcoes.todas ? ' --all' : ''} (${rotulo(conta)})`;
+            // Fatia 2 do ensaio da 0.5.0 (P1): só o ENOENT antes da consulta prova a fonte ausente; qualquer
+            // outra falha do `claude` continua deixando o inventário incompleto.
+            fontes.push(r.ausente
+                ? { origem, ok: true, ausente: true, detalhe: `${r.detalhe}: nenhuma sessão claude-bg a listar`,
+                    correcao: 'para despachar e listar pelo claude-bg, instale o Claude Code e garanta `claude` no PATH' }
+                : { origem, ok: r.ok, detalhe: r.detalhe });
+            for (const s of r.sessoes) {
+                const fantasma = ehFantasma('claude-bg', s);
+                sessoes.push({ ...s, runtime: 'claude-bg', perfil, fantasma, viva: !fantasma && !TERMINAIS.includes(estadoDe(s)) });
+            }
+        }
+        else {
+            const r = (0, codex_1.consultarRollouts)(opcoes.todas, conta.dir);
+            // A conta do processo segue com o caminho de antes; a do perfil vai pelo id, nunca pela pasta.
+            fontes.push(...(conta.perfil ? r.resultadosFontes.map(f => ({ ...f,
+                origem: `codex (${rotulo(conta)}): ${path.relative(conta.dir, f.origem)}` })) : r.resultadosFontes));
+            for (const s of r.sessoes) {
+                const recente = typeof s.atividadeEm === 'number' && agoraMs - s.atividadeEm <= janelaMs;
+                sessoes.push({ ...s, runtime: 'codex', perfil, fantasma: false, viva: estadoDe(s) !== 'completed' && recente });
+            }
+        }
+    }
+    return { sessoes, fontes, contas: base.contas };
+}
+/**
+ * D7: o mapa sessionId -> estado que o escalonador e o monitor usam, agora de todas as contas.
+ * Fantasma vira `fantasma` (nem `working` nem `blocked`: nao ocupa vaga nem pede o dono); codex
+ * vivo vira `working`. `null` ("runtime nao consultado") quando nenhuma conta claude-bg respondeu e
+ * nenhuma sessao codex apareceu: um mapa vazio ali diria "nada rodando" sem ter olhado.
+ */
+function estadosNasContas(raiz, opcoes = {}) {
+    const r = consultarContas(raiz, opcoes);
+    const claude = r.fontes.filter(f => f.origem.startsWith('claude agents'));
+    if (claude.length > 0 && !claude.some(f => f.ok) && !r.sessoes.some(s => s.runtime === 'codex'))
+        return null;
+    return new Map(r.sessoes.map(s => [s.sessionId,
+        s.fantasma ? 'fantasma' : s.runtime === 'codex' ? (s.viva ? 'working' : estadoDe(s)) : estadoDe(s)]));
+}
+/**
+ * RM-056 (D3): sessoes vivas de cada perfil do runtime nesta maquina, a carga do rodizio por
+ * carga. So as contas dos perfis sao consultadas (a do processo nao recebe despacho com perfis).
+ */
+function sessoesVivasPorPerfil(raiz, runtime, staleMin, agoraMs) {
+    const contas = contasDeSessoes(raiz).contas.filter(c => c.runtime === runtime && c.perfil);
+    const carga = new Map(contas.map(c => [c.perfil.id, 0]));
+    for (const s of consultarContas(raiz, { contas, staleMin, agoraMs }).sessoes) {
+        if (s.viva && s.perfil)
+            carga.set(s.perfil, (carga.get(s.perfil) ?? 0) + 1);
+    }
+    return carga;
+}

package/dist/sessoes-inventario.js

@@ -38,9 +38,8 @@ exports.inventariarSessoes = inventariarSessoes;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const os = __importStar(require("node:os"));
-const claude_bg_1 = require("./adapters/claude-bg");
-const codex_1 = require("./adapters/codex");
 const estado_thread_1 = require("./estado-thread");
+const sessoes_contas_1 = require("./sessoes-contas");
 const thread_1 = require("./thread");
 /** Projeto canônico mais próximo de cada cwd declarado, sem varrer o HOME inteiro. */
 function raizesDeRegistros(cwds) {
@@ -71,16 +70,10 @@ function raizesDeRegistros(cwds) {
 }
 function inventariarSessoes(raiz, opcoes = {}) {
     const canonica = (0, estado_thread_1.raizDoEstado)(raiz);
-    const claude = (0, claude_bg_1.consultarSessoes)(undefined, opcoes.todas);
-    const codex = (0, codex_1.consultarRollouts)(opcoes.todas);
-    const fontes = [
-        { origem: `claude agents --json${opcoes.todas ? ' --all' : ''}`, ok: claude.ok, detalhe: claude.detalhe },
-        ...codex.resultadosFontes,
-    ];
-    const todas = [
-        ...claude.sessoes.map(s => ({ ...s, runtime: 'claude-bg', vinculos: [] })),
-        ...codex.sessoes.map(s => ({ ...s, runtime: 'codex', vinculos: [] })),
-    ];
+    // RM-056 (D4): a conta do processo e cada perfil do store, sem repetir diretorio.
+    const contas = (0, sessoes_contas_1.consultarContas)(canonica, { todas: opcoes.todas });
+    const fontes = contas.fontes;
+    const todas = contas.sessoes.map(s => ({ ...s, vinculos: [] }));
     // O cruzamento usa o universo global mesmo quando a apresentação é local.
     try {
         const projetos = raizesDeRegistros([canonica, ...todas.map(s => s.cwd)]);
@@ -155,5 +148,6 @@ function inventariarSessoes(raiz, opcoes = {}) {
         escopo: { usuario: os.userInfo().username, global: !!opcoes.global, historico: !!opcoes.todas, raiz: canonica },
         fontes, sessoes, total: sessoes.length,
         semThread: sessoes.filter(s => s.vinculos.length === 0).length, ambiguas,
+        fantasmas: sessoes.filter(s => s.fantasma).length,
     };
 }

package/dist/sessoes.js

@@ -44,21 +44,34 @@ exports.tabelaDeSessoes = tabelaDeSessoes;
 exports.logsDaSessao = logsDaSessao;
 exports.pararSessao = pararSessao;
 exports.comandoDeAttach = comandoDeAttach;
+exports.limparFantasmas = limparFantasmas;
+exports.sessoesSemFim = sessoesSemFim;
+exports.textoDaLimpeza = textoDaLimpeza;
 const adapter = __importStar(require("./adapters/claude-bg"));
 const sessoes_inventario_1 = require("./sessoes-inventario");
 const runtime_profiles_1 = require("./runtime-profiles");
 const util_1 = require("./util");
+const estado_thread_1 = require("./estado-thread");
+const ledger_1 = require("./ledger");
+const thread_1 = require("./thread");
 function textoDoInventario(r) {
     const linhas = [
         `Inventário ${r.escopo.global ? 'global' : 'do projeto'} da conta ${r.escopo.usuario}; histórico: ${r.escopo.historico ? 'incluído' : 'omitido'}.`,
-        `Fontes: ${r.fontes.map(f => `${f.origem} (${f.ok ? 'ok' : 'FALHA'})`).join('; ')}`,
-        `Total: ${r.total}; sem thread: ${r.semThread}; ambíguas: ${r.ambiguas}; consulta: ${r.ok ? 'válida' : 'INCOMPLETA'}.`,
+        `Fontes: ${r.fontes.map(f => `${f.origem} (${f.ausente ? 'ausente' : f.ok ? 'ok' : 'FALHA'})`).join('; ')}`,
+        `Total: ${r.total}; sem thread: ${r.semThread}; ambíguas: ${r.ambiguas}; fantasmas: ${r.fantasmas}; consulta: ${r.ok ? 'válida' : 'INCOMPLETA'}.`,
     ];
+    // RM-056 (D4): a coluna PERFIL e o id do perfil (`processo` sem perfil), nunca o diretorio da conta.
     if (r.sessoes.length)
-        linhas.push((0, util_1.tabela)(['ID', 'RUNTIME', 'ESTADO', 'THREAD/FASE'], r.sessoes.map(s => [s.sessionId, s.runtime, s.state ?? s.status ?? 'unknown',
+        linhas.push((0, util_1.tabela)(['ID', 'RUNTIME', 'PERFIL', 'ESTADO', 'THREAD/FASE'], r.sessoes.map(s => [s.sessionId, s.runtime, s.perfil ?? 'processo',
+            `${s.state ?? s.status ?? 'unknown'}${s.fantasma ? ' (fantasma)' : ''}`,
             s.vinculos.map(v => `${v.thread}/${v.fase}`).join(', ') || '(fora do ork)'])));
+    if (r.fantasmas > 0)
+        linhas.push('Fantasma: registro sem processo vivo, não ocupa vaga; `ork sessions limpar-fantasmas` solta o vínculo do ork sem tocar no runtime.');
     for (const f of r.fontes.filter(f => !f.ok))
         linhas.push(`Falha: ${f.detalhe}`);
+    // Fatia 2 do ensaio da 0.5.0 (P1): a fonte ausente nao e falha, mas diz o que falta e como ter.
+    for (const f of r.fontes.filter(f => f.ausente))
+        linhas.push(`Ausente: ${f.detalhe}${f.correcao ? `; correção: ${f.correcao}` : ''}`);
     return linhas.join('\n');
 }
 function tabelaDeSessoes(raiz, todas = false) {
@@ -117,3 +130,74 @@ function comandoDeAttach(chave, raiz) {
     const { sessao, perfil, configDir } = l.achada;
     return { texto: adapter.comandoAttach(sessao.sessionId, perfil ? configDir : null), codigo: 0 };
 }
+const ENCERRAM_A_SESSAO = ['phase_result', 'sessao_morta', 'session_superseded'];
+/**
+ * RM-056 (D6): solta o vinculo do `ork` com cada sessao fantasma (sem pid e sem processo) deste
+ * projeto, gravando `sessao_morta` no ledger da thread: e o evento que libera a conducao
+ * (`fimDaSessao`) e a vaga. Nunca chama o runtime: o registro no `claude agents` fica onde esta.
+ */
+function limparFantasmas(raiz, opcoes = {}) {
+    const canonica = (0, estado_thread_1.raizDoEstado)(raiz);
+    const inv = (0, sessoes_inventario_1.inventariarSessoes)(canonica, { global: true });
+    const itens = [];
+    for (const s of inv.sessoes.filter(x => x.fantasma)) {
+        // Fechamento (RM-056, ao fechar): so os vinculos da thread que fecha; o resto fica como estava.
+        const vinculos = opcoes.thread ? s.vinculos.filter(v => v.thread === opcoes.thread && v.raiz === canonica) : s.vinculos;
+        if (opcoes.thread && vinculos.length === 0)
+            continue;
+        if (vinculos.length === 0) {
+            itens.push({ sessionId: s.sessionId, perfil: s.perfil, thread: null, fase: null, acao: 'sem-thread' });
+            continue;
+        }
+        for (const v of vinculos) {
+            const base = { sessionId: s.sessionId, perfil: s.perfil, thread: v.thread, fase: v.fase };
+            if (v.raiz !== canonica) {
+                itens.push({ ...base, acao: 'outro-projeto' });
+                continue;
+            }
+            const dir = (0, thread_1.dirThread)(canonica, v.thread);
+            if ((0, ledger_1.lerLedger)(dir).some(e => ENCERRAM_A_SESSAO.includes(e.tipo) && e.sessionId === s.sessionId)) {
+                itens.push({ ...base, acao: 'ja-solto' });
+                continue;
+            }
+            if (!opcoes.dryRun)
+                (0, ledger_1.registrar)(dir, v.thread, 'sessao_morta', {
+                    fase: v.fase, sessionId: s.sessionId, runtime: s.runtime, ...(s.perfil ? { perfilId: s.perfil } : {}),
+                    origem: opcoes.origem ?? 'sessions.limpar-fantasmas', estadoNoRuntime: s.state ?? s.status ?? null,
+                    evidencia: 'claude agents lista a sessao sem pid ou com pid sem processo (fantasma, RM-056 D5)',
+                    razao: 'solta o vinculo do ork (conducao e vaga) sem tocar no runtime: claude stop e claude rm nao acham o job',
+                });
+            itens.push({ ...base, acao: 'solto' });
+        }
+    }
+    return { ok: inv.ok, dryRun: opcoes.dryRun === true, itens, falhas: inv.fontes.filter(f => !f.ok).map(f => `${f.origem}: ${f.detalhe}`) };
+}
+/**
+ * RM-056 (ao fechar): as sessoes registradas na thread que o ledger dela ainda nao encerra. E o filtro
+ * barato do fechamento: so com alguma delas o `liberarAoFechar` consulta o inventario (o `claude agents`
+ * de cada conta). Sessao sem fim pode estar viva; quem decide se e fantasma e o inventario.
+ */
+function sessoesSemFim(raiz, threadId) {
+    const canonica = (0, estado_thread_1.raizDoEstado)(raiz);
+    const t = (0, thread_1.lerThread)(canonica, threadId);
+    const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(canonica, threadId));
+    const encerradas = new Set(eventos.filter(e => ENCERRAM_A_SESSAO.includes(e.tipo)).map(e => String(e.sessionId ?? '')));
+    const ids = (Array.isArray(t.sessoes) ? t.sessoes : []).map(s => s?.sessionId).filter((id) => typeof id === 'string');
+    return [...new Set(ids)].filter(id => !encerradas.has(id));
+}
+function textoDaLimpeza(r) {
+    if (r.itens.length === 0)
+        return `Nenhuma sessão fantasma${r.ok ? '' : ' nas contas que responderam'}.` +
+            r.falhas.map(f => `\nFalha: ${f}`).join('');
+    const verbo = {
+        solto: r.dryRun ? 'soltaria (sessao_morta no ledger)' : 'solto: sessao_morta no ledger',
+        'ja-solto': 'já encerrada no ledger', 'sem-thread': 'fora do ork: nada a soltar',
+        'outro-projeto': 'vínculo de outro projeto: rode lá',
+    };
+    return [
+        `Sessões fantasma (sem pid e sem processo)${r.dryRun ? ', ensaio: nada foi gravado' : ''}. O runtime não foi tocado.`,
+        (0, util_1.tabela)(['ID', 'PERFIL', 'THREAD/FASE', 'AÇÃO'], r.itens.map(i => [i.sessionId, i.perfil ?? 'processo',
+            i.thread ? `${i.thread}/${i.fase}` : '-', verbo[i.acao]])),
+        ...r.falhas.map(f => `Falha: ${f}`),
+    ].join('\n');
+}