@orkastery/cli 0.5.3 → 0.5.6

package/dist/session-watcher-claude.js

@@ -75,6 +75,7 @@ const session_events_1 = require("./session-events");
 const ledger_1 = require("./ledger");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
+const procedencia_1 = require("./procedencia");
 const hitl_1 = require("./hitl");
 /** Uma consulta nativa custa cerca de 0,3 s; cinco segundos mantém o custo abaixo de 10%. */
 exports.INTERVALO_WATCH_CLAUDE_MS = 5000;
@@ -546,6 +547,9 @@ function provaDoOrk(raiz, threadId, sessao, eventos, fonte) {
         const cwd = fonte?.cwd, headNoDespacho = fonte?.head;
         if (!cwd || typeof headNoDespacho !== 'string')
             return falta('HEAD da worktree no despacho não registrado; commit não conferível', { commits: [], recusados: registrados });
+        // RM-047 (P2): o git da prova só roda na worktree registrada; o cwd vem do ledger.
+        if ((0, procedencia_1.cwdLocalOuNulo)(raiz, threadId, cwd, 'ledger') === null)
+            return falta('cwd do despacho fora das worktrees registradas no git; commit não conferível', { commits: [], recusados: registrados });
         const commits = registrados.filter(sha => commitConferido(cwd, sha, headNoDespacho));
         const recusados = registrados.filter(sha => !commits.includes(sha));
         if (!commits.length)
@@ -622,7 +626,9 @@ function garantirFonteClaude(raiz, thread, sessao) {
         if (atual)
             return atual;
         const despacho = eventos.filter(e => e.tipo === 'phase_dispatch' && e.sessionId === sessao.sessionId).at(-1);
-        const cwd = typeof despacho?.cwd === 'string' ? despacho.cwd : thread.worktree ?? raiz;
+        // RM-047 (P2): o cwd do ledger ou do thread.json so vale como worktree registrada no git.
+        const cwd = typeof despacho?.cwd === 'string' ? (0, procedencia_1.exigirCwdLocal)(raiz, thread.id, despacho.cwd, 'ledger')
+            : (0, procedencia_1.diretorioDaThread)(raiz, thread);
         const fonte = { nativo: 'claude-agents', cwd, origem: 'sessions.watch' };
         validarFonteClaude(eventos, sessao.sessionId, fonte);
         if (!(0, ledger_1.registrarSeExiste)(dir, thread.id, 'session_sensor_registered', { fase: sessao.fase, sessionId: sessao.sessionId,

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

@@ -132,7 +132,7 @@ function consultarContas(raiz, opcoes = {}) {
                 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 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.