@orkastery/cli 0.6.4 → 0.6.6

package/dist/session-watcher.js

@@ -39,6 +39,8 @@ exports.reconciliarSessaoSemWatcher = reconciliarSessaoSemWatcher;
 exports.validarRegistroWatcher = validarRegistroWatcher;
 exports.validarFonteWatcher = validarFonteWatcher;
 exports.prepararFonteWatcher = prepararFonteWatcher;
+exports.esperarProntidaoWatcher = esperarProntidaoWatcher;
+exports.esperarConfirmacaoDoPaiWatcher = esperarConfirmacaoDoPaiWatcher;
 exports.iniciarWatcher = iniciarWatcher;
 exports.acompanharSessao = acompanharSessao;
 /** D6: observador restrito a uma sessão, cursor canônico e resultados idempotentes. */
@@ -62,6 +64,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 +392,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 +555,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 +579,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 +595,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 +614,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 +697,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 +727,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 +763,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 +773,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 +789,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 } : {}),
@@ -877,6 +908,61 @@ function prepararFonteWatcher(raiz, sessionId, fonte) {
             throw e;
     }
 }
+class ErroDoApertoWatcher extends Error {
+    encerrarOutro;
+    constructor(message, encerrarOutro) {
+        super(message);
+        this.encerrarOutro = encerrarOutro;
+    }
+}
+const TETO_ABSOLUTO_APERTO_WATCHER_MS = 60000;
+const PAUSA_APERTO_WATCHER = new Int32Array(new SharedArrayBuffer(4));
+function conferirTetoDoAperto(tetoMs) {
+    if (!Number.isFinite(tetoMs) || tetoMs <= 0)
+        throw new Error('teto invalido para o aperto de mao do watcher');
+}
+/** Lado do dispatcher: lentidao nao encerra um watcher cuja identidade continua viva. */
+function esperarProntidaoWatcher(lerSinal, identidade, opcoes = {}) {
+    const agora = opcoes.agora ?? Date.now;
+    const estado = opcoes.estado ?? codex_runner_1.estadoProcesso;
+    const pausar = opcoes.pausar ?? ((ms) => { Atomics.wait(PAUSA_APERTO_WATCHER, 0, 0, ms); });
+    const tetoProntidaoMs = opcoes.tetoMs ?? TETO_ABSOLUTO_APERTO_WATCHER_MS;
+    conferirTetoDoAperto(tetoProntidaoMs);
+    const inicio = agora();
+    for (;;) {
+        if (agora() - inicio >= tetoProntidaoMs)
+            throw new ErroDoApertoWatcher('watcher sem prontidao confirmada', true);
+        const sinal = lerSinal();
+        if (sinal === 'confirmado')
+            return;
+        if (sinal === 'invalido')
+            throw new ErroDoApertoWatcher('watcher com prontidao invalida', true);
+        if (estado(identidade) === 'ausente')
+            throw new ErroDoApertoWatcher('watcher sem prontidao confirmada', false);
+        const restante = tetoProntidaoMs - (agora() - inicio);
+        pausar(Math.min(10, Math.max(1, restante)));
+    }
+}
+/** Lado do watcher: o ack continua pendente somente enquanto o pai capturado na partida nao saiu. */
+async function esperarConfirmacaoDoPaiWatcher(lerSinal, identidadePai, opcoes = {}) {
+    const agora = opcoes.agora ?? Date.now;
+    const estado = opcoes.estado ?? codex_runner_1.estadoProcesso;
+    const pausar = opcoes.pausar ?? ((ms) => new Promise(resolve => setTimeout(resolve, ms)));
+    const tetoConfirmacaoMs = opcoes.tetoMs ?? TETO_ABSOLUTO_APERTO_WATCHER_MS;
+    conferirTetoDoAperto(tetoConfirmacaoMs);
+    const inicio = agora();
+    for (;;) {
+        if (agora() - inicio >= tetoConfirmacaoMs)
+            throw new ErroDoApertoWatcher('watcher sem confirmacao do pai', false);
+        const sinal = lerSinal();
+        if (sinal === 'confirmado')
+            return;
+        if (sinal === 'invalido' || estado(identidadePai) === 'ausente')
+            throw new ErroDoApertoWatcher('watcher sem confirmacao do pai', false);
+        const restante = tetoConfirmacaoMs - (agora() - inicio);
+        await pausar(Math.min(10, Math.max(1, restante)));
+    }
+}
 function iniciarWatcher(raiz, sessionId) {
     const { thread, sessao: registrada } = (0, session_events_1.resolverSessao)(raiz, sessionId);
     const sessao = (0, session_events_1.exigirSessaoDespachada)(registrada, sessionId);
@@ -918,27 +1004,29 @@ function iniciarWatcher(raiz, sessionId) {
     try {
         if (!identidade)
             throw new Error('watcher sem identidade de processo');
-        const deadline = Date.now() + 5000;
-        const pausa = new Int32Array(new SharedArrayBuffer(4));
-        while (Date.now() < deadline) {
-            const ready = lerJson(readyPath);
-            if (ready && ready.token === token && ready.sessionId === sessionId && ready.despachoEm === sessao.despachadaEm &&
-                JSON.stringify(ready.identidade) === JSON.stringify(identidade) && (0, codex_runner_1.estadoProcesso)(identidade) === 'vivo') {
-                (0, ledger_1.registrar)(dir, thread.id, 'session_watcher_started', { fase: sessao.fase, sessionId,
-                    despachoEm: sessao.despachadaEm, pid: identidade.pid, identidade, readyPath, token });
-                (0, codex_runner_1.gravarAtomico)(ackPath, { token });
-                return identidade.pid;
+        esperarProntidaoWatcher(() => {
+            if (!fs.existsSync(readyPath))
+                return 'pendente';
+            let ready;
+            try {
+                ready = lerJson(readyPath);
             }
-            if ((0, codex_runner_1.estadoProcesso)(identidade) === 'ausente')
-                break;
-            Atomics.wait(pausa, 0, 0, 10);
-        }
-        throw new Error('watcher sem prontidao confirmada');
+            catch {
+                return 'invalido';
+            }
+            return ready && ready.token === token && ready.sessionId === sessionId && ready.despachoEm === sessao.despachadaEm &&
+                JSON.stringify(ready.identidade) === JSON.stringify(identidade) && (0, codex_runner_1.estadoProcesso)(identidade) === 'vivo'
+                ? 'confirmado' : 'invalido';
+        }, identidade);
+        (0, ledger_1.registrar)(dir, thread.id, 'session_watcher_started', { fase: sessao.fase, sessionId,
+            despachoEm: sessao.despachadaEm, pid: identidade.pid, identidade, readyPath, token });
+        (0, codex_runner_1.gravarAtomico)(ackPath, { token });
+        return identidade.pid;
     }
     catch (e) {
         falha();
-        // Encerrar apenas o filho cuja identidade continua sendo a capturada no spawn.
-        if (identidade && (0, codex_runner_1.estadoProcesso)(identidade) === 'vivo')
+        // Lentidao dentro do teto nao encerra o filho; so teto ou prontidao invalida autorizam o sinal.
+        if (e instanceof ErroDoApertoWatcher && e.encerrarOutro && identidade && (0, codex_runner_1.estadoProcesso)(identidade) === 'vivo')
             child.kill('SIGTERM');
         throw e;
     }
@@ -949,18 +1037,30 @@ async function acompanhar() {
     try {
         const readyPath = process.argv[5], token = process.argv[6];
         if (readyPath && token) {
+            const identidadePai = (0, codex_runner_1.identidadeProcesso)(process.ppid);
+            if (!identidadePai)
+                throw new Error('watcher sem confirmacao do pai');
             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)
                 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 esperarConfirmacaoDoPaiWatcher(() => {
+                if (!(0, ledger_1.threadPresente)((0, thread_1.dirThread)(carregado.raiz, threadId)))
+                    return 'invalido';
+                const ackPath = readyPath + '.ack';
+                if (!fs.existsSync(ackPath))
+                    return 'pendente';
+                let ack;
+                try {
+                    ack = lerJson(ackPath);
+                }
+                catch {
+                    return 'invalido';
+                }
+                return ack?.token === token ? 'confirmado' : 'invalido';
+            }, identidadePai);
         }
         await acompanharSessao(carregado, sessionId, { threadId });
     }

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}`);