@orkastery/cli 0.5.6 → 0.6.1

package/dist/session-watcher.js

@@ -35,7 +35,10 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 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.reconciliarSessaoSemWatcher = reconciliarSessaoSemWatcher;
+exports.validarRegistroWatcher = validarRegistroWatcher;
 exports.validarFonteWatcher = validarFonteWatcher;
+exports.prepararFonteWatcher = prepararFonteWatcher;
 exports.iniciarWatcher = iniciarWatcher;
 exports.acompanharSessao = acompanharSessao;
 /** D6: observador restrito a uma sessão, cursor canônico e resultados idempotentes. */
@@ -55,6 +58,9 @@ const codex_controller_sensor_1 = require("./adapters/codex-controller-sensor");
 const retry_1 = require("./retry");
 const ratelimit_1 = require("./ratelimit");
 const session_watcher_claude_1 = require("./session-watcher-claude");
+const session_watcher_grok_1 = require("./session-watcher-grok");
+const conta_esgotada_1 = require("./conta-esgotada");
+const trabalho_thread_1 = require("./trabalho-thread");
 /** Falhas operacionais e bloqueios sem retry automático não alegam conclusão do produto. */
 function bloqueioPreservado(terminal) {
     return terminal.classificacao === 'gate_blocked' && terminal.motivo !== null &&
@@ -281,7 +287,7 @@ function conferirRegistro(dir, registro) {
  * com o dono da remoção.
  */
 function desfazerNaThreadRemovida(pasta, criadas) {
-    for (const cursor of ['cursor.json', 'cursor-claude.json']) {
+    for (const cursor of ['cursor.json', 'cursor-claude.json', 'cursor-grok.json']) {
         try {
             fs.rmSync(path.join(pasta, cursor), { force: true });
         }
@@ -325,6 +331,9 @@ function diagnosticoWatcher(e) {
             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 (mensagem === 'runtime.unavailable: rollout do controller ausente' ||
+        mensagem === 'runtime.unavailable: rollout do controller sem session_meta conferível')
+        return { ...base, categoria, erro: 'fonte do runtime ainda não está pronta', 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 };
@@ -374,10 +383,115 @@ function observarSessao(carregado, sessionId, opcoes = {}) {
         throw e;
     }
 }
+/**
+ * RM-064 T9: a batida não depende do processo watcher ter nascido. Para a última sessão
+ * despachada e verificada, recompõe a fonte do próprio despacho, observa o runtime diretamente
+ * e, depois do mesmo limite do watcher, registra uma parada tipada que o retry consegue tratar.
+ */
+function reconciliarSessaoSemWatcher(carregado, threadId, agoraMs = Date.now()) {
+    const thread = (0, thread_1.lerThread)(carregado.raiz, threadId);
+    const sessao = thread.sessoes.at(-1);
+    const ignorada = (detalhe) => ({ thread: threadId,
+        sessionId: sessao?.sessionId ?? null, estado: 'ignorada', detalhe });
+    if (thread.status === 'fechada' || !sessao || sessao.verificada !== true ||
+        !['codex', 'claude-bg', 'grok'].includes(sessao.runtime) || typeof sessao.despachadaEm !== 'string')
+        return ignorada('sem sessão despachada e verificada que o watcher possa reconciliar');
+    const dir = (0, thread_1.dirThread)(carregado.raiz, threadId);
+    let eventos = (0, ledger_1.lerLedger)(dir);
+    if (eventos.some(e => e.tipo === 'phase_result' && e.sessionId === sessao.sessionId &&
+        (e.despachoEm === undefined || e.despachoEm === sessao.despachadaEm)))
+        return ignorada('sessão já possui phase_result');
+    const iniciado = eventos.filter(e => e.tipo === 'session_watcher_started' && e.sessionId === sessao.sessionId &&
+        e.despachoEm === sessao.despachadaEm).at(-1);
+    const identidade = iniciado?.identidade;
+    if (identidade && iniciado?.pid === identidade.pid && (0, codex_runner_1.estadoProcesso)(identidade) === 'vivo')
+        return ignorada('watcher verificado continua vivo');
+    try {
+        const registro = eventos.filter(e => e.tipo === 'session_sensor_registered' && e.sessionId === sessao.sessionId &&
+            e.despachoEm === sessao.despachadaEm).at(-1);
+        if (!registro && sessao.runtime === 'claude-bg') {
+            (0, session_watcher_claude_1.garantirFonteClaude)(carregado.raiz, thread, (0, session_events_1.exigirSessaoDespachada)(sessao, sessao.sessionId));
+        }
+        else if (!registro && sessao.runtime === 'codex') {
+            const despacho = eventos.filter(e => e.tipo === 'phase_dispatch' && e.sessionId === sessao.sessionId).at(-1);
+            const controlador = (despacho?.controlador ?? sessao.controlador);
+            const cwd = despacho?.cwd;
+            if (controlador && cwd) {
+                const fonte = { controlador, cwd };
+                validarRegistroWatcher(carregado.raiz, sessao.sessionId, fonte);
+                (0, session_events_1.comLockDeSessao)(dir, () => {
+                    const atuais = (0, ledger_1.lerLedger)(dir);
+                    if (!atuais.some(e => e.tipo === 'session_sensor_registered' && e.sessionId === sessao.sessionId &&
+                        e.despachoEm === sessao.despachadaEm)) {
+                        (0, ledger_1.registrar)(dir, threadId, 'session_sensor_registered', { fase: sessao.fase, sessionId: sessao.sessionId,
+                            despachoEm: sessao.despachadaEm, ...fonte, origem: 'conducao.batida',
+                            ...(despacho?.perfil ? { perfil: despacho.perfil } : {}) });
+                    }
+                });
+            }
+        }
+        const observado = observarSessao(carregado, sessao.sessionId, { threadId, agoraMs });
+        if (!observado.ocupado) {
+            const observadoEm = new Date(agoraMs).toISOString();
+            (0, session_events_1.comLockDeSessao)(dir, () => {
+                const atuais = (0, ledger_1.lerLedger)(dir);
+                if (!atuais.some(e => e.tipo === 'session_watcher_observed' && e.sessionId === sessao.sessionId &&
+                    e.despachoEm === sessao.despachadaEm && e.ts === observadoEm)) {
+                    (0, ledger_1.registrar)(dir, threadId, 'session_watcher_observed', { ts: observadoEm, fase: sessao.fase,
+                        sessionId: sessao.sessionId, despachoEm: sessao.despachadaEm, origem: 'conducao.batida' });
+                }
+            });
+        }
+        if (observado.concluido)
+            return { thread: threadId, sessionId: sessao.sessionId,
+                estado: 'concluida', detalhe: `runtime observado: ${observado.classificacao ?? 'terminal'}` };
+        return { thread: threadId, sessionId: sessao.sessionId, estado: 'acompanhada',
+            detalhe: observado.ocupado ? 'observação ocupada; nova batida repetirá' : 'runtime ainda sem terminal' };
+    }
+    catch (erro) {
+        // `observarSessao` diagnostica sua própria falha; a recomposição estrutural passa pelo mesmo
+        // recibo. Só depois do limite a batida transforma a ausência persistente em parada.
+        tentarRegistrarErroWatcher(carregado.raiz, threadId, sessao.sessionId, erro);
+        eventos = (0, ledger_1.lerLedger)(dir);
+        const doIntervalo = (0, session_watcher_claude_1.eventosDoIntervalo)(eventos, (0, session_events_1.exigirSessaoDespachada)(sessao, sessao.sessionId));
+        const uteis = doIntervalo.filter(e => ['runtime_heartbeat', 'runtime_event', 'runtime_stop', 'runtime_subagent_stop', 'commit',
+            'mcp_git_committed', 'sessao_bloqueada', 'sessao_destravada'].includes(e.tipo));
+        const observacoesBoas = doIntervalo.filter(e => e.sessionId === sessao.sessionId &&
+            (e.tipo === 'session_watcher_observed' || e.tipo === 'session_watcher_error' && e.encerramento === 'recuperado'));
+        const ultimaObservacao = Math.max(Date.parse(sessao.despachadaEm), ...[...uteis, ...observacoesBoas].map(e => Date.parse(e.ts)).filter(Number.isFinite));
+        const errosDaSerie = doIntervalo.filter(e => e.tipo === 'session_watcher_error' && e.sessionId === sessao.sessionId &&
+            e.encerramento !== 'recuperado').map(e => Date.parse(e.ts)).filter(ts => Number.isFinite(ts) && ts >= ultimaObservacao);
+        const primeiroErro = errosDaSerie.length > 0 ? Math.min(...errosDaSerie) : Number.NEGATIVE_INFINITY;
+        const ultimoUtil = Math.max(ultimaObservacao, primeiroErro);
+        if (agoraMs - ultimoUtil < exports.LIMITE_MORTE_MS)
+            return { thread: threadId, sessionId: sessao.sessionId,
+                estado: 'acompanhada', detalhe: 'fonte ainda indisponível dentro do limite de estabilidade' };
+        const sessionId = sessao.sessionId;
+        const chave = (0, node_crypto_1.createHash)('sha256').update(sessionId + '|' + sessao.despachadaEm).digest('hex');
+        const sensorResultId = `codex:${chave}`;
+        (0, session_events_1.comLockDeSessao)(dir, () => {
+            const atuais = (0, ledger_1.lerLedger)(dir);
+            if (atuais.some(e => e.tipo === 'phase_result' && e.sessionId === sessao.sessionId &&
+                e.despachoEm === sessao.despachadaEm))
+                return;
+            const dados = { fase: sessao.fase, sessionId: sessao.sessionId, despachoEm: sessao.despachadaEm,
+                sensorResultId, classificacao: 'gate_blocked', motivo: 'runtime.unavailable', runtime: sessao.runtime,
+                fonte: 'conducao.batida: sessão verificada sem watcher e sem evento útil', fonteVencedora: null,
+                ok: false, conclusaoNativa: false, conclusaoNativaAusente: 'watcher ausente e fonte indisponível além do limite',
+                estado: 'bloqueada', observadoEm: new Date(agoraMs).toISOString(), gate: 'phase.dispatch',
+                origem: 'conducao.batida', morteLatenciaMs: agoraMs - ultimoUtil };
+            (0, ledger_1.registrar)(dir, threadId, 'sessao_morta', dados);
+            (0, ledger_1.registrar)(dir, threadId, 'gate_blocked', dados);
+            (0, ledger_1.registrar)(dir, threadId, 'phase_result', dados);
+        });
+        return { thread: threadId, sessionId: sessao.sessionId, estado: 'parada',
+            detalhe: 'sessão verificada sem watcher e sem evento útil além do limite' };
+    }
+}
 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');
+    if (sessao.runtime !== 'codex' && sessao.runtime !== 'claude-bg' && sessao.runtime !== 'grok')
+        throw new Error('watch requer sessão Codex ou claude-bg ou grok registrada');
     const now = opcoes.agoraMs ?? Date.now();
     if (!Number.isFinite(now))
         throw new Error('relógio inválido');
@@ -413,7 +527,14 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
                 thread, sessao, dir, pasta, chave, agoraMs: now, limiteMs: exports.LIMITE_MORTE_MS, consulta: opcoes.consultaClaude, carregado })) ?? { ...base, ocupado: true };
             return (0, ledger_1.threadPresente)(dir) ? r : desfazer();
         }
-        return comLockWatcher(pasta, () => {
+        // RM-067 (F2): o grok tem observador próprio (stream, recibo do supervisor e pasta da sessão), no mesmo lock.
+        if (sessao.runtime === 'grok') {
+            const r = comLockWatcher(pasta, () => (0, session_watcher_grok_1.observarGrokSobLock)({ raiz: carregado.raiz, thread, sessao, dir, pasta, chave,
+                agoraMs: now, limiteMs: exports.LIMITE_MORTE_MS, relogioReal: opcoes.agoraMs === undefined })) ?? { ...base, ocupado: true };
+            return (0, ledger_1.threadPresente)(dir) ? r : desfazer();
+        }
+        let contaParaReconciliar = null;
+        const observado = comLockWatcher(pasta, () => {
             const eventos = (0, ledger_1.lerLedger)(dir), resultadoId = `codex:${chave}`;
             const pronto = eventos.find(e => e.tipo === 'phase_result' && e.sensorResultId === resultadoId);
             if (pronto)
@@ -610,10 +731,12 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
                     terminal = { ...terminal, classificacao: 'gate_blocked', motivo: 'runtime.unavailable' };
                 }
                 // I-33 (D12): o turno terminou pela CONTA (cota, credito ou login), dito pelo proprio runtime.
-                // E bloqueio, nunca conclusao; a D11c decide no retry se houve producao antes da morte.
+                // É bloqueio, nunca conclusão; o retry deriva checkpoint quando já houve produção.
                 if (conta)
                     terminal = { ...terminal, classificacao: 'gate_blocked', motivo: conta.falha.motivo, falhaDeConta: conta.falha,
                         fonte: `${conta.fonte}: ${conta.falha.motivo} (${conta.falha.trecho})` };
+                const respostaFinal = terminal.respostaFinal
+                    ? (0, trabalho_thread_1.gravarRespostaFinalDaSessao)(carregado.raiz, thread.id, sessionId, terminal.respostaFinal) : null;
                 const dados = { fase: sessao.fase, sessionId, despachoEm: sessao.despachadaEm, sensorResultId: resultadoId,
                     classificacao: terminal.classificacao, motivo: terminal.motivo, runtime: 'codex', fonte: terminal.fonte,
                     fonteVencedora: incompleto || invalido || aberto || descorrelacionado ? null : terminais[0]?.nome ?? null,
@@ -627,13 +750,18 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
                     estado: terminal.classificacao === 'fase_concluida' ? 'concluida' : 'bloqueada',
                     observadoEm: terminal.timestamp, gate: 'phase.dispatch', origem: 'sessions.watch',
                     morteLatenciaMs: morte ? now - cursor.progressoEm : null, ...(perfil ? { perfil } : {}),
+                    ...(respostaFinal ? { respostaFinal: { arquivo: (0, trabalho_thread_1.caminhoDoTrabalho)(thread.id) + respostaFinal.arquivo,
+                            sha256: respostaFinal.sha256, bytes: respostaFinal.bytes, truncada: respostaFinal.truncada } } : {}),
                     ...(conta ? { falhaDeConta: { motivo: conta.falha.motivo, resetEm: conta.falha.resetEm, fonte: conta.falha.fonte,
                             trecho: conta.falha.trecho } } : {}) };
                 const tipo = semTerminal && morte && !incompleto && !conta ? 'sessao_morta' : terminal.classificacao;
                 // I-33 (D12): o perfil sai do rodizio na primeira gravacao do resultado, onde a evidencia esta.
                 if (conta && perfil && !atuais.some(e => e.tipo === 'phase_result' && e.sensorResultId === resultadoId)) {
                     try {
-                        (0, ratelimit_1.marcarContaDaFalha)(carregado, perfil, conta.falha, now);
+                        const marcado = (0, ratelimit_1.marcarContaDaFalha)(carregado, perfil, conta.falha, now);
+                        if (marcado?.esgotadoAte)
+                            contaParaReconciliar = { perfil, falha: conta.falha,
+                                esgotadoAte: marcado.esgotadoAte, erroEm: terminal.timestamp };
                     }
                     catch { /* store ocupado ou invalido: o retry marca de novo pelo gate tipado */ }
                 }
@@ -646,7 +774,11 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
                     (0, ledger_1.registrar)(dir, thread.id, 'phase_result', dados);
                 return { ...base, bytesLidos, concluido: true, classificacao: terminal.classificacao };
             });
-        }) ?? { ...base, ocupado: true };
+        });
+        const episodio = contaParaReconciliar;
+        if (episodio)
+            (0, conta_esgotada_1.reconciliarContaEsgotada)({ raiz: carregado.raiz, agoraMs: now, ...episodio });
+        return observado ?? { ...base, ocupado: true };
     }
     catch (e) {
         // Thread apagada no meio da observação: encerra sem erro, sem recriar a pasta e sem resíduo.
@@ -655,8 +787,8 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
         throw e;
     }
 }
-/** Valida a fonte antes de registro, stderr ou spawn; tambem usada na recuperacao. */
-function validarFonteWatcher(raiz, sessionId, fonte) {
+/** Valida vínculo, variante e perfil sem exigir que o runtime já tenha publicado seus metadados. */
+function validarRegistroWatcher(raiz, sessionId, fonte) {
     const { thread, sessao: registrada } = (0, session_events_1.resolverSessao)(raiz, sessionId);
     const sessao = (0, session_events_1.exigirSessaoDespachada)(registrada, sessionId);
     const dir = (0, thread_1.dirThread)(raiz, thread.id);
@@ -669,12 +801,27 @@ function validarFonteWatcher(raiz, sessionId, fonte) {
     // I-33 (D4): perfil invalido ou divergente do despacho reprova antes de observar pela conta errada.
     (0, runtime_profiles_1.perfilDoRegistro)([...eventos, ...(fonte ? [{ tipo: 'session_sensor_registered', sessionId,
                 despachoEm: sessao.despachadaEm, ...fonte }] : [])], sessao);
+    if (registro.nativo !== undefined && sessao.runtime !== 'claude-bg')
+        throw new Error('fonte nativa claude-agents em sessão de outro runtime');
+    if (registro.controlador && sessao.runtime !== 'codex')
+        throw new Error('fonte do controller Codex em sessão de outro runtime');
+    if (registro.grok !== undefined && sessao.runtime !== 'grok')
+        throw new Error('fonte do grok em sessão de outro runtime');
+    if (sessao.runtime === 'grok' && registro.grok === undefined)
+        throw new Error('sessão grok sem a fonte do grok');
+    return { thread, sessao, dir, eventos, registro };
+}
+/** Validação profunda feita pelo laço: prontidão eventual nunca impede o registro do vínculo. */
+function validarFonteWatcher(raiz, sessionId, fonte) {
+    const { thread, sessao, dir, eventos, registro } = validarRegistroWatcher(raiz, sessionId, fonte);
     if (registro.nativo !== undefined) {
-        if (sessao.runtime !== 'claude-bg')
-            throw new Error('fonte nativa claude-agents em sessão de outro runtime');
         (0, session_watcher_claude_1.validarFonteClaude)(eventos, sessionId, registro);
         return;
     }
+    if (registro.grok !== undefined) {
+        (0, session_watcher_grok_1.validarFonteGrok)(eventos, sessionId, registro, dir);
+        return;
+    }
     if (registro.controlador) {
         const despacho = eventos.filter(e => e.tipo === 'phase_dispatch' && e.sessionId === sessionId).at(-1);
         if (despacho?.controlador !== undefined && despacho.controlador !== registro.controlador)
@@ -690,6 +837,20 @@ function validarFonteWatcher(raiz, sessionId, fonte) {
         (0, codex_controller_sensor_1.lerSnapshotController)(fixada);
     }
 }
+/**
+ * No despacho, fixa a fonte que já está pronta e recusa corrupção permanente antes de
+ * registrar ou iniciar o watcher. A publicação ainda incompleta do controller é deixada
+ * para o laço do watcher, que repete a mesma validação profunda com prazo e diagnóstico.
+ */
+function prepararFonteWatcher(raiz, sessionId, fonte) {
+    try {
+        validarFonteWatcher(raiz, sessionId, fonte);
+    }
+    catch (e) {
+        if (!diagnosticoWatcher(e).transitorio)
+            throw e;
+    }
+}
 function iniciarWatcher(raiz, sessionId) {
     const { thread, sessao: registrada } = (0, session_events_1.resolverSessao)(raiz, sessionId);
     const sessao = (0, session_events_1.exigirSessaoDespachada)(registrada, sessionId);
@@ -697,7 +858,7 @@ function iniciarWatcher(raiz, sessionId) {
     // I-34: sessão claude-bg despachada antes do registro nativo ganha a fonte derivada do despacho.
     if (sessao.runtime === 'claude-bg')
         (0, session_watcher_claude_1.garantirFonteClaude)(raiz, thread, sessao);
-    validarFonteWatcher(raiz, sessionId);
+    validarRegistroWatcher(raiz, sessionId);
     const anterior = (0, ledger_1.lerLedger)(dir).filter(e => e.tipo === 'session_watcher_started' &&
         e.sessionId === sessionId && e.despachoEm === sessao.despachadaEm).at(-1);
     const identidadeAnterior = anterior?.identidade;
@@ -762,7 +923,7 @@ async function acompanhar() {
     try {
         const readyPath = process.argv[5], token = process.argv[6];
         if (readyPath && token) {
-            validarFonteWatcher(carregado.raiz, sessionId);
+            validarRegistroWatcher(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)

package/dist/sessoes-contas.js

@@ -33,8 +33,10 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUNTIMES_DAS_SESSOES = void 0;
 exports.pidVivo = pidVivo;
 exports.ehFantasma = ehFantasma;
+exports.encerradaNaLista = encerradaNaLista;
 exports.contasDeSessoes = contasDeSessoes;
 exports.consultarContas = consultarContas;
 exports.estadosNasContas = estadosNasContas;
@@ -48,6 +50,10 @@ exports.sessoesVivasPorPerfil = sessoesVivasPorPerfil;
  * perfil do store, sem repetir diretorio, e cada sessao volta com o id do perfil dela (nunca o
  * diretorio nem nada de dentro dele).
  *
+ * RM-067 (F4): o `grok` entra com a pasta `sessions/` que o proprio runtime grava em cada casa (`GROK_HOME`), lida so
+ * pelos nomes e pelo mtime do `updates.jsonl`. A conta do processo dele so entra quando essa pasta existe: maquina sem o
+ * `grok` nao ganha fonte nova.
+ *
  * 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.
@@ -56,6 +62,7 @@ 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 grok_1 = require("./adapters/grok");
 const runtime_profiles_1 = require("./runtime-profiles");
 const TERMINAIS = ['done', 'completed', 'exited', 'stopped', 'failed'];
 const estadoDe = (s) => String(s.state ?? s.status ?? '').trim().toLowerCase();
@@ -75,6 +82,14 @@ function pidVivo(pid) {
 function ehFantasma(runtime, s, vivo = pidVivo) {
     return runtime === 'claude-bg' && !TERMINAIS.includes(estadoDe(s)) && !vivo(s.pid);
 }
+/**
+ * RM-037 (ork-rm037esperas, D7): o runtime mostra a sessao encerrada: estado terminal (`done`, `completed`, `exited`,
+ * `stopped`, `failed`) ou fantasma, registro sem processo que trabalhe por ele. Domicilio unico dessa leitura: o portao
+ * de vaga do `ork phase run` (`vagaDoDespacho`) e a capacidade do #Noctum a usam.
+ */
+function encerradaNaLista(s) {
+    return s.fantasma || TERMINAIS.includes(estadoDe(s));
+}
 const real = (dir) => { try {
     return fs.realpathSync(dir);
 }
@@ -99,17 +114,26 @@ function contasDeSessoes(raiz, env = process.env) {
         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));
+                if (exports.RUNTIMES_DAS_SESSOES.includes(d.runtime))
+                    incluir(d.runtime, d, (0, runtime_profiles_1.diretorioDoPerfil)(d));
             }
         }
         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)
+    for (const runtime of runtime_profiles_1.RUNTIMES_COM_INVENTARIO)
         incluir(runtime, null, (0, runtime_profiles_1.diretorioImplicito)(runtime, env));
+    const casaGrok = (0, runtime_profiles_1.diretorioImplicito)('grok', env);
+    if (fs.existsSync(path.join(casaGrok, 'sessions')))
+        incluir('grok', null, casaGrok);
     return { contas, fontes };
 }
+/**
+ * RM-067 (F4): os runtimes cujas sessoes o `ork sessions` lista por conta. O grok entra aqui, e nao em
+ * `RUNTIMES_COM_INVENTARIO`, que tambem diz os runtimes de assinatura do #Noctum (a medicao dele segue sem o grok).
+ */
+exports.RUNTIMES_DAS_SESSOES = [...runtime_profiles_1.RUNTIMES_COM_INVENTARIO, 'grok'];
 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
@@ -145,7 +169,7 @@ function consultarContas(raiz, opcoes = {}) {
                 sessoes.push({ ...s, runtime: 'claude-bg', perfil, fantasma, viva: !fantasma && !TERMINAIS.includes(estadoDe(s)) });
             }
         }
-        else {
+        else if (conta.runtime === 'codex') {
             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,
@@ -155,6 +179,17 @@ function consultarContas(raiz, opcoes = {}) {
                 sessoes.push({ ...s, runtime: 'codex', perfil, fantasma: false, viva: estadoDe(s) !== 'completed' && recente });
             }
         }
+        else if (conta.runtime === 'grok') {
+            // RM-067 (F4): a pasta da sessao que o runtime grava; viva e a escrita recente no updates.jsonl, como no codex.
+            const r = (0, grok_1.consultarSessoesGrok)(conta.dir);
+            const origem = `grok sessions (${rotulo(conta)})`;
+            fontes.push(r.ausente ? { origem, ok: true, ausente: true, detalhe: 'nenhuma sessao grok nesta conta ainda' }
+                : { origem, ok: r.ok, detalhe: r.detalhe });
+            for (const s of r.sessoes) {
+                const recente = typeof s.atividadeEm === 'number' && agoraMs - s.atividadeEm <= janelaMs;
+                sessoes.push({ ...s, runtime: 'grok', perfil, fantasma: false, viva: recente });
+            }
+        }
     }
     return { sessoes, fontes, contas: base.contas };
 }
@@ -167,10 +202,12 @@ function consultarContas(raiz, opcoes = {}) {
 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'))
+    if (claude.length > 0 && !claude.some(f => f.ok) && !r.sessoes.some(s => s.runtime === 'codex' || s.runtime === 'grok'))
         return null;
+    // RM-067 (F4): a sessao grok sem escrita recente fica `idle`; o runtime nao grava estado terminal que o ork leia sem o conteudo.
     return new Map(r.sessoes.map(s => [s.sessionId,
-        s.fantasma ? 'fantasma' : s.runtime === 'codex' ? (s.viva ? 'working' : estadoDe(s)) : estadoDe(s)]));
+        s.fantasma ? 'fantasma' : s.runtime === 'codex' ? (s.viva ? 'working' : estadoDe(s))
+            : s.runtime === 'grok' ? (s.viva ? 'working' : 'idle') : estadoDe(s)]));
 }
 /**
  * RM-056 (D3): sessoes vivas de cada perfil do runtime nesta maquina, a carga do rodizio por

package/dist/sessoes-inventario.js

@@ -71,7 +71,7 @@ function raizesDeRegistros(cwds) {
 function inventariarSessoes(raiz, opcoes = {}) {
     const canonica = (0, estado_thread_1.raizDoEstado)(raiz);
     // 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 contas = (0, sessoes_contas_1.consultarContas)(canonica, { todas: opcoes.todas, ...(opcoes.prazoMs ? { prazoMs: opcoes.prazoMs } : {}) });
     const fontes = contas.fontes;
     const todas = contas.sessoes.map(s => ({ ...s, vinculos: [] }));
     // O cruzamento usa o universo global mesmo quando a apresentação é local.

package/dist/sessoes.js

@@ -54,24 +54,26 @@ const util_1 = require("./util");
 const estado_thread_1 = require("./estado-thread");
 const ledger_1 = require("./ledger");
 const thread_1 = require("./thread");
+const locale_1 = require("./locale");
 function textoDoInventario(r) {
+    const m = (0, locale_1.msg)().operacao.restante.sessions.inventario;
     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}; fantasmas: ${r.fantasmas}; consulta: ${r.ok ? 'válida' : 'INCOMPLETA'}.`,
+        m.abertura(r.escopo.global, r.escopo.usuario, r.escopo.historico),
+        m.fontes(r.fontes.map(f => `${f.origem} (${f.ausente ? m.fonteEstado.ausente : f.ok ? m.fonteEstado.ok : m.fonteEstado.falha})`).join('; ')),
+        m.resumo(r.total, r.semThread, r.ambiguas, r.fantasmas, r.ok),
     ];
     // 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', '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)'])));
+        linhas.push((0, util_1.tabela)([...m.colunas], r.sessoes.map(s => [s.sessionId, s.runtime, s.perfil ?? m.processo,
+            `${s.state ?? s.status ?? m.desconhecido}${s.fantasma ? ` (${m.fantasma})` : ''}`,
+            s.vinculos.map(v => `${v.thread}/${v.fase}`).join(', ') || m.fora])));
     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.');
+        linhas.push(m.explicacaoFantasma);
     for (const f of r.fontes.filter(f => !f.ok))
-        linhas.push(`Falha: ${f.detalhe}`);
+        linhas.push(m.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}` : ''}`);
+        linhas.push(m.ausente(f.detalhe, f.correcao ?? null));
     return linhas.join('\n');
 }
 function tabelaDeSessoes(raiz, todas = false) {
@@ -83,6 +85,7 @@ function tabelaDeSessoes(raiz, todas = false) {
  * viva). So uma conta pode responder; duas viram recusa, nenhuma mantem a mensagem de antes.
  */
 function localizarSessao(chave, raiz) {
+    const m = (0, locale_1.msg)().operacao.restante.sessions.localizar;
     let perfis = [];
     const falhas = [];
     if (raiz) {
@@ -99,10 +102,9 @@ function localizarSessao(chave, raiz) {
         return { achada: r.achadas[0] };
     if (r.achadas.length > 1) {
         const contas = r.achadas.map(a => `${a.perfil?.id ?? 'processo'} (${a.sessao.sessionId})`).join(', ');
-        return { texto: `sessao "${chave}" encontrada em mais de uma conta: ${contas}; use o id completo`, codigo: 1 };
+        return { texto: m.ambigua(chave, contas), codigo: 1 };
     }
-    return { texto: `sessao "${chave}" nao encontrada no runtime` + (falhas.length ? `; contas sem resposta: ${falhas.join('; ')}` : ''),
-        codigo: 1 };
+    return { texto: m.ausente(chave, falhas.join('; ')), codigo: 1 };
 }
 /** Logs de uma sessao pelo id curto, id completo ou nome, lidos na conta onde ela esta. */
 function logsDaSessao(chave, linhas, raiz) {
@@ -120,7 +122,7 @@ function pararSessao(chave, raiz) {
         return l;
     const { sessao, perfil, ambiente } = l.achada;
     const r = adapter.pararAchada(sessao, ambiente);
-    return { texto: r.texto || `sessao ${sessao.sessionId} parada${perfil ? ` (perfil ${perfil.id})` : ''}`, codigo: r.ok ? 0 : 1 };
+    return { texto: r.texto || (0, locale_1.msg)().operacao.restante.sessions.localizar.parada(sessao.sessionId, perfil?.id ?? null), codigo: r.ok ? 0 : 1 };
 }
 /** Comando de attach (precisa de TTY, entao o CLI imprime em vez de executar). */
 function comandoDeAttach(chave, raiz) {
@@ -138,9 +140,9 @@ const ENCERRAM_A_SESSAO = ['phase_result', 'sessao_morta', 'session_superseded']
  */
 function limparFantasmas(raiz, opcoes = {}) {
     const canonica = (0, estado_thread_1.raizDoEstado)(raiz);
-    const inv = (0, sessoes_inventario_1.inventariarSessoes)(canonica, { global: true });
+    const inv = opcoes.inventario ?? (0, sessoes_inventario_1.inventariarSessoes)(canonica, { global: true });
     const itens = [];
-    for (const s of inv.sessoes.filter(x => x.fantasma)) {
+    for (const s of inv.sessoes.filter(x => x.fantasma && (!opcoes.sessoes || opcoes.sessoes.includes(x.sessionId)))) {
         // 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)
@@ -186,18 +188,18 @@ function sessoesSemFim(raiz, threadId) {
     return [...new Set(ids)].filter(id => !encerradas.has(id));
 }
 function textoDaLimpeza(r) {
+    const m = (0, locale_1.msg)().operacao.restante.sessions.limpeza;
     if (r.itens.length === 0)
-        return `Nenhuma sessão fantasma${r.ok ? '' : ' nas contas que responderam'}.` +
-            r.falhas.map(f => `\nFalha: ${f}`).join('');
+        return m.nenhuma(!r.ok) + r.falhas.map(f => `\n${m.falha(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á',
+        solto: r.dryRun ? m.acoes.soltaria : m.acoes.solto,
+        'ja-solto': m.acoes.jaSolto, 'sem-thread': m.acoes.semThread,
+        'outro-projeto': m.acoes.outroProjeto,
     };
     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',
+        m.abertura(r.dryRun),
+        (0, util_1.tabela)([...m.colunas], r.itens.map(i => [i.sessionId, i.perfil ?? m.processo,
             i.thread ? `${i.thread}/${i.fase}` : '-', verbo[i.acao]])),
-        ...r.falhas.map(f => `Falha: ${f}`),
+        ...r.falhas.map(f => m.falha(f)),
     ].join('\n');
 }