@orkastery/cli 0.5.1 → 0.5.6

package/dist/session-watcher.js

@@ -33,10 +33,11 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BLOCO_WATCH_BYTES = exports.INTERVALO_WATCH_MS = exports.LIMITE_MORTE_MS = void 0;
+exports.BLOCO_WATCH_BYTES = exports.MAX_FALHAS_WATCH = exports.MAX_ESPERA_ERRO_WATCH_MS = exports.INTERVALO_WATCH_MS = exports.LIMITE_MORTE_MS = void 0;
 exports.observarSessao = observarSessao;
 exports.validarFonteWatcher = validarFonteWatcher;
 exports.iniciarWatcher = iniciarWatcher;
+exports.acompanharSessao = acompanharSessao;
 /** D6: observador restrito a uma sessão, cursor canônico e resultados idempotentes. */
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
@@ -110,6 +111,8 @@ function semProvaNativa(snapshot, terminal, fonteVencedora, fechamento, sessionI
 }
 exports.LIMITE_MORTE_MS = 600000;
 exports.INTERVALO_WATCH_MS = 1000;
+exports.MAX_ESPERA_ERRO_WATCH_MS = 30000;
+exports.MAX_FALHAS_WATCH = 12;
 exports.BLOCO_WATCH_BYTES = codex_events_1.LIMITE_LINHA_CODEX + 65536;
 function lerJson(file) {
     if (!fs.existsSync(file))
@@ -291,8 +294,87 @@ function desfazerNaThreadRemovida(pasta, criadas) {
         catch { /* já removida ou não vazia */ }
     }
 }
+/** Diagnóstico fechado: mensagens de E/S e JSON podem conter caminhos e segredos. */
+function diagnosticoWatcher(e) {
+    const erro = e;
+    const code = ['ENOENT', 'EAGAIN', 'EBUSY', 'EINTR', 'EACCES', 'EPERM', 'EIO', 'ENOSPC', 'SESSION_STATE_SPLIT']
+        .includes(erro?.code ?? '') ? erro.code : null;
+    const nome = e instanceof Error ? e.constructor.name : '';
+    const construtor = ['Error', 'SyntaxError', 'TypeError', 'RangeError', 'ReferenceError', 'URIError', 'EvalError', 'AggregateError']
+        .includes(nome) ? nome : 'desconhecido';
+    const base = { code, construtor };
+    const mensagem = erro?.message ?? '';
+    if (mensagem === 'prazo de observação esgotado')
+        return { ...base, categoria: 'observacao.prazo',
+            erro: 'nenhuma observação bem-sucedida dentro do orçamento de espera', transitorio: false };
+    // Só motivos literais do núcleo saem no diagnóstico: nenhum conteúdo de metadado.
+    const motivos = ['sessão do controller divergente', 'instância do controller divergente',
+        'vínculo thread/fase/prompt do controller divergente', 'cwd do controller divergente',
+        'identidade do controller divergente da registrada', 'identidade do runtime divergente da registrada',
+        'rollout do controller ausente', 'rollout do controller divergente do registrado',
+        'rollout do controller rotacionado sem vínculo provado com a fonte fixada',
+        'descritor consumidor de rollout divergente da fonte fixada'];
+    const metadado = /^runtime\.unavailable: metadado (state\.json|launch\.json|process-launch\.json) de controller (inválido|ausente)$/.test(mensagem);
+    const categoria = metadado || motivos.some(m => mensagem === `runtime.unavailable: ${m}`) ? mensagem
+        : mensagem === 'controlador registrado divergente do despacho' ? 'controller.registro-divergente'
+            : mensagem === 'despacho do controller sem cwd registrado' ? 'controller.cwd-ausente'
+                : mensagem.startsWith('runtime.unavailable:') ? 'runtime.unavailable: motivo não categorizado'
+                    : code ? `io.${code}` : construtor;
+    if (code === 'SESSION_STATE_SPLIT')
+        return { ...base, categoria: 'estado.dividido',
+            erro: 'estado canônico temporariamente sem vínculo; auditoria será repetida', transitorio: true };
+    if (['ENOENT', 'EAGAIN', 'EBUSY', 'EINTR'].includes(erro?.code ?? ''))
+        return { ...base, categoria, erro: `leitura temporariamente indisponível (${erro.code})`, transitorio: true };
+    if (e instanceof SyntaxError || /^JSON invalido em /.test(erro?.message ?? '') ||
+        metadado)
+        return { ...base, categoria: metadado ? categoria : 'json.invalido', erro: 'metadado JSON indisponível ou incompleto', transitorio: true };
+    if (/^(ingestão ocupada|creation\.busy:)/.test(erro?.message ?? ''))
+        return { ...base, categoria: 'observacao.ocupada', erro: 'observação ocupada; nova tentativa agendada', transitorio: true };
+    return { ...base, categoria, erro: 'falha permanente na observação; confira vínculo e fonte do sensor', transitorio: false };
+}
+const errosRegistrados = new WeakSet();
+function registrarErroWatcher(raiz, threadId, sessionId, e, serie) {
+    if (!serie && e && typeof e === 'object' && errosRegistrados.has(e))
+        return true;
+    const dados = diagnosticoWatcher(e);
+    if (dados.categoria === 'observacao.ocupada')
+        return true;
+    const registrado = (0, ledger_1.registrarSeExiste)((0, thread_1.dirThread)(raiz, threadId), threadId, 'session_watcher_error', {
+        sessionId, motivo: 'runtime.unavailable', ...dados, ...serie,
+        transitorio: dados.transitorio && (!serie?.encerramento || serie.encerramento === 'recuperado'), origem: 'sessions.watch',
+    });
+    if (registrado && e && typeof e === 'object')
+        errosRegistrados.add(e);
+    return registrado !== null;
+}
+/** Falhar ao diagnosticar não troca o erro observado nem interrompe o retry transitório. */
+function tentarRegistrarErroWatcher(...args) {
+    try {
+        return registrarErroWatcher(...args);
+    }
+    catch {
+        return false;
+    }
+}
+function observarSemDiagnostico(carregado, sessionId, opcoes) {
+    return observarSessaoResolvida(carregado, sessionId, (0, session_events_1.resolverSessao)(carregado.raiz, sessionId, opcoes.threadId), opcoes);
+}
 function observarSessao(carregado, sessionId, opcoes = {}) {
-    const { thread, sessao: registrada } = (0, session_events_1.resolverSessao)(carregado.raiz, sessionId);
+    let threadId = opcoes.threadId;
+    try {
+        const resolvida = (0, session_events_1.resolverSessao)(carregado.raiz, sessionId, threadId);
+        // Recusa de entrada sem despacho não é falha de um watcher ancorado.
+        threadId = resolvida.sessao.origem !== 'adocao' && resolvida.sessao.despachadaEm
+            ? resolvida.thread.id : undefined;
+        return observarSessaoResolvida(carregado, sessionId, resolvida, opcoes);
+    }
+    catch (e) {
+        if (threadId)
+            tentarRegistrarErroWatcher(carregado.raiz, threadId, sessionId, e);
+        throw e;
+    }
+}
+function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registrada }, opcoes) {
     const sessao = (0, session_events_1.exigirSessaoDespachada)(registrada, sessionId);
     if (sessao.runtime !== 'codex' && sessao.runtime !== 'claude-bg')
         throw new Error('watch requer sessão Codex ou claude-bg registrada');
@@ -398,6 +480,27 @@ function observarSessao(carregado, sessionId, opcoes = {}) {
                     cursor.progressoEm = Math.max(cursor.progressoEm, leitura.quando);
                 }
             }
+            // Commit MCP é produção do núcleo, mesmo quando app-server não avança o rollout.
+            // Só renova inatividade com ambos os processos vivos, dentro deste despacho e
+            // sem terminal/erro nativo. Não substitui terminal, close ou prova de conclusão.
+            let progressoMcpEventId;
+            if (snapshot?.estadoController === 'vivo' && snapshot.estadoRuntime === 'vivo' &&
+                ['working', 'running'].includes(snapshot.estado) && !snapshot.fechamento &&
+                !snapshot.terminalNativo && !snapshot.erro && !snapshot.limitacao) {
+                for (const e of (0, session_watcher_claude_1.eventosDoIntervalo)(eventos, sessao)) {
+                    const quando = Date.parse(e.ts);
+                    if (e.tipo !== 'mcp_git_committed' || e.thread !== thread.id || e.origem !== 'mcp.git' ||
+                        e.estadoAuditado !== true || typeof e.commit !== 'string' || !/^[a-f0-9]{40}$/.test(e.commit) ||
+                        (e.sessionId !== undefined && e.sessionId !== sessionId) ||
+                        (e.despachoEm !== undefined && e.despachoEm !== sessao.despachadaEm) ||
+                        quando > now || quando <= cursor.progressoEm)
+                        continue;
+                    cresceu = true;
+                    cursor.crescimentoEm = Math.max(cursor.crescimentoEm, quando);
+                    cursor.progressoEm = quando;
+                    progressoMcpEventId = e.eventId;
+                }
+            }
             // Erro de metadados posterior não obriga a reler o mesmo backlog no restart.
             (0, codex_runner_1.gravarAtomico)(file, cursor);
             const processo = registro?.processoPath ? lerJson(registro.processoPath) : null;
@@ -482,7 +585,8 @@ function observarSessao(carregado, sessionId, opcoes = {}) {
                     if (!atuais.some(e => e.sensorEventId === heartbeatId))
                         (0, ledger_1.registrar)(dir, thread.id, 'runtime_heartbeat', {
                             ts: new Date(cursor.crescimentoEm).toISOString(), fase: sessao.fase, sessionId, despachoEm: sessao.despachadaEm,
-                            sensorEventId: heartbeatId, fonte: 'progresso reconhecido do stream/rollout', bytesLidos,
+                            sensorEventId: heartbeatId, fonte: progressoMcpEventId ? 'mcp_git_committed do despacho' : 'progresso reconhecido do stream/rollout',
+                            ...(progressoMcpEventId ? { mcpEventId: progressoMcpEventId } : {}), bytesLidos,
                         });
                     cursor.heartbeatEm = cursor.crescimentoEm;
                     (0, codex_runner_1.gravarAtomico)(file, cursor);
@@ -548,13 +652,6 @@ function observarSessao(carregado, sessionId, opcoes = {}) {
         // Thread apagada no meio da observação: encerra sem erro, sem recriar a pasta e sem resíduo.
         if (!(0, ledger_1.threadPresente)(dir))
             return desfazer();
-        if (!/ocupad/.test(e.message) && !(0, ledger_1.registrarSeExiste)(dir, thread.id, 'session_watcher_error', {
-            fase: sessao.fase, sessionId, despachoEm: sessao.despachadaEm, motivo: 'runtime.unavailable',
-            // Não copiar conteúdo de metadados/logs em mensagens de JSON.parse.
-            erro: e instanceof SyntaxError ? 'metadado JSON inválido' : e.message,
-            origem: 'sessions.watch',
-        }))
-            return removida;
         throw e;
     }
 }
@@ -612,7 +709,7 @@ function iniciarWatcher(raiz, sessionId) {
     const err = fs.openSync(path.join(dir, `watcher-${sessionId}.stderr`), 'a', 0o600);
     let child;
     try {
-        child = (0, node_child_process_1.spawn)(process.execPath, [__filename, '--run', raiz, sessionId, readyPath, token], {
+        child = (0, node_child_process_1.spawn)(process.execPath, [__filename, '--run', raiz, sessionId, readyPath, token, thread.id], {
             cwd: raiz, detached: true, stdio: ['ignore', 'ignore', err],
         });
     }
@@ -661,47 +758,102 @@ function iniciarWatcher(raiz, sessionId) {
 }
 async function acompanhar() {
     const carregado = (0, manifest_1.exigirManifesto)(process.argv[3]), sessionId = process.argv[4];
-    const { thread } = (0, session_events_1.resolverSessao)(carregado.raiz, sessionId);
-    const readyPath = process.argv[5], token = process.argv[6];
-    if (readyPath && token) {
-        validarFonteWatcher(carregado.raiz, sessionId);
-        const sessao = (0, session_events_1.exigirSessaoDespachada)((0, session_events_1.resolverSessao)(carregado.raiz, sessionId).sessao, sessionId);
-        const identidade = (0, codex_runner_1.identidadeProcesso)(process.pid);
-        if (!identidade)
-            throw new Error('watcher sem identidade propria');
-        (0, codex_runner_1.gravarAtomico)(readyPath, { token, sessionId, despachoEm: sessao.despachadaEm, identidade });
-        const deadline = Date.now() + 5000;
-        while (lerJson(readyPath + '.ack')?.token !== token) {
-            if (Date.now() >= deadline)
-                throw new Error('watcher sem confirmacao do pai');
-            await new Promise(r => setTimeout(r, 10));
+    const threadId = process.argv[7] ?? (0, session_events_1.resolverSessao)(carregado.raiz, sessionId).thread.id;
+    try {
+        const readyPath = process.argv[5], token = process.argv[6];
+        if (readyPath && token) {
+            validarFonteWatcher(carregado.raiz, sessionId);
+            const sessao = (0, session_events_1.exigirSessaoDespachada)((0, session_events_1.resolverSessao)(carregado.raiz, sessionId, threadId).sessao, sessionId);
+            const identidade = (0, codex_runner_1.identidadeProcesso)(process.pid);
+            if (!identidade)
+                throw new Error('watcher sem identidade propria');
+            (0, codex_runner_1.gravarAtomico)(readyPath, { token, sessionId, despachoEm: sessao.despachadaEm, identidade });
+            const deadline = Date.now() + 5000;
+            while (lerJson(readyPath + '.ack')?.token !== token) {
+                if (Date.now() >= deadline)
+                    throw new Error('watcher sem confirmacao do pai');
+                await new Promise(r => setTimeout(r, 10));
+            }
         }
+        await acompanharSessao(carregado, sessionId, { threadId });
     }
-    const dir = (0, thread_1.dirThread)(carregado.raiz, thread.id);
+    catch (e) {
+        tentarRegistrarErroWatcher(carregado.raiz, threadId, sessionId, e);
+        throw e;
+    }
+}
+/** Mesmo laço do processo destacado, com relógio e espera injetáveis para regressões. */
+async function acompanharSessao(carregado, sessionId, opcoes) {
+    const dir = (0, thread_1.dirThread)(carregado.raiz, opcoes.threadId);
+    const esperar = opcoes.esperar ?? ((ms) => new Promise(r => setTimeout(r, ms)));
+    const agora = opcoes.agora ?? Date.now;
+    let falhas = 0, tentativas = 0, esperas = 0, ultimaObservacao = agora(), ultimoErro;
     for (;;) {
         // Projeto ou thread apagados encerram o laço em silêncio: nada a observar nem a recriar.
         if (!(0, ledger_1.threadPresente)(dir))
             return;
         let atual;
         try {
-            atual = (0, thread_1.lerThread)(carregado.raiz, thread.id);
+            atual = (0, thread_1.lerThread)(carregado.raiz, opcoes.threadId);
             if (atual.status !== 'aberta' || atual.sessoes.at(-1)?.sessionId !== sessionId)
                 return;
-            const r = observarSessao(carregado, sessionId);
+            // O laço agrega sua série de erros; a API de observação avulsa diagnostica separadamente.
+            const r = observarSemDiagnostico(carregado, sessionId, { threadId: opcoes.threadId, agoraMs: opcoes.agora?.() });
+            if (r.ocupado)
+                throw new Error('ingestão ocupada; tente novamente');
+            if (!r.ocupado) {
+                if (falhas)
+                    tentarRegistrarErroWatcher(carregado.raiz, opcoes.threadId, sessionId, ultimoErro, { falhasConsecutivas: falhas, etapa: 'final', encerramento: 'recuperado' });
+                falhas = 0;
+                tentativas = 0;
+                esperas = 0;
+                ultimaObservacao = agora();
+            }
             if (r.concluido || r.encerrado)
                 return;
         }
         catch (e) {
             if (!(0, ledger_1.threadPresente)(dir))
                 return;
-            if (!/ocupad/.test(e.message))
-                throw e;
+            esperas++;
+            const dados = diagnosticoWatcher(e), ocupado = dados.categoria === 'observacao.ocupada';
+            const expirou = agora() - ultimaObservacao >= exports.LIMITE_MORTE_MS;
+            // Contenção não é erro. Estado dividido exige nova auditoria; ambos consomem
+            // só tempo, sem antecipar os 600 s pelo teto das outras falhas.
+            if (!ocupado || expirou) {
+                if (ocupado)
+                    e = new Error('prazo de observação esgotado');
+                falhas++;
+                if (!ocupado && dados.categoria !== 'estado.dividido')
+                    tentativas++;
+                ultimoErro = e;
+                const encerramento = ocupado ? 'prazo' : !dados.transitorio ? 'permanente'
+                    : expirou ? 'prazo' : tentativas >= exports.MAX_FALHAS_WATCH ? 'tentativas' : undefined;
+                if (falhas === 1 || encerramento)
+                    tentarRegistrarErroWatcher(carregado.raiz, opcoes.threadId, sessionId, e, { falhasConsecutivas: falhas, etapa: encerramento ? 'final' : 'inicial', ...(encerramento ? { encerramento } : {}) });
+                if (encerramento)
+                    throw e;
+            }
         }
-        await new Promise(r => setTimeout(r, atual?.sessoes.at(-1)?.runtime === 'claude-bg' ? session_watcher_claude_1.INTERVALO_WATCH_CLAUDE_MS : exports.INTERVALO_WATCH_MS));
+        await esperar(esperas ? Math.min(exports.MAX_ESPERA_ERRO_WATCH_MS, exports.INTERVALO_WATCH_MS * 2 ** Math.min(esperas - 1, 5), Math.max(1, exports.LIMITE_MORTE_MS - (agora() - ultimaObservacao)))
+            : atual?.sessoes.at(-1)?.runtime === 'claude-bg' ? session_watcher_claude_1.INTERVALO_WATCH_CLAUDE_MS : exports.INTERVALO_WATCH_MS);
     }
 }
 if (require.main === module && process.argv[2] === '--run')
-    acompanhar().catch(() => {
-        process.stderr.write('ork watcher: observação interrompida; confira session_watcher_error e estado canônico.\n');
+    acompanhar().catch(e => {
+        // O dispatcher fornece o vínculo antes do spawn: até falha ao carregar o manifesto
+        // precisa de diagnóstico. Sem ledger acessível, o stderr não promete um recibo inexistente.
+        let registroIndisponivel = !process.argv[7];
+        if (process.argv[7]) {
+            try {
+                registroIndisponivel = !registrarErroWatcher(process.argv[3], process.argv[7], process.argv[4], e);
+            }
+            catch {
+                registroIndisponivel = true;
+            }
+        }
+        process.stderr.write(registroIndisponivel
+            ? 'ork watcher: observação interrompida; não foi possível registrar session_watcher_error.\n'
+            : 'ork watcher: observação interrompida; confira session_watcher_error e estado canônico.\n');
         process.exitCode = 1;
     });

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, opcoes.prazoMs);
+            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,22 +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 origemClaude = `claude agents --json${opcoes.todas ? ' --all' : ''}`;
-    // Fatia 2 do ensaio da 0.5.0 (P1): como o diretório opcional do Codex, só o ENOENT antes da consulta
-    // prova a fonte ausente; qualquer outra falha do `claude` continua deixando o inventário incompleto.
-    const fontes = [
-        claude.ausente
-            ? { origem: origemClaude, ok: true, ausente: true, detalhe: `${claude.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: origemClaude, 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)]);
@@ -161,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,19 +44,29 @@ 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.ausente ? 'ausente' : f.ok ? 'ok' : 'FALHA'})`).join('; ')}`,
-        `Total: ${r.total}; sem thread: ${r.semThread}; ambíguas: ${r.ambiguas}; consulta: ${r.ok ? 'válida' : 'INCOMPLETA'}.`,
+        `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.
@@ -120,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');
+}