@orkastery/cli 0.5.1 → 0.5.6

package/dist/verify.js

@@ -13,10 +13,12 @@
  *      declarada como `verify.failed`, e nao como regressao que nao da para provar.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PREFIXO_BLOQUEADO_NO_VERIFY = exports.TIMEOUT_VERIFY_MS = void 0;
+exports.ESPERA_PADRAO_DA_FILA_PESADA_MS = exports.ESPERA_DA_FILA_PESADA_MS = exports.PREFIXO_BLOQUEADO_NO_VERIFY = exports.TIMEOUT_VERIFY_MS = void 0;
 exports.ambienteDoVerify = ambienteDoVerify;
 exports.prazoDoComando = prazoDoComando;
 exports.executar = executar;
+exports.semVereditoPorTempo = semVereditoPorTempo;
+exports.executorComSteal = executorComSteal;
 exports.identidadeDoProduto = identidadeDoProduto;
 exports.causaDoEncerramento = causaDoEncerramento;
 exports.comandoNoLedger = comandoNoLedger;
@@ -36,9 +38,14 @@ const node_path_1 = require("node:path");
 const node_crypto_1 = require("node:crypto");
 const util_1 = require("./util");
 const horario_1 = require("./horario");
+const locale_1 = require("./locale");
 const redacao_saida_1 = require("./redacao-saida");
+const steal_1 = require("./steal");
+const instabilidade_1 = require("./instabilidade");
+const fila_pesada_1 = require("./fila-pesada");
 const redacao_url_1 = require("./redacao-url");
 const conducao_1 = require("./conducao");
+const procedencia_1 = require("./procedencia");
 /** Teto de tempo de um comando de verificacao (build e suite completa cabem). */
 exports.TIMEOUT_VERIFY_MS = 10 * 60 * 1000;
 /** Ultimas linhas da saida real, o suficiente para servir de evidencia no ledger. */
@@ -103,10 +110,39 @@ function executar(nome, comando, cwd, tetoMs = exports.TIMEOUT_VERIFY_MS) {
         const testes = (0, redacao_saida_1.testesQueCairam)(saida);
         if (testes.length > 0)
             resultado.testeQueCaiu = testes;
+        const falhas = (0, redacao_saida_1.falhasDeTeste)(saida);
+        if (falhas.length > 0)
+            resultado.falhasDeTeste = falhas;
         resultado.trecho = (0, redacao_saida_1.redigirSaida)(saida);
     }
     return resultado;
 }
+/**
+ * RM-037 (fatia 6): o comando nao tem veredito. Estouro de prazo, ou reprovacao so de teste com relogio
+ * sob steal acima de 40%: a maquina, e nao o codigo, decidiu o resultado.
+ */
+function semVereditoPorTempo(c) {
+    return c.causa === 'timeout' || (c.relogioSobSteal?.length ?? 0) > 0;
+}
+/**
+ * RM-037 (fatia 6): mede o steal na janela de cada comando e marca a reprovacao que foi so de teste com
+ * relogio sob steal alto. Os testes de relogio sao os da assinatura de prazo do runner e os do registro
+ * de instabilidade vigente. Comando que passou, estourou ou nem rodou so ganha a medida.
+ */
+function executorComSteal(base, leitor = steal_1.lerProcStat, registro = new Set()) {
+    return (nome, comando, cwd) => {
+        const janela = (0, steal_1.abrirJanela)(leitor);
+        const r = base(nome, comando, cwd);
+        const stealPct = janela.fechar();
+        const resultado = { ...r, stealPct };
+        if (!r.ok && r.causa !== 'timeout' && r.executado !== false && (0, steal_1.stealAlto)(stealPct)) {
+            const testes = (0, steal_1.reprovacaoSoDeRelogio)(r.falhasDeTeste, registro);
+            if (testes)
+                resultado.relogioSobSteal = testes;
+        }
+        return resultado;
+    };
+}
 /** I-54 (D11): erros de spawn em que o processo nem chegou a existir. */
 const NAO_LANCADO = new Set(['ENOENT', 'EACCES', 'EAGAIN', 'ENOMEM', 'EPERM', 'EMFILE']);
 /**
@@ -164,6 +200,8 @@ function comandoNoLedger(c) {
         ...(c.duracaoMs !== undefined ? { duracaoMs: c.duracaoMs } : {}),
         ...(c.testeQueCaiu?.length ? { testeQueCaiu: c.testeQueCaiu } : {}),
         ...(c.trecho !== undefined ? { trecho: c.trecho } : {}),
+        ...(c.stealPct !== undefined ? { stealPct: c.stealPct } : {}),
+        ...(c.relogioSobSteal?.length ? { relogioSobSteal: c.relogioSobSteal } : {}),
     };
 }
 /** Comandos declarados em `verify:` no manifesto, na ordem canonica. */
@@ -176,15 +214,35 @@ function comandosDoManifesto(manifesto) {
     }
     return lista;
 }
-/** Diretorio onde a verificacao roda: a worktree da thread, ou a raiz do projeto. */
+/**
+ * Diretorio onde a verificacao roda: a worktree da thread, ou a raiz do projeto. RM-047 (P2): a worktree
+ * do `thread.json` so vale registrada no `git worktree list` e com o estado local (`estado.rastreado`,
+ * `estado.worktree-nao-registrada`).
+ */
 function cwdDaThread(raiz, thread) {
-    return thread.worktree ?? raiz;
+    return (0, procedencia_1.diretorioDaThread)(raiz, thread);
 }
 /** HEAD real do diretorio de trabalho, carimbado em toda verificacao. */
 function commitReal(cwd) {
     const r = (0, util_1.exec)('git', ['rev-parse', 'HEAD'], cwd);
     return r.ok ? r.stdout.trim() : util_1.COMMIT_DESCONHECIDO;
 }
+/** RM-058 N2 (D10): quanto o `ork verify` do CLI espera a vez na fila pesada sem `--esperar`. */
+exports.ESPERA_DA_FILA_PESADA_MS = 60 * 60 * 1000;
+/** RM-058 N2 (GO-FIX 1, B1 e A9 do CHECK): a espera de quem verifica por dentro de outro comando e nao disse prazo. */
+exports.ESPERA_PADRAO_DA_FILA_PESADA_MS = 30_000;
+/**
+ * RM-058 N2 (D9 e D10 da ork-rm058n2): a rodada inteira na fila de recursos pesados, depois da conducao. O
+ * artefato e o diretorio de trabalho da thread; as vagas sao `concurrency.max_parallel_heavy` (0 desliga). Sem a
+ * vez no prazo, `ErroDaFilaPesada` sai antes de qualquer comando rodar e de qualquer evento ir ao ledger.
+ */
+function naFilaPesada(carregado, threadId, operacao, conducao, executar) {
+    const cwd = cwdDaThread(carregado.raiz, (0, thread_1.lerThread)(carregado.raiz, threadId));
+    const espera = conducao.filaPesada?.esperarMs ?? conducao.esperarMs ?? exports.ESPERA_PADRAO_DA_FILA_PESADA_MS;
+    return (0, fila_pesada_1.comRecursoPesado)(carregado.raiz, { artefato: cwd, operacao, thread: threadId,
+        slots: carregado.manifesto.concurrency.max_parallel_heavy, esperarMs: espera, aoEsperar: conducao.filaPesada?.aoEsperar,
+        comandoDeEsperar: conducao.filaPesada?.comandoDeEsperar }, executar);
+}
 /** O pedido de conducao de uma verificacao, com o prazo derivado dos comandos que ela vai rodar (D3). */
 function pedidoDoVerify(carregado, threadId, operacao, comandos, conducao) {
     return {
@@ -206,7 +264,7 @@ function executorSobConducao(base, manifesto, conducao) {
 /** `ork verify --baseline`: grava o estado do mundo ANTES do GO. */
 function gravarBaseline(carregado, threadId, executor = executar, conducao = {}, origem = 'cli') {
     const pedido = pedidoDoVerify(carregado, threadId, 'baseline', comandosDoManifesto(carregado.manifesto).length, conducao);
-    return (0, conducao_1.comConducao)(carregado.raiz, threadId, pedido, (tomada) => gravarBaselineSobConducao(carregado, threadId, executorSobConducao(executor, carregado.manifesto, tomada), origem));
+    return (0, conducao_1.comConducao)(carregado.raiz, threadId, pedido, (tomada) => naFilaPesada(carregado, threadId, 'baseline', conducao, () => gravarBaselineSobConducao(carregado, threadId, executorSobConducao(executor, carregado.manifesto, tomada), origem)));
 }
 function gravarBaselineSobConducao(carregado, threadId, executor, origem) {
     const { raiz, manifesto } = carregado;
@@ -239,9 +297,7 @@ function verificarClaim(claim, cwd, executor = executar) {
             verificado: false,
             // Alegacao negativa sem comando e reprovacao (caso EvoJ6); positiva e aviso.
             motivo: negativa ? 'claims.failed' : 'claims.unverifiable',
-            detalhe: negativa
-                ? 'alegacao negativa/absoluta sem comando de verificacao: nao ha como comprova-la'
-                : 'sem comando de verificacao declarado',
+            detalhe: (0, locale_1.textoDoCatalogo)((m) => negativa ? m.verify.claimNegativaSemComando : m.verify.claimSemComando),
             execucoes: [],
         };
     }
@@ -253,22 +309,25 @@ function verificarClaim(claim, cwd, executor = executar) {
             claim,
             verificado: false,
             motivo: 'verify.sem-veredito',
-            detalhe: `comando "${(0, redacao_url_1.redigirCredenciaisUrl)(naoRodou.comando)}" nao foi executado: ${naoRodou.resumo}`,
+            detalhe: (0, locale_1.textoDoCatalogo)((m) => m.verify.claimNaoExecutada((0, redacao_url_1.redigirCredenciaisUrl)(naoRodou.comando), naoRodou.resumo)),
             execucoes,
         };
     }
     const falhou = execucoes.find((e) => !e.ok);
-    // I-37 (D1): estouro de prazo nao desmente a alegacao; a prova so nao chegou ao fim.
-    const estourou = falhou?.causa === 'timeout';
+    // I-37 (D1): estouro de prazo nao desmente a alegacao; a prova so nao chegou ao fim. RM-037 (fatia 6):
+    // nem a reprovacao so de teste com relogio sob steal acima de 40%.
+    const estourou = !!falhou && semVereditoPorTempo(falhou);
     return {
         claim,
         verificado: !falhou,
         motivo: falhou ? (estourou ? 'verify.timeout' : 'claims.failed') : null,
-        detalhe: falhou
+        detalhe: (0, locale_1.textoDoCatalogo)((m) => falhou
             ? estourou
-                ? `comando "${falhou.comando}" estourou o prazo de ${Math.round((falhou.prazoMs ?? 0) / 1000)} s sem terminar`
-                : `comando "${(0, redacao_url_1.redigirCredenciaisUrl)(falhou.comando)}" saiu com codigo ${falhou.code}`
-            : `${execucoes.length} comando(s) reexecutado(s) com sucesso`,
+                ? falhou.causa === 'timeout'
+                    ? m.verify.claimEstourou(falhou.comando, Math.round((falhou.prazoMs ?? 0) / 1000))
+                    : m.verify.claimRelogio((0, redacao_url_1.redigirCredenciaisUrl)(falhou.comando), falhou.stealPct, steal_1.LIMIAR_STEAL_PCT, falhou.relogioSobSteal.join(', '))
+                : m.verify.claimSaiu((0, redacao_url_1.redigirCredenciaisUrl)(falhou.comando), falhou.code)
+            : m.verify.claimOk(execucoes.length)),
         execucoes,
     };
 }
@@ -281,9 +340,9 @@ function verificar(carregado, threadId, opcoes = {}) {
     const planejados = (0, claims_1.lerClaims)(carregado.raiz, threadId).filter((c) => c.estado !== 'retirada')
         .reduce((n, c) => n + c.verificar.length, 0) + (opcoes.soClaims ? 0 : comandosDoManifesto(carregado.manifesto).length) + 1;
     const pedido = pedidoDoVerify(carregado, threadId, opcoes.operacao ?? 'verify', planejados, opcoes.conducao ?? {});
-    return (0, conducao_1.comConducao)(carregado.raiz, threadId, pedido, (tomada) => verificarSobConducao(carregado, threadId, opcoes, tomada, pedido.canal));
+    return (0, conducao_1.comConducao)(carregado.raiz, threadId, pedido, (tomada) => naFilaPesada(carregado, threadId, 'verify', opcoes.conducao ?? {}, (uso) => verificarSobConducao(carregado, threadId, opcoes, tomada, pedido.canal, uso)));
 }
-function verificarSobConducao(carregado, threadId, opcoes, conducao, canal) {
+function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, filaPesada) {
     const { raiz, manifesto } = carregado;
     const thread = (0, thread_1.lerThread)(raiz, threadId);
     const cwd = cwdDaThread(raiz, thread);
@@ -294,10 +353,14 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal) {
     // `ork verify` roda em toda fase, e uma claim por criterio por rodada viraria
     // acumulador em vez de verificacao.
     (0, claims_1.registrarCriteriosDePronto)(raiz, threadId);
+    // RM-037 (fatia 6): o registro de instabilidade da arvore verificada e a janela de steal da rodada.
+    const instabilidade = (0, instabilidade_1.lerRegistroDeInstabilidade)(cwd, opcoes.agoraMs);
+    const leitor = opcoes.lerProcStat ?? steal_1.lerProcStat;
+    const janelaDaRodada = (0, steal_1.abrirJanela)(leitor);
     // I-37 (D2, D3): o prazo de cada comando sai do manifesto carregado no inicio da rodada;
     // editar o manifesto no meio dela nao muda o teto de quem ainda vai rodar.
-    const executor = executorSobConducao(opcoes.executor
-        ?? ((nome, comando, dirDeTrabalho) => executar(nome, comando, dirDeTrabalho, prazoDoComando(manifesto, nome))), manifesto, conducao);
+    const executor = executorSobConducao(executorComSteal(opcoes.executor
+        ?? ((nome, comando, dirDeTrabalho) => executar(nome, comando, dirDeTrabalho, prazoDoComando(manifesto, nome))), leitor, (0, instabilidade_1.testesDeRelogioVigentes)(instabilidade)), manifesto, conducao);
     // I-54 (D10): o preparo roda UMA vez, antes das claims. Ele nunca e condicao para uma claim
     // passar (cada uma roda o proprio comando inteiro); ele so deixa pronta a compilacao. A
     // identidade do produto e tomada logo depois dele e conferida no fim da rodada.
@@ -332,7 +395,7 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal) {
     for (const atual of comandos) {
         if (atual.ok)
             continue;
-        if (atual.causa === 'timeout') {
+        if (semVereditoPorTempo(atual)) {
             estouros.push(atual);
             continue;
         }
@@ -348,6 +411,16 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal) {
     const identidadeFinal = preparo ? identidadeDoProduto(cwd) : null;
     const produtoAlterado = !!preparo && identidadeFinal !== preparo.identidade;
     const naoExecutados = comandos.filter((c) => c.executado === false);
+    const rodadaPct = janelaDaRodada.fechar();
+    const todos = [...(preparo ? [preparo.resultado] : []), ...claims.flatMap((c) => c.execucoes), ...comandos];
+    const steal = {
+        fonte: steal_1.FONTE_STEAL,
+        medido: rodadaPct !== null,
+        rodadaPct,
+        limiarPct: steal_1.LIMIAR_STEAL_PCT,
+        porComando: Object.fromEntries(todos.map((c) => [c.nome, c.stealPct ?? null])),
+        relogioSobSteal: todos.filter((c) => c.relogioSobSteal?.length).map((c) => c.nome),
+    };
     const motivos = [];
     if (claims.some((c) => c.motivo === 'claims.failed'))
         motivos.push('claims.failed');
@@ -384,6 +457,10 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal) {
         falhasSemBaseline: falhasSemBaseline.map((r) => r.nome),
         estouros: estouros.map((r) => r.nome),
         prazoMs: manifesto.verify.timeout_ms ?? exports.TIMEOUT_VERIFY_MS,
+        steal,
+        ...(instabilidade.presente ? { instabilidade: { contrato: 'ork.instabilidade/v1', arquivo: instabilidade.arquivo,
+                vigentes: instabilidade.vigentes.map((e) => e.teste), vencidas: instabilidade.vencidas.map((e) => e.teste),
+                erros: instabilidade.erros } } : {}),
         ...(preparo ? { preparo: { ...comandoNoLedger(preparo.resultado), duracaoMs: preparo.resultado.duracaoMs,
                 identidade: preparo.identidade.slice(0, 16), identidadeFinal: identidadeFinal.slice(0, 16), produtoAlterado } } : {}),
         motivos,
@@ -391,6 +468,8 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal) {
         // I-36: por qual canal a verificacao chegou; a reentrada da sessao que conduz aparece aqui.
         canal,
         conducao: { identidade: conducao.identidade, reentrada: conducao.reentrada },
+        // RM-058 N2: se a rodada esperou a vez na fila pesada, e quanto.
+        filaPesada,
     });
     for (const motivo of bloqueantes) {
         (0, gates_1.registrarGateBloqueado)(dir, threadId, {
@@ -405,8 +484,10 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal) {
                 : motivo === 'verify.regression'
                     ? `regressao em: ${regressoes.map((r) => r.nome).join(', ')}`
                     : motivo === 'verify.timeout'
-                        ? `estourou o prazo sem terminar: ${[...estouros.map((r) => r.nome),
-                            ...claims.filter((c) => c.motivo === 'verify.timeout').map((c) => c.claim.id)].join(', ')}`
+                        ? `sem veredito por tempo (prazo estourado, ou teste com relogio sob steal acima de ${steal_1.LIMIAR_STEAL_PCT}%): ${[
+                            ...estouros.map((r) => r.nome),
+                            ...claims.filter((c) => c.motivo === 'verify.timeout').map((c) => c.claim.id)
+                        ].join(', ')}`
                         : motivo === 'verify.sem-veredito'
                             ? [produtoAlterado ? 'o produto mudou entre o preparo e o fim da rodada' : '',
                                 ...naoExecutados.map((c) => `${c.nome} nao foi executado`),
@@ -435,74 +516,82 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal) {
         falhasSemBaseline,
         estouros,
         preparo: preparo ? { ...preparo, identidadeFinal: identidadeFinal, produtoAlterado } : null,
+        steal,
+        instabilidade,
+        filaPesada,
         motivos,
         ok,
     };
 }
 /** `FALHOU (codigo 1)`, ou `ESTOUROU O PRAZO (600 s, rodou 612 s)`: a causa e dita pelo nome. */
 function situacaoDoComando(c) {
+    const m = (0, locale_1.msg)().verify;
     const s = (ms) => `${Math.round((ms ?? 0) / 1000)} s`;
     if (c.causa === 'timeout')
-        return `ESTOUROU O PRAZO (${s(c.prazoMs)}, rodou ${s(c.duracaoMs)})`;
+        return m.estourou(s(c.prazoMs), s(c.duracaoMs));
+    if (c.relogioSobSteal?.length)
+        return m.relogioSobSteal(c.stealPct, steal_1.LIMIAR_STEAL_PCT);
     if (c.causa === 'nao-encontrado')
-        return `NAO EXECUTOU (comando nao encontrado, codigo ${c.code})`;
+        return m.naoExecutou(c.code);
     if (c.causa === 'sinal')
-        return `MORTO POR SINAL (codigo ${c.code})`;
-    return `FALHOU (codigo ${c.code})`;
+        return m.mortoPorSinal(c.code);
+    return m.falhou(c.code);
 }
-/** Texto de `ork verify`. */
+/** Texto de `ork verify`. O detalhe da claim veio do catalogo em pt-BR e sai remontado no locale ativo. */
 function textoDoVerify(r) {
+    const m = (0, locale_1.msg)().verify;
     const linhas = [];
-    linhas.push(`ork verify da thread ${r.thread}`);
-    linhas.push(`  HEAD real   ${r.commit}`);
-    linhas.push(`  diretorio   ${r.cwd}`);
-    linhas.push(`  baseline    ${r.baseline ? `${(0, util_1.shaCurto)(r.baseline.commit)} de ${(0, horario_1.formatarDataHoraRotulada)(r.baseline.gravadaEm)}` : '(nao gravada: falha nao pode ser chamada de regressao)'}`);
+    linhas.push(m.titulo(r.thread));
+    linhas.push(m.head(r.commit));
+    linhas.push(m.diretorio(r.cwd));
+    linhas.push(r.baseline ? m.baseline((0, util_1.shaCurto)(r.baseline.commit), (0, horario_1.formatarDataHoraRotulada)(r.baseline.gravadaEm)) : m.semBaseline);
     if (r.preparo) {
         const p = r.preparo;
-        linhas.push(`  preparo     ${p.resultado.ok ? 'ok' : situacaoDoComando(p.resultado)} em ` +
-            `${Math.round((p.resultado.duracaoMs ?? 0) / 1000)} s, uma vez para a rodada; produto ` +
-            `${p.produtoAlterado ? 'MUDOU no meio da rodada: nenhum veredito vale' : 'conferido do preparo ao fim'}`);
+        linhas.push(m.preparo(p.resultado.ok ? m.comandoOk : situacaoDoComando(p.resultado), Math.round((p.resultado.duracaoMs ?? 0) / 1000), p.produtoAlterado));
+    }
+    linhas.push(r.steal.medido ? m.stealMedido(r.steal.rodadaPct, r.steal.fonte, r.steal.limiarPct) : m.stealNaoMedido(r.steal.fonte));
+    if (r.instabilidade.erros.length > 0) {
+        linhas.push(m.instabilidadeForaDoContrato(r.instabilidade.arquivo, r.instabilidade.erros.join('; ')));
+    }
+    else if (r.instabilidade.vencidas.length > 0) {
+        linhas.push(m.instabilidadeVencidas(r.instabilidade.vencidas.length, r.instabilidade.vencidas.map((e) => e.teste).join(', ')));
     }
     linhas.push('');
-    linhas.push('Claims reexecutadas no HEAD real:');
+    linhas.push(m.claimsReexecutadas);
     if (r.claims.length === 0) {
-        linhas.push('  (nenhuma claim registrada nesta thread)');
+        linhas.push(m.nenhumaClaim);
     }
     for (const c of r.claims) {
-        linhas.push(`  ${c.claim.id}  verificado: ${c.verificado ? 'sim' : 'NAO'}  ${c.claim.alegacao}`);
-        linhas.push(`      arquivo: ${c.claim.arquivo}`);
-        linhas.push(`      ${c.claim.verificar.length > 0 ? `comando(s): ${c.claim.verificar.join(' && ')}` : 'sem comando de verificacao'}`);
+        linhas.push(m.claim(c.claim.id, c.verificado, c.claim.alegacao));
+        linhas.push(m.arquivo(c.claim.arquivo));
+        linhas.push(c.claim.verificar.length > 0 ? m.comandos(c.claim.verificar.join(' && ')) : m.semComando);
         if (!c.verificado)
-            linhas.push(`      motivo tipado: ${c.motivo} (${c.detalhe})`);
+            linhas.push(m.motivoTipado(String(c.motivo), (0, locale_1.remontar)(c.detalhe)));
     }
     if (r.comandos.length > 0) {
         linhas.push('');
-        linhas.push('Comandos de verify do manifesto:');
+        linhas.push(m.comandosDoManifesto);
         for (const c of r.comandos) {
-            linhas.push(`  ${c.nome.padEnd(10)} ${c.ok ? 'ok' : situacaoDoComando(c)}  ${c.comando}`);
+            linhas.push(m.comando(c.nome, c.ok ? m.comandoOk : situacaoDoComando(c), c.comando));
             if (!c.ok && c.testeQueCaiu?.length)
-                linhas.push(`             teste(s) que caiu(ram): ${c.testeQueCaiu.join('; ')}`);
+                linhas.push(m.testesQueCairam(c.testeQueCaiu.join('; ')));
         }
     }
     if (r.estouros.length > 0) {
         linhas.push('');
-        linhas.push(`Estouro de prazo (nao e reprovacao, a prova nao terminou): ${r.estouros.map((c) => c.nome).join(', ')}`);
+        linhas.push(m.semVeredito(r.estouros.map((c) => c.nome).join(', ')));
     }
     if (r.regressoes.length > 0 || r.preExistentes.length > 0 || r.falhasSemBaseline.length > 0) {
         linhas.push('');
-        linhas.push(`Classificacao: ${r.regressoes.length} regressao(oes), ` +
-            `${r.preExistentes.length} pre-existente(s), ` +
-            `${r.falhasSemBaseline.length} falha(s) sem baseline`);
+        linhas.push(m.classificacao(r.regressoes.length, r.preExistentes.length, r.falhasSemBaseline.length));
         for (const c of r.regressoes)
-            linhas.push(`  regressao      ${c.nome}: ${c.comando}`);
+            linhas.push(m.regressao(c.nome, c.comando));
         for (const c of r.preExistentes)
-            linhas.push(`  pre-existente  ${c.nome}: ${c.comando}`);
+            linhas.push(m.preExistente(c.nome, c.comando));
         for (const c of r.falhasSemBaseline)
-            linhas.push(`  sem baseline   ${c.nome}: ${c.comando}`);
+            linhas.push(m.falhaSemBaseline(c.nome, c.comando));
     }
     linhas.push('');
-    linhas.push(r.ok
-        ? 'Veredito: VERDADE SUSTENTADA (nenhum motivo bloqueante).'
-        : `Veredito: REPROVADO. Motivos tipados: ${r.motivos.join(', ')}`);
+    linhas.push(r.ok ? m.verdade : m.reprovado(r.motivos.join(', ')));
     return linhas.join('\n');
 }

package/dist/vida-da-thread.js

@@ -0,0 +1,254 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VALIDADE_DA_VIDA_NO_RETRATO_MS = exports.VIDA_NAO_VERIFICADA = exports.chaveDaConta = exports.PRAZO_DA_LEITURA_MS = void 0;
+exports.motivoDaCausa = motivoDaCausa;
+exports.lerRuntime = lerRuntime;
+exports.vidaDaThread = vidaDaThread;
+exports.paradaDesde = paradaDesde;
+exports.textoDaParada = textoDaParada;
+exports.sessaoVivaNaThread = sessaoVivaNaThread;
+exports.vidaDoRetrato = vidaDoRetrato;
+/**
+ * RM-063 (F2): a sessao de cada thread, verificada no runtime, para as superficies que dizem "sigo".
+ *
+ * Incidente de 12/10/2026 (P2 da pagina da RM-063): com o despacho do GO da K7 morto e o daemon do
+ * claude-bg fora do ar, o `ork roadmap status` disse "sigo ork-rm026k7conhe na fase GO". O "sigo" saia de
+ * toda thread aberta com fase, ou do lease de conducao, que sobrevive a sessao morta ate a prova do fim.
+ *
+ * Agora so diz "sigo" quem tem sessao viva verificada no runtime: o `claude agents --json --all` de cada
+ * conta e os rollouts do codex, pela mesma consulta do inventario da RM-056 (fantasma e a sessao sem
+ * processo). Sessao fantasma, despacho falho ou nenhuma sessao viram "<thread> parada desde HH:MM:
+ * <motivo>", com o ultimo sinal de vida que o ledger guarda.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const sessoes_contas_1 = require("./sessoes-contas");
+const estado_thread_1 = require("./estado-thread");
+const ledger_1 = require("./ledger");
+const horario_1 = require("./horario");
+const locale_roadmap_1 = require("./locale-roadmap");
+/** O prazo do `claude agents` na leitura da vida: o status nao espera um daemon travado por minutos. */
+exports.PRAZO_DA_LEITURA_MS = 20_000;
+/** A chave de uma conta que respondeu: o runtime, e o perfil quando a conta e de um perfil do store. */
+const chaveDaConta = (runtime, perfil) => `${runtime}:${perfil ?? ''}`;
+exports.chaveDaConta = chaveDaConta;
+/** O motivo de uma causa, no catalogo pedido (pt-BR por padrao: e o que vai ao `--json` e ao retrato). */
+function motivoDaCausa(c, m = locale_roadmap_1.ROADMAP_PT_BR.motivoDaParada) {
+    switch (c.tipo) {
+        case 'nenhumaSessao': return m.nenhumaSessao(c.fase);
+        case 'despachoFalhou': return m.despachoFalhou(c.fase, c.detalhe);
+        case 'sessaoCaiu': return m.sessaoCaiu(c.sessao, c.motivo);
+        case 'runtimeSemResposta': return m.runtimeSemResposta(c.runtime, c.detalhe, c.sessao);
+        case 'naoAparece': return m.naoAparece(c.sessao);
+        case 'fantasma': return m.fantasma(c.sessao);
+        case 'encerrada': return m.encerrada(c.sessao, c.estado);
+        case 'naoLida': return m.naoLida(c.detalhe);
+        case 'semAtividade': return m.semAtividade(c.sessao, c.minutos);
+        case 'retratoVelho': return m.retratoVelho(c.minutos);
+    }
+}
+const curto = (texto, teto = 100) => {
+    const limpo = String(texto ?? '').replace(/[\p{Cc}\s]+/gu, ' ').trim();
+    return limpo.length > teto ? `${limpo.slice(0, teto - 3)}...` : limpo;
+};
+/**
+ * `claude agents` e os rollouts do codex de cada conta desta maquina (a do processo e cada perfil do store), conta a
+ * conta: o que uma conta nao respondeu nao vira "a sessao nao aparece". Falha vira falha, nunca "sem sessao".
+ */
+function lerRuntime(raiz, prazoMs = exports.PRAZO_DA_LEITURA_MS) {
+    const responderam = new Set(), falhas = [], sessoes = [];
+    try {
+        const canonica = (0, estado_thread_1.raizDoEstado)(raiz);
+        const { contas, fontes } = (0, sessoes_contas_1.contasDeSessoes)(canonica);
+        for (const f of fontes)
+            if (!f.ok)
+                falhas.push(curto(f.detalhe, 120));
+        for (const conta of contas) {
+            const r = (0, sessoes_contas_1.consultarContas)(canonica, { todas: true, contas: [conta], prazoMs });
+            if (r.fontes.some((f) => f.ok)) {
+                responderam.add(conta.runtime);
+                responderam.add((0, exports.chaveDaConta)(conta.runtime, conta.perfil?.id ?? null));
+            }
+            else
+                falhas.push(...r.fontes.filter((f) => !f.ok).map((f) => `${f.origem}: ${curto(f.detalhe, 120)}`));
+            for (const s of r.sessoes) {
+                sessoes.push({ sessionId: s.sessionId, runtime: s.runtime, viva: s.viva, fantasma: s.fantasma,
+                    estado: String(s.state ?? s.status ?? '').trim().toLowerCase(), perfil: s.perfil,
+                    atividadeEm: typeof s.atividadeEm === 'number' ? s.atividadeEm : null });
+            }
+        }
+    }
+    catch (e) {
+        falhas.push(curto(e.message, 160));
+    }
+    return { responderam: [...responderam], falhas, sessoes };
+}
+/** O motivo tipado com o detalhe, sem repetir o motivo quando o detalhe ja comeca por ele. */
+function motivoComDetalhe(e) {
+    const motivo = typeof e.motivo === 'string' ? e.motivo : '';
+    const detalhe = typeof e.detalhe === 'string' ? e.detalhe : typeof e.erro === 'string' ? e.erro : '';
+    return !detalhe ? motivo || 'sem detalhe' : !motivo || detalhe.startsWith(motivo) ? detalhe : `${motivo}: ${detalhe}`;
+}
+function causaDaFalha(e, sessionId) {
+    if (sessionId && e.sessionId === sessionId)
+        return { tipo: 'sessaoCaiu', sessao: sessionId.slice(0, 8), motivo: curto(e.motivo, 40) };
+    return { tipo: 'despachoFalhou', fase: typeof e.fase === 'string' && e.fase ? e.fase : null, detalhe: curto(motivoComDetalhe(e), 90) };
+}
+/** Eventos que o proprio `ork` grava sobre a sessao: nao sao sinal de vida dela. */
+const SO_DO_ORK = /^(conducao_|retry_|despacho_idempotente$)/;
+/**
+ * A vida da thread: a sessao do despacho mais recente, de qualquer fase (o despacho de GO que falha deixa a thread
+ * em GOAL), e a falha do runtime depois dele. `leitura` so e chamada quando ha sessao a conferir: thread sem
+ * despacho nao custa consulta ao runtime.
+ */
+function vidaDaThread(t, eventos, leitura, agoraMs = Date.now()) {
+    const fase = t.faseAtual;
+    const parada = (desdeEm, causa, sessionId = null) => ({ viva: false, sessionId, desdeEm: desdeEm ?? null, motivo: motivoDaCausa(causa), causa });
+    const ultimoSinal = eventos.at(-1)?.ts ?? t.atualizadaEm ?? t.criadaEm ?? null;
+    let iDespacho = -1;
+    for (let i = eventos.length - 1; i >= 0; i--) {
+        const e = eventos[i];
+        if (e.tipo === ledger_1.TIPOS_DE_EVENTO.faseDespachada && typeof e.sessionId === 'string' && e.sessionId) {
+            iDespacho = i;
+            break;
+        }
+    }
+    const despacho = iDespacho >= 0 ? eventos[iDespacho] : null;
+    const registrada = (t.sessoes ?? []).at(-1) ?? null;
+    const sessionId = despacho ? String(despacho.sessionId) : registrada?.sessionId ?? null;
+    const runtime = (typeof despacho?.runtime === 'string' && despacho.runtime) || registrada?.runtime || 'claude-bg';
+    const perfilDoDespacho = despacho?.perfil?.id ??
+        registrada?.perfil?.id;
+    const perfil = typeof perfilDoDespacho === 'string' && perfilDoDespacho ? perfilDoDespacho : null;
+    // A falha que vale e a de depois do despacho corrente (a de antes ja foi superada por ele), e que nada superou depois:
+    // o gate liberado do mesmo motivo ou da mesma sessao, ou a fase que terminou bem.
+    const depois = eventos.slice(iDespacho + 1);
+    const falha = [...depois.entries()].reverse().find(([k, e]) => (e.tipo === ledger_1.TIPOS_DE_EVENTO.despachoFalhou ||
+        (e.tipo === ledger_1.TIPOS_DE_EVENTO.gateBloqueado && typeof e.motivo === 'string' && e.motivo.startsWith('runtime.'))) &&
+        !depois.slice(k + 1).some((p) => (p.tipo === ledger_1.TIPOS_DE_EVENTO.gateLiberado && (p.motivo === e.motivo ||
+            (!!e.sessionId && p.sessionId === e.sessionId))) || (p.tipo === 'phase_result' && p.ok === true)))?.[1] ?? null;
+    if (!sessionId) {
+        return falha ? parada(falha.ts, causaDaFalha(falha, null)) : parada(ultimoSinal, { tipo: 'nenhumaSessao', fase });
+    }
+    const l = leitura();
+    const s = l.sessoes.find((x) => x.runtime === runtime && (x.sessionId === sessionId || x.sessionId.startsWith(sessionId)));
+    if (s?.viva)
+        return { viva: true, sessionId, desdeEm: null, motivo: null };
+    if (falha)
+        return parada(falha.ts, causaDaFalha(falha, sessionId), sessionId);
+    const id = sessionId.slice(0, 8);
+    const daSessao = [...eventos].reverse().find((e) => e.sessionId === sessionId && !SO_DO_ORK.test(e.tipo))?.ts ?? despacho?.ts ?? ultimoSinal;
+    // A conta do despacho precisa ter respondido: a do perfil, ou qualquer uma do runtime quando o despacho nao teve perfil.
+    if (!l.responderam.includes(perfil ? (0, exports.chaveDaConta)(runtime, perfil) : runtime)) {
+        return parada(daSessao, { tipo: 'runtimeSemResposta', runtime, detalhe: l.falhas.length ? curto(l.falhas[0], 80) : null, sessao: id }, sessionId);
+    }
+    if (!s)
+        return parada(daSessao, { tipo: 'naoAparece', sessao: id }, sessionId);
+    if (s.fantasma)
+        return parada(daSessao, { tipo: 'fantasma', sessao: id }, sessionId);
+    // O codex so conta como vivo com atividade recente no rollout: sem ela e sem estado final, e silencio, nao fim.
+    if (s.runtime === 'codex' && s.estado !== 'completed' && typeof s.atividadeEm === 'number') {
+        return parada(new Date(s.atividadeEm).toISOString(), { tipo: 'semAtividade', sessao: id, minutos: Math.max(0, Math.floor((agoraMs - s.atividadeEm) / 60000)) }, sessionId);
+    }
+    return parada(daSessao, { tipo: 'encerrada', sessao: id, estado: s.estado || 'sem estado' }, sessionId);
+}
+/** "parada desde HH:MM: <motivo>", no fuso do dono; sem o instante, so o motivo. */
+function paradaDesde(v, opcoes = {}) {
+    const desde = v.desdeEm && Number.isFinite(Date.parse(v.desdeEm)) ? ` desde ${(0, horario_1.formatarHora)(v.desdeEm, opcoes)}` : '';
+    return `parada${desde}: ${v.motivo ?? 'sem sessão viva verificada no runtime'}`;
+}
+/** "<thread> parada desde HH:MM: <motivo>": a linha que substitui o "sigo" quando a sessao nao esta viva. */
+function textoDaParada(thread, v, opcoes = {}) {
+    return `${thread} ${paradaDesde(v, opcoes)}`;
+}
+/**
+ * RM-063 (F3, GO-FIX): ha sessao viva trabalhando na thread? Pelo sessionId conhecido ou pela worktree dela (o
+ * adaptador que falha ou lanca depois de abrir a sessao nao devolve o id). E a prova que o `ork retry run` pede antes
+ * de redespachar: sem ela, a fase pode ganhar uma segunda sessao na mesma worktree. `respondeu: false` quando o
+ * runtime nao respondeu: sem prova, nada e redespachado.
+ */
+function sessaoVivaNaThread(raiz, thread, ids, consultar = () => (0, sessoes_contas_1.consultarContas)((0, estado_thread_1.raizDoEstado)(raiz), { todas: false, prazoMs: exports.PRAZO_DA_LEITURA_MS })) {
+    let r;
+    try {
+        r = consultar();
+    }
+    catch (e) {
+        return { respondeu: false, sessionId: null, detalhe: curto(e.message, 120) };
+    }
+    const falha = r.fontes.find((f) => f.origem.startsWith('claude agents') && !f.ok);
+    if (falha)
+        return { respondeu: false, sessionId: null, detalhe: curto(`${f(falha.origem)}: ${falha.detalhe}`, 160) };
+    const real = (p) => { try {
+        return fs.realpathSync(p);
+    }
+    catch {
+        return path.resolve(p);
+    } };
+    const worktree = thread.worktree ? real(thread.worktree) : null;
+    const naWorktree = (cwd) => typeof cwd === 'string' && !!worktree &&
+        (real(cwd) === worktree || real(cwd).startsWith(worktree + path.sep));
+    const viva = r.sessoes.find((s) => s.viva && (ids.some((id) => id && (s.sessionId === id || s.sessionId.startsWith(id))) || naWorktree(s.cwd)));
+    return { respondeu: true, sessionId: viva?.sessionId ?? null, detalhe: null };
+}
+const f = (origem) => origem.replace(/\s+/g, ' ');
+/** A vida de quem nao foi verificado: o retrato de outra maquina que nao publica a sessao. */
+exports.VIDA_NAO_VERIFICADA = Object.freeze({ viva: false, sessionId: null, desdeEm: null, motivo: null });
+/**
+ * A vida que vem no retrato de outra maquina (`ork/fabrica-estado`): so vale com os tipos certos. Retrato
+ * antigo, sem o campo, ou com o campo fora do formato, vira "nao verificada", e a linha nao diz "sigo".
+ */
+function vidaDoRetrato(bruto, publicadoEm, quando) {
+    if (!bruto || typeof bruto !== 'object')
+        return exports.VIDA_NAO_VERIFICADA;
+    const v = bruto;
+    const textoOuNulo = (x) => x === null || typeof x === 'string';
+    if (typeof v.viva !== 'boolean' || !textoOuNulo(v.desdeEm) || !textoOuNulo(v.motivo))
+        return exports.VIDA_NAO_VERIFICADA;
+    // A sessao viva de um retrato velho nao e "sigo": a maquina que morreu depois de publicar seguiria "viva" para sempre.
+    const idadeMs = publicadoEm && quando ? Date.parse(quando) - Date.parse(publicadoEm) : NaN;
+    if (v.viva && Number.isFinite(idadeMs) && idadeMs > exports.VALIDADE_DA_VIDA_NO_RETRATO_MS) {
+        const causa = { tipo: 'retratoVelho', minutos: Math.floor(idadeMs / 60000) };
+        return { viva: false, sessionId: null, desdeEm: publicadoEm ?? null, motivo: motivoDaCausa(causa), causa };
+    }
+    // Parada sem motivo publicado nao vira "nao verificada": a outra maquina disse que a sessao nao esta viva.
+    const motivo = v.motivo === null ? (v.viva ? null : 'sem sessão viva') : curto(v.motivo, 120);
+    return { viva: v.viva, sessionId: null, desdeEm: v.desdeEm, motivo };
+}
+/**
+ * Ate quando a sessao viva de um retrato publicado vale: o retrato igual so volta ao remoto de hora em hora
+ * (`PULSACAO_MS` da fabrica), mais uma batida do pulse de folga.
+ */
+exports.VALIDADE_DA_VIDA_NO_RETRATO_MS = 75 * 60 * 1000;