@orkastery/cli 0.6.3 → 0.6.5

package/dist/session-watcher.js

@@ -62,6 +62,7 @@ const session_watcher_grok_1 = require("./session-watcher-grok");
 const conta_esgotada_1 = require("./conta-esgotada");
 const trabalho_thread_1 = require("./trabalho-thread");
 const pedido_conducao_1 = require("./pedido-conducao");
+const codex_task_complete_1 = require("./codex-task-complete");
 /** O gate estreito da própria sessão vence diagnósticos genéricos do watcher. */
 function pedidoDaConducao(eventos, sessionId, despachoEm) {
     const evento = eventos.filter(e => e.tipo === 'gate_blocked' && e.origem === 'mcp.request_conduction' &&
@@ -389,6 +390,16 @@ function observarSessao(carregado, sessionId, opcoes = {}) {
         return observarSessaoResolvida(carregado, sessionId, resolvida, opcoes);
     }
     catch (e) {
+        if (e.code === 'SESSION_STATE_SPLIT' && threadId) {
+            const thread = (0, thread_1.lerThread)(carregado.raiz, threadId);
+            const registrada = thread.sessoes.find(s => s.sessionId === sessionId);
+            if (registrada) {
+                const sessao = (0, session_events_1.exigirSessaoDespachada)(registrada, sessionId);
+                const prova = (0, codex_task_complete_1.taskCompleteFixadoDaSessao)(carregado.raiz, thread, sessao, (0, ledger_1.lerLedger)((0, thread_1.dirThread)(carregado.raiz, threadId)), opcoes.agoraMs ?? Date.now());
+                if (prova)
+                    return observarSessaoResolvida(carregado, sessionId, { thread, sessao }, { ...opcoes, taskCompleteFixado: prova });
+            }
+        }
         if (threadId)
             tentarRegistrarErroWatcher(carregado.raiz, threadId, sessionId, e);
         throw e;
@@ -542,7 +553,8 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
             return desfazer();
         if (sessao.runtime === 'claude-bg') {
             const r = comLockWatcher(pasta, () => (0, session_watcher_claude_1.observarClaudeSobLock)({ raiz: carregado.raiz,
-                thread, sessao, dir, pasta, chave, agoraMs: now, limiteMs: exports.LIMITE_MORTE_MS, consulta: opcoes.consultaClaude, carregado })) ?? { ...base, ocupado: true };
+                thread, sessao, dir, pasta, chave, agoraMs: now, limiteMs: exports.LIMITE_MORTE_MS, consulta: opcoes.consultaClaude,
+                tela: opcoes.telaClaude, carregado })) ?? { ...base, ocupado: true };
             return (0, ledger_1.threadPresente)(dir) ? r : desfazer();
         }
         // RM-067 (F2): o grok tem observador próprio (stream, recibo do supervisor e pasta da sessão), no mesmo lock.
@@ -565,6 +577,7 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
             const perfil = (0, runtime_profiles_1.perfilDoRegistro)(eventos, sessao);
             // Fonte do controller validada ANTES de ler rollout ou escrever cursor.
             let fonteControlador = null, snapshot = null;
+            let taskCompleteFixado = opcoes.taskCompleteFixado ?? null;
             let cwdDespacho;
             if (registro?.controlador) {
                 const despacho = eventos.filter(e => e.tipo === 'phase_dispatch' && e.sessionId === sessionId).at(-1);
@@ -580,7 +593,16 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
                     vinculo: { thread: thread.id, fase: sessao.fase, promptSha256: sessao.promptSha256 }
                 });
                 // Relógio injetado vale como está; o real é lido pelo sensor depois do state.json.
-                snapshot = (0, codex_controller_sensor_1.lerSnapshotController)(fonteControlador, opcoes.agoraMs === undefined ? {} : { agoraMs: now });
+                try {
+                    snapshot = (0, codex_controller_sensor_1.lerSnapshotController)(fonteControlador, opcoes.agoraMs === undefined ? {} : { agoraMs: now });
+                }
+                catch (e) {
+                    // A varredura integral e excepcional: no fluxo saudável o cursor incremental
+                    // reconhece task_complete sem reler todo o rollout a cada polling.
+                    taskCompleteFixado ??= (0, codex_task_complete_1.taskCompleteFixadoDaFonte)(fonteControlador, now);
+                    if (!taskCompleteFixado)
+                        throw e;
+                }
             }
             const file = path.join(pasta, 'cursor.json');
             const cursor = lerJson(file) ?? { schema: 'ork.session-cursor/v1', sessionId,
@@ -590,7 +612,7 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
             // Cursor anterior media bytes, nao progresso: migracao conservadora desde o despacho.
             cursor.progressoEm ??= Date.parse(sessao.despachadaEm);
             // Transporte do controller não admite descoberta nem override de rollout.
-            const fontes = { stream: registro?.logPath, rollout: snapshot ? snapshot.rollout
+            const fontes = { stream: registro?.logPath, rollout: fonteControlador ? fonteControlador.rollout
                     : opcoes.rollout === undefined ? (0, codex_1.acharRollout)(sessionId, 3, (0, codex_1.casaDoCodex)(perfil)) : opcoes.rollout };
             let bytesLidos = 0, temMais = false, cresceu = false;
             for (const [nome, fonte] of Object.entries(fontes)) {
@@ -673,7 +695,10 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
                 return tempo || (y.numeroTurno ?? 0) - (x.numeroTurno ?? 0) ||
                     ordem[x.classificacao] - ordem[y.classificacao] || a.nome.localeCompare(b.nome);
             });
-            let terminal = terminais[0]?.terminal;
+            const taskCompleteDoCursor = fonteControlador ? terminais.find(({ nome, terminal: atual }) => nome === 'rollout' && atual.fonte === 'rollout.task_complete')?.terminal : undefined;
+            let terminal = taskCompleteFixado?.terminal ?? taskCompleteDoCursor ?? terminais[0]?.terminal;
+            const taskCompleteAutenticado = terminal !== undefined &&
+                (terminal === taskCompleteFixado?.terminal || terminal === taskCompleteDoCursor);
             const fontesAtuais = Object.values(cursor.fontes);
             const aberto = fontesAtuais.some(f => {
                 if (!f.parser.turnoAberto)
@@ -700,22 +725,23 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
             const invalido = fontesAtuais.some(f => f.parser.invalido);
             // Conclusão nativa é medida em todo terminal, independente da política de retry:
             // bloqueio sem retry preserva o motivo, mas não prova que o turno do runtime terminou.
-            const provaNativa = snapshot && terminal
+            const provaNativa = taskCompleteAutenticado ? null : snapshot && terminal
                 ? semProvaNativa(snapshot, terminal, terminais[0]?.nome, fechamento, sessionId, cwdDespacho)
                 : 'terminal nativo do controller ausente';
             // Parecer negativo também exige conclusão nativa inteira: texto claims.failed de
             // turno interrompido não pode virar rejeição autenticada de um objetivo.
-            const semProva = snapshot && terminal && terminal.classificacao !== 'human.pending' && !bloqueioPreservado(terminal)
+            const semProva = !taskCompleteAutenticado && snapshot && terminal && terminal.classificacao !== 'human.pending' && !bloqueioPreservado(terminal)
                 ? provaNativa : null;
             const descorrelacionado = !!semProva;
-            const incompleto = semCloseNoLimite && (!!terminal || estado !== 'ausente' || aberto || parcial || invalido) || !backlog && (((parcial || aberto || invalido || descorrelacionado || !terminal) && !!fechamento) ||
+            const observacaoInvalida = !taskCompleteAutenticado && (invalido || aberto || descorrelacionado);
+            const incompleto = !taskCompleteAutenticado && (semCloseNoLimite && (!!terminal || estado !== 'ausente' || aberto || parcial || invalido) || !backlog && (((parcial || aberto || invalido || descorrelacionado || !terminal) && !!fechamento) ||
                 (estavel && (parcial || (aberto && estado === 'ausente') ||
-                    (supervisionado && estado === 'desconhecido'))));
+                    (supervisionado && estado === 'desconhecido')))));
             const morte = estado === 'ausente' && estavel && !temMais;
             // Fechamento supervisionado precisa existir antes de associar o código de saída ao turno.
-            const podeTerminar = !esperaHumana && (incompleto || (!temMais && !aberto &&
+            const podeTerminar = taskCompleteAutenticado || !esperaHumana && (incompleto || (!temMais && !aberto &&
                 ((terminal && (fechamento || !supervisionado)) || morte)));
-            const conta = falhaDeContaDoTerminal(terminal, !invalido && !aberto, snapshot, now);
+            const conta = falhaDeContaDoTerminal(terminal, taskCompleteAutenticado || !invalido && !aberto, snapshot, now);
             (0, codex_runner_1.gravarAtomico)(file, cursor);
             return (0, session_events_1.comLockDeSessao)(dir, () => {
                 const atuais = (0, ledger_1.lerLedger)(dir);
@@ -735,9 +761,9 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
                 const pedido = pedidoDaConducao(atuais, sessionId, sessao.despachadaEm);
                 const semTerminal = !terminal;
                 // Fato registrado para a autoridade de revisão: `null` só com terminal nativo correlacionado.
-                const conclusaoNativa = incompleto || invalido || aberto || descorrelacionado
+                const conclusaoNativa = incompleto || observacaoInvalida
                     ? provaNativa ?? 'observação incompleta ou inválida' : provaNativa;
-                if (incompleto || invalido || aberto || descorrelacionado)
+                if (incompleto || observacaoInvalida)
                     terminal = { classificacao: 'gate_blocked', motivo: 'runtime.unavailable',
                         timestamp: new Date(now).toISOString(), turnId: null, fonte: semProva ?? 'observação incompleta ou inválida',
                         tokens: new codex_events_1.ParserCodex().estado.tokens, duracaoMs: null };
@@ -745,12 +771,12 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
                     terminal = { classificacao: 'gate_blocked', motivo: 'runtime.silencio',
                         timestamp: new Date(now).toISOString(), turnId: null, fonte: 'processo ausente e arquivos estáveis',
                         tokens: new codex_events_1.ParserCodex().estado.tokens, duracaoMs: null };
-                if (pedido && (terminal.classificacao === 'fase_concluida' ||
+                if (pedido && (taskCompleteAutenticado || terminal.classificacao === 'fase_concluida' ||
                     terminal.classificacao === 'gate_blocked' && ['runtime.unavailable', 'runtime.silencio'].includes(terminal.motivo ?? ''))) {
                     terminal = { ...terminal, classificacao: 'gate_blocked', motivo: pedido.motivo,
                         fonte: `mcp.request_conduction: ${pedido.detalhe}` };
                 }
-                if (fechamento && (fechamento.exitCode !== 0 || fechamento.signal || fechamento.erro) &&
+                if (!taskCompleteAutenticado && fechamento && (fechamento.exitCode !== 0 || fechamento.signal || fechamento.erro) &&
                     terminal.classificacao !== 'human.pending' && !bloqueioPreservado(terminal)) {
                     terminal = { ...terminal, classificacao: 'gate_blocked', motivo: 'runtime.unavailable' };
                 }
@@ -761,16 +787,19 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
                         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 taskCompleteBloqueado = taskCompleteAutenticado && terminal.classificacao !== 'fase_concluida';
                 const dados = { fase: sessao.fase, sessionId, despachoEm: sessao.despachadaEm, sensorResultId: resultadoId,
                     classificacao: terminal.classificacao, motivo: terminal.motivo, runtime: 'codex', fonte: terminal.fonte,
-                    fonteVencedora: pedido || incompleto || invalido || aberto || descorrelacionado ? null : terminais[0]?.nome ?? null,
+                    fonteVencedora: pedido ? null : taskCompleteAutenticado ? 'rollout'
+                        : incompleto || invalido || aberto || descorrelacionado ? null : terminais[0]?.nome ?? null,
                     turnId: terminal.turnId, numeroTurno: terminal.numeroTurno ?? null,
                     tokens: terminal.tokens, exitCode: fechamento?.exitCode ?? null, exitCodeFonte: fechamento?.fonte ?? 'unavailable',
                     signal: fechamento?.signal ?? null, duracaoMs: fechamento?.duracaoMs ?? terminal.duracaoMs,
                     duracaoFonte: fechamento?.fonte ?? (terminal.duracaoMs === null ? 'unavailable' : terminal.fonte),
-                    ok: terminal.classificacao === 'fase_concluida' && fechamento?.exitCode === 0,
-                    conclusaoNativa: conclusaoNativa === null,
-                    conclusaoNativaAusente: conclusaoNativa,
+                    ok: terminal.classificacao === 'fase_concluida' && (taskCompleteAutenticado || fechamento?.exitCode === 0),
+                    conclusaoNativa: conclusaoNativa === null && !taskCompleteBloqueado,
+                    conclusaoNativaAusente: taskCompleteBloqueado
+                        ? 'task_complete encerrou o turno com resultado bloqueado' : conclusaoNativa,
                     estado: terminal.classificacao === 'fase_concluida' ? 'concluida' : 'bloqueada',
                     observadoEm: terminal.timestamp, gate: 'phase.dispatch', origem: 'sessions.watch',
                     morteLatenciaMs: morte ? now - cursor.progressoEm : null, ...(perfil ? { perfil } : {}),

package/dist/ship.js

@@ -51,6 +51,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MODOS_QUE_AUTORIZAM_PUSH = void 0;
+exports.verificacaoCompletaParaShip = verificacaoCompletaParaShip;
 exports.commitQueIncorporou = commitQueIncorporou;
 exports.autorizacaoDePush = autorizacaoDePush;
 exports.arvoreComBranch = arvoreComBranch;
@@ -88,6 +89,10 @@ const mcp_ship_transporte_1 = require("./mcp-ship-transporte");
 const branch_de_estado_1 = require("./branch-de-estado");
 const locale_1 = require("./locale");
 const noctum_guarda_1 = require("./noctum-guarda");
+/** RM-081 F3: `ok` nunca basta quando a rodada nao cobriu a suite inteira. */
+function verificacaoCompletaParaShip(verificacao) {
+    return verificacao.ok && !verificacao.parcial;
+}
 /**
  * RM-037 (fatia 5, A1): o commit de primeiro pai da base que incorporou o `shaDe`: o merge que trouxe a branch, ou
  * o proprio `shaDe` quando a base avancou por fast-forward ate ele. Com a branch ja incorporada, a ponta da base e
@@ -556,9 +561,10 @@ function ship(carregado, threadId, opcoes) {
     const verificacao = (0, verify_1.verificar)(carregado, threadId, { executor: opcoes.executorVerify,
         conducao: { filaPesada: { ...opcoes.avisoDaFilaPesada, esperarMs: opcoes.esperarFilaPesadaMs } } });
     r.verificacao = verificacao;
-    if (!verificacao.ok) {
-        const motivo = verificacao.motivos.find((m) => m !== 'claims.unverifiable');
-        return bloquear(motivo, (0, locale_1.textoDoCatalogo)((m) => m.ship.verificacaoReprovou(verificacao.commit, verificacao.motivos.join(', '))), (0, locale_1.textoDoCatalogo)((m) => m.ship.rodeVerify(threadId)));
+    if (!verificacaoCompletaParaShip(verificacao)) {
+        const motivo = (verificacao.parcial ? 'verify.failed'
+            : verificacao.motivos.find((m) => m !== 'claims.unverifiable'));
+        return bloquear(motivo, (0, locale_1.textoDoCatalogo)((m) => m.ship.verificacaoReprovou(verificacao.commit, verificacao.parcial ? 'verify.parcial' : verificacao.motivos.join(', '))), (0, locale_1.textoDoCatalogo)((m) => m.ship.rodeVerify(threadId)));
     }
     // Referencias locais, resolvidas antes de tomar o lease.
     const shaDe = shaDaRef(raiz, `refs/heads/${de}`);