@orkastery/cli 0.5.1 → 0.5.6

package/dist/pulse.js

@@ -4,6 +4,7 @@ exports.JANELA_DAS_DECISOES_MS = exports.CONTRATO_PULSE = void 0;
 exports.apresentacaoCurtaDoItem = apresentacaoCurtaDoItem;
 exports.comporPulse = comporPulse;
 exports.montarPulse = montarPulse;
+exports.filaDoDono = filaDoDono;
 exports.textoDoPulse = textoDoPulse;
 const escopo_escrita_1 = require("./escopo-escrita");
 /** D4: uma fila para quem precisa de humano, com fontes e espera observada. */
@@ -13,12 +14,14 @@ const liveness_1 = require("./liveness");
 const master_1 = require("./master");
 const master_batch_1 = require("./master-batch");
 const orquestracao_1 = require("./orquestracao");
+const impedimento_1 = require("./impedimento");
 const thread_1 = require("./thread");
 const sessoes_adopt_1 = require("./sessoes-adopt");
 const ledger_1 = require("./ledger");
 const types_1 = require("./types");
 const util_1 = require("./util");
 const horario_1 = require("./horario");
+const locale_1 = require("./locale");
 const hitl_presentation_1 = require("./hitl-presentation");
 const hitl_contract_1 = require("./hitl-contract");
 const hitl_curto_1 = require("./hitl-curto");
@@ -27,6 +30,7 @@ const docs_1 = require("./docs");
 const conducao_1 = require("./conducao");
 const conducao_texto_1 = require("./conducao-texto");
 const hitl_resumo_1 = require("./hitl-resumo");
+const hitl_tempo_parado_1 = require("./hitl-tempo-parado");
 const parado_no_condutor_1 = require("./parado-no-condutor");
 exports.CONTRATO_PULSE = 'ork.pulse/v1';
 /** Uma semana: o resumo cita a decisao uma vez, e ela continua lida ate sair da janela. */
@@ -169,6 +173,20 @@ function comporPulse(carregado, entrada) {
                 thread: l.thread, fase: p.fase, sessionId: null, desdeEm: p.desdeEm, paradaHaMin: p.paradaHaMin, impacto: impacto(p.fase),
                 pergunta: p.detalhe, opcoes: [], recomendacao: p.correcao, comandoResposta: p.correcao, evidencia: [p.evidencia],
                 fontes: ['monitor'], contextoLogs: [] };
+            // RM-055: o impedimento do despacho sai no contrato curto, com o comando exato e o re-despacho depois.
+            if (p.impedimento) {
+                item.impedimento = { motivo: p.motivo, comando: p.impedimento.comando, retry: `ork retry run ${l.thread}` };
+                try {
+                    const curto = (0, impedimento_1.pedidoCurtoDoImpedimento)({ thread: l.thread, fase: p.fase, motivo: p.motivo, detalhe: p.detalhe,
+                        desdeEm: p.desdeEm, impedimento: p.impedimento }, quando);
+                    item.apresentacaoCurta = { telegram: (0, hitl_curto_1.textoDoPedidoCurto)(curto, 'telegram'), terminal: (0, hitl_curto_1.textoDoPedidoCurto)(curto, 'terminal') };
+                    item.opcoes = curto.alternativas.map(a => (0, locale_1.textoDoCatalogo)((m) => `${a.chave}. ${m.pulse.alternativaDoImpedimento(a.texto)}`));
+                    item.comandoResposta = item.impedimento.retry;
+                }
+                catch {
+                    item.evidencia.push('Pedido curto do impedimento indisponível; a correção acima vale.');
+                }
+            }
             // I-45: vaga parada e sinal do escalonador (`ork board reap` devolve a vaga), nao pergunta ao dono.
             const esperaAutomatica = ['lease.busy', 'conducao.em-andamento', 'concurrency.limite', 'runtime.rate-limited', 'vaga.stale'].includes(p.motivo);
             (esperaAutomatica ? automaticas : humanos).push(item);
@@ -195,7 +213,7 @@ function comporPulse(carregado, entrada) {
             continue;
         const item = { id: `orfa:${o.thread}:${o.fase}:${o.sessionId}`, classe: o.classe, motivo: o.motivo,
             thread: o.thread, fase: o.fase, sessionId: o.sessionId, desdeEm: o.desdeEm, paradaHaMin: minutos(o.desdeEm, quando),
-            impacto: impacto(o.fase), pergunta: `Fase ${o.fase} sem heartbeat desde ${o.ultimoHeartbeatEm}.`,
+            impacto: impacto(o.fase), pergunta: (0, locale_1.textoDoCatalogo)((m) => m.pulse.semHeartbeat(o.fase, o.ultimoHeartbeatEm)),
             opcoes: [], recomendacao: o.retry.razao,
             comandoResposta: o.retry.automatica ? `ork retry run ${o.thread} --motivo runtime.silencio --fase ${o.fase}` :
                 `ork retry plan ${o.thread} --motivo runtime.silencio --fase ${o.fase}`,
@@ -246,11 +264,12 @@ function montarPulse(carregado, opcoes = {}) {
     const diagnosticos = [];
     const quando = opcoes.quando ?? (0, util_1.agora)();
     const consulta = opcoes.consulta ?? (opcoes.semRuntime
-        ? { ok: false, sessoes: [], detalhe: 'runtime não consultado por --sem-runtime' } : (0, claude_bg_1.consultarSessoes)(undefined, true));
+        ? { ok: false, sessoes: [], detalhe: (0, locale_1.textoDoCatalogo)((m) => m.pulse.semRuntime) } : (0, claude_bg_1.consultarSessoes)(undefined, true));
     const estados = consulta.ok ? new Map(consulta.sessoes.map(s => [s.sessionId ?? '', (0, hitl_1.estadoBruto)(s)])) : null;
     const radar = (0, hitl_1.varrerSessoes)({ raiz: carregado.raiz, consulta, agora: quando, registrar: opcoes.registrar, escopo: opcoes.escopo, linhasLogs: opcoes.linhasLogs });
-    if (radar.telasAdiadas)
-        diagnosticos.push(`radar.orcamento: ${radar.telasAdiadas} tela(s) de sessão ficaram para a próxima varredura`);
+    const telasAdiadas = radar.telasAdiadas;
+    if (telasAdiadas)
+        diagnosticos.push((0, locale_1.textoDoCatalogo)((m) => m.pulse.telasAdiadas(telasAdiadas)));
     // Falha de observação não prova silêncio: Claude indisponível preserva sua guarda de HITL e Codex mantém sua coleta independente.
     const orfas = (0, liveness_1.detectarFasesOrfas)(carregado, { quando, registrar: opcoes.registrar, escopo: opcoes.escopo, diagnosticos,
         fontes: opcoes.fontes, estados: estados ?? undefined, runtimes: consulta.ok ? undefined : ['codex'] });
@@ -269,24 +288,41 @@ function montarPulse(carregado, opcoes = {}) {
     // retrato que o status do roadmap le sem rede. Falha de leitura e diagnostico, nunca "sem PR".
     let entregas;
     try {
-        entregas = (0, parado_no_condutor_1.entregasDoProjeto)(carregado, { quando, sessoes: radar.sessoes, lerPrs: (candidatas) => {
+        entregas = (0, parado_no_condutor_1.entregasDoProjeto)(carregado, { quando, sessoes: radar.sessoes, lerPrs: opcoes.semForja ? () => null : (candidatas) => {
                 const leitura = (0, parado_no_condutor_1.lerPrsDaForja)(carregado, { quando, executor: opcoes.executorDoGh, candidatas });
                 if (leitura.ok) {
                     try {
                         (0, parado_no_condutor_1.gravarRetratoDePrs)(carregado.raiz, leitura.retrato);
                     }
                     catch { /* o retrato e economia do status */ }
+                    try {
+                        (0, parado_no_condutor_1.esquecerForjaSemLeitura)(carregado.raiz);
+                    }
+                    catch { /* sem a marca, a proxima perda de leitura e dita de novo */ }
                 }
                 return leitura;
             } });
-        if (entregas.prs && !entregas.prs.ok)
-            diagnosticos.push(`prs.nao-lidos: ${entregas.prs.erro.slice(0, 160)}`);
+        const leitura = entregas.prs;
+        if (leitura && !leitura.ok && leitura.semLeitura) {
+            // RM-037 (fatia 5, A5): a forja sem leitura de PR e dita uma vez por remoto e host; as batidas seguintes nao repetem.
+            let novidade = true;
+            try {
+                novidade = (0, parado_no_condutor_1.avisarForjaSemLeitura)(carregado.raiz, leitura.semLeitura, leitura.erro, quando);
+            }
+            catch { /* sem marca, diz de novo */ }
+            if (novidade)
+                diagnosticos.push(`prs.sem-leitura: ${leitura.erro.slice(0, 160)}`);
+        }
+        else if (leitura && !leitura.ok)
+            diagnosticos.push(`prs.nao-lidos: ${leitura.erro.slice(0, 160)}`);
     }
     catch (e) {
         diagnosticos.push(`entregas.indisponiveis: ${e.message.slice(0, 120)}`);
     }
     const pulse = comporPulse(carregado, { radar, monitor, orfas, batch: (0, master_1.pendentesDeScore)(carregado.raiz), ...(entregas ? { entregas } : {}) });
-    const conducoes = monitor.linhas.filter((l) => l.conducao).map((l) => ({ thread: l.thread, linha: (0, conducao_texto_1.linhaDeConducao)(l.conducao, { agora: quando }) }));
+    // RM-061 (F2b, G2): a linha de conducao e da familia `thread` e segue o locale ativo; o JSON a guarda em pt-BR.
+    const conducoes = monitor.linhas.filter((l) => l.conducao)
+        .map((l) => ({ thread: l.thread, linha: (0, locale_1.textoDoCatalogo)(() => (0, conducao_texto_1.linhaDeConducao)(l.conducao, { agora: quando })) }));
     if (conducoes.length > 0)
         pulse.conducoes = conducoes;
     // B4: a metade que presta contas. Leitura pura; falhar aqui nunca derruba a fila de atencao.
@@ -298,36 +334,79 @@ function montarPulse(carregado, opcoes = {}) {
     catch (e) {
         diagnosticos.push(`decisoes.indisponiveis: ${e.message.slice(0, 120)}`);
     }
+    // RM-057 (fatia 3): leitura pura do ledger; falhar aqui nunca derruba a fila de atencao.
+    try {
+        const hitl = (0, hitl_tempo_parado_1.lerHitlDeConducaoAgora)(carregado.raiz, quando);
+        if (hitl.abertas.length || hitl.seteDias.pedidos || hitl.seteDias.respondidos)
+            pulse.hitlDeConducao = hitl;
+    }
+    catch (e) {
+        diagnosticos.push(`hitl-conducao.indisponivel: ${e.message.slice(0, 120)}`);
+    }
     if (diagnosticos.length)
         pulse.runtime.detalhe = [pulse.runtime.detalhe, ...diagnosticos].filter(Boolean).join('; ');
     return pulse;
 }
+/**
+ * RM-063 (F2): a fila do dono que o `ork roadmap status` le, a MESMA do `ork pulse` (`precisaDeHumanoAgora`). Em 12/10/2026
+ * o status disse "Nada agora" com o pulse contando 3: as duas superficies montavam a fila cada uma do seu jeito. Sem
+ * forja e sem registrar; o texto de cada item sai numa linha, redigido.
+ */
+function filaDoDono(carregado, opcoes = {}) {
+    const linha = (texto, teto) => {
+        const limpo = (0, hitl_1.redigirSegredos)(texto).replace(/[\p{Cc}\s]+/gu, ' ').trim();
+        return limpo.length > teto ? `${limpo.slice(0, teto - 3)}...` : limpo;
+    };
+    try {
+        const p = montarPulse(carregado, { quando: opcoes.quando, semForja: true });
+        // Sem o `claude` nesta maquina nao ha sessao dele a perder: a fila do monitor e do ledger esta inteira.
+        const lida = p.runtime.ok || !(0, util_1.noPath)('claude');
+        return { lida, detalhe: lida ? null : linha(p.runtime.detalhe, 160),
+            itens: p.precisaDeHumanoAgora.map(i => ({ id: i.id, thread: i.thread, sessionId: i.sessionId, fase: i.fase, classe: i.classe,
+                motivo: i.motivo, pergunta: linha(i.pergunta || i.motivo, 200), comando: linha(i.comandoResposta, 160), paradaHaMin: i.paradaHaMin })) };
+    }
+    catch (e) {
+        return { lida: false, detalhe: linha(e.message, 160), itens: [] };
+    }
+}
 function textoDoPulse(p) {
+    const m = (0, locale_1.msg)().pulse;
     // I-35: o pulse guarda ISO; o texto ao dono sai no fuso dele, rotulado no cabeçalho.
-    const local = (texto) => (0, horario_1.localizarTexto)(texto, { agora: p.consultadoEm });
-    const linhas = [`Pulse (${p.contrato}) ${(0, horario_1.formatarDataHoraRotulada)(p.consultadoEm, { agora: p.consultadoEm })}`, `Precisa de humano agora: ${p.resumo.humanos}`, `${p.resumo.scores} entrega(s) sem nota, aceitas por padrão com registro`];
+    // RM-061 (F2b, G2): o que o pulse montou pelo catalogo sai remontado; o resto (pedido HITL, ledger) como veio.
+    const local = (texto) => (0, horario_1.localizarTexto)((0, locale_1.remontar)(texto), { agora: p.consultadoEm });
+    // O detalhe do runtime junta partes separadas por "; ": cada uma e remontada.
+    const detalhe = (texto) => (0, horario_1.localizarTexto)(texto.split('; ').map(locale_1.remontar).join('; '), { agora: p.consultadoEm });
+    const linhas = [m.cabecalho(p.contrato, (0, horario_1.formatarDataHoraRotulada)(p.consultadoEm, { agora: p.consultadoEm })), m.precisaDeHumano(p.resumo.humanos), m.semNota(p.resumo.scores)];
     // RM-037 (fatia 4): PR nao lido tambem e dito, para a falta de linha do condutor nao parecer "nada parado".
-    if (p.runtime.ok && ['liveness.snapshot.invalid', 'prs.nao-lidos', 'entregas.indisponiveis'].some(d => p.runtime.detalhe.includes(d))) {
-        linhas.push(`[diagnostico] ${local(p.runtime.detalhe)}`);
+    if (p.runtime.ok && ['liveness.snapshot.invalid', 'prs.nao-lidos', 'prs.sem-leitura', 'entregas.indisponiveis'].some(d => p.runtime.detalhe.includes(d))) {
+        linhas.push(m.diagnostico(detalhe(p.runtime.detalhe)));
     }
     if (!p.runtime.ok)
-        linhas.push(`[consulta incompleta] ${local(p.runtime.detalhe)}`);
+        linhas.push(m.consultaIncompleta(detalhe(p.runtime.detalhe)));
     for (const i of p.precisaDeHumanoAgora) {
-        linhas.push('', `${i.thread ?? i.sessionId} [${i.classe}] ${i.paradaHaMin == null ? 'desconhecido' : i.paradaHaMin < 1 ? 'menos de 1' : i.paradaHaMin} min`, local(i.pergunta), ...i.opcoes.map(o => `  opção: ${o}`), `Recomendação: ${i.recomendacao}`, `Responder: ${i.comandoResposta}`, ...i.contextoLogs.map(l => `  log: ${l}`));
+        linhas.push('', m.item(String(i.thread ?? i.sessionId), m.classe(i.classe), i.paradaHaMin == null ? m.desconhecido : i.paradaHaMin < 1 ? m.menosDeUm : String(i.paradaHaMin)), local(i.pergunta), ...i.opcoes.map(o => m.opcao((0, locale_1.remontar)(o))), m.recomendacao((0, locale_1.remontar)(i.recomendacao)), m.responder((0, locale_1.remontar)(i.comandoResposta)), ...i.contextoLogs.map(l => m.log(l)));
     }
     if (p.conducoes?.length) {
-        linhas.push('', `Conduzidas agora: ${p.conducoes.length}`);
+        linhas.push('', m.conduzidas(p.conducoes.length));
         for (const c of p.conducoes)
-            linhas.push(`${c.thread}: ${c.linha}`);
+            linhas.push(m.conducao(c.thread, (0, locale_1.remontar)(c.linha)));
     }
     // RM-037 (fatia 4): o que espera o condutor, uma linha por thread; nao e pergunta ao dono.
     if (p.paradoNoCondutor?.length) {
-        linhas.push('', `Parado no condutor: ${p.paradoNoCondutor.length}`);
+        linhas.push('', m.paradoNoCondutor(p.paradoNoCondutor.length));
         for (const x of p.paradoNoCondutor)
             linhas.push((0, hitl_resumo_1.linhaDoParadoNoCondutor)(x, { agora: p.consultadoEm }));
     }
-    linhas.push('', `Ações automáticas pendentes: ${p.resumo.automaticas}`);
+    // RM-057 (fatia 3): quanto tempo cada pergunta de conducao aberta ja parou a thread, e a mediana da semana.
+    if (p.hitlDeConducao) {
+        const h = p.hitlDeConducao;
+        linhas.push('', m.hitlDeConducao(h.abertas.length, (0, hitl_tempo_parado_1.textoDaMediana)(h)));
+        for (const a of h.abertas)
+            linhas.push((0, hitl_tempo_parado_1.linhaDaPerguntaParada)(a, { agora: p.consultadoEm }));
+    }
+    linhas.push('', m.automaticas(p.resumo.automaticas));
+    // RM-061 (F2b, D4): o item do radar sem tipo de HITL usa a classe como motivo; ela sai pelo id, o motivo tipado fica.
     for (const i of p.acoesAutomaticas)
-        linhas.push(`${i.thread}: ${i.motivo}; ${i.comandoResposta}`);
+        linhas.push(m.automatica(String(i.thread), i.motivo === i.classe ? m.classe(i.motivo) : i.motivo, (0, locale_1.remontar)(i.comandoResposta)));
     return linhas.join('\n');
 }

package/dist/ratelimit.js

@@ -61,6 +61,7 @@ exports.lerFilaDeRetomada = lerFilaDeRetomada;
 exports.janelaPadraoMs = janelaPadraoMs;
 exports.enfileirar = enfileirar;
 exports.prazoDaConta = prazoDaConta;
+exports.prazoDaCotaVista = prazoDaCotaVista;
 exports.marcarContaDaFalha = marcarContaDaFalha;
 exports.gravarPedido = gravarPedido;
 exports.exigirPedido = exigirPedido;
@@ -72,6 +73,7 @@ const path = __importStar(require("node:path"));
 const manifest_1 = require("./manifest");
 const util_1 = require("./util");
 const horario_1 = require("./horario");
+const locale_1 = require("./locale");
 const runtime_profiles_1 = require("./runtime-profiles");
 var claude_bg_1 = require("./adapters/claude-bg");
 Object.defineProperty(exports, "parseRateLimit", { enumerable: true, get: function () { return claude_bg_1.parseRateLimit; } });
@@ -151,15 +153,30 @@ function prazoDaConta(manifesto, falha, agoraMs = Date.now()) {
         return falha.resetEm;
     return new Date(agoraMs + janelaPadraoMs(manifesto)).toISOString();
 }
-/** Marca no store o perfil que falhou pela conta. Sem perfil (ambiente do processo), nada a marcar. */
-function marcarContaDaFalha(carregado, perfil, falha, agoraMs = Date.now()) {
+/**
+ * RM-037 (fatia 5): ate quando a conta sai do rodizio pela cota que o observador viu na transcricao, com a
+ * sessao viva. Vale a hora dita (ja ancorada no instante da mensagem) ou a janela padrao contada da mensagem,
+ * nunca do relogio de quem leu. Prazo que ja venceu volta `null`: a conta ja voltou, e marcar agora tiraria do
+ * rodizio uma conta boa (a regra A10 do despacho recusado nao vale aqui, porque ninguem acabou de recusar nada).
+ */
+function prazoDaCotaVista(manifesto, falha, mensagemMs, agoraMs = Date.now()) {
+    if (falha.motivo !== 'runtime.quota-exhausted' || !Number.isFinite(mensagemMs))
+        return null;
+    const prazo = falha.resetEm ?? new Date(mensagemMs + janelaPadraoMs(manifesto)).toISOString();
+    return Date.parse(prazo) > agoraMs ? prazo : null;
+}
+/**
+ * Marca no store o perfil que falhou pela conta. Sem perfil (ambiente do processo), nada a marcar. `prazo`,
+ * quando vem, e o ja calculado por quem viu a falha (`prazoDaCotaVista`); sem ele, vale `prazoDaConta`.
+ */
+function marcarContaDaFalha(carregado, perfil, falha, agoraMs = Date.now(), prazo) {
     // RM-037 (defeitosdeco D-6): modelo inacessivel nao e falha da conta inteira; o perfil fica no rodizio.
     if (!perfil || falha.motivo === 'runtime.model-unavailable')
         return null;
     const esgotado = falha.motivo === 'runtime.quota-exhausted';
     return (0, runtime_profiles_1.marcarFalhaDePerfil)(carregado.raiz, perfil.id, { estado: esgotado ? 'esgotado' : 'sem-auth',
-        esgotadoAte: prazoDaConta(carregado.manifesto, falha, agoraMs), motivo: falha.motivo, detalhe: falha.trecho,
-        em: new Date(agoraMs).toISOString() });
+        esgotadoAte: esgotado && prazo ? prazo : prazoDaConta(carregado.manifesto, falha, agoraMs), motivo: falha.motivo,
+        detalhe: falha.trecho, em: new Date(agoraMs).toISOString() });
 }
 /** Regrava um pedido (append-only: a versao nova vence, o historico fica). */
 function gravarPedido(raiz, pedido) {
@@ -188,10 +205,11 @@ function vencidos(raiz, quando = (0, util_1.agora)()) {
 /** Quanto falta para a janela de um pedido, em texto curto para o CLI. */
 function faltaPara(pedido, quando = (0, util_1.agora)()) {
     const ms = new Date(pedido.liberaEm).getTime() - new Date(quando).getTime();
+    const m = (0, locale_1.msg)().horario;
     if (ms <= 0)
-        return 'ja liberou';
+        return m.jaLiberou;
     const min = Math.ceil(ms / 60000);
-    return min < 60 ? `em ${min} min` : `em ${Math.floor(min / 60)}h${String(min % 60).padStart(2, '0')}`;
+    return min < 60 ? m.emMinutos(min) : m.emHoras(Math.floor(min / 60), String(min % 60).padStart(2, '0'));
 }
 /** Tabela de `ork retry list`. */
 function tabelaDaFila(raiz, quando = (0, util_1.agora)()) {

package/dist/recall.js

@@ -257,7 +257,9 @@ function recallDaThread(carregado, memoria, threadId, opcoes = {}) {
             falhas.push({ id: 'memoria-busca', titulo: 'Descoberta de handoffs da fase', location: '',
                 orkmind: null, retrieve_when: fase, resolvido: false, motivo: 'orkmind-indisponivel', via: null,
                 conteudo: '', metodo: '', sha256: '', intervalo: null,
-                detalhe: `${memoria.leituraRestrita ? falhaDeConsulta(erro) : 'memory.transport.export'}: busca semantica falhou; resultado nao comprova colecao vazia` });
+                // RM-038: a janela cheia do export tem codigo proprio; o resto segue como falha de transporte.
+                detalhe: `${memoria.leituraRestrita ? falhaDeConsulta(erro) : erro instanceof Error && erro.message === 'memory.query.window-saturated'
+                    ? erro.message : 'memory.transport.export'}: busca semantica falhou; resultado nao comprova colecao vazia` });
         }
     }
     if (opcoes.id !== undefined && resolvidos.length === 0 && falhas.length === 0 && adiados.length === 0) {

package/dist/redacao-saida.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LIMITE_DE_TESTES = exports.LIMITE_DO_TRECHO = void 0;
 exports.redigirSaida = redigirSaida;
 exports.testesQueCairam = testesQueCairam;
+exports.falhasDeTeste = falhasDeTeste;
 /**
  * I-37 (D9): a saida de um comando que falhou, pronta para ir ao ledger.
  *
@@ -41,5 +42,67 @@ function testesQueCairam(saida) {
         if (nomes.length === exports.LIMITE_DE_TESTES)
             break;
     }
+    // RM-037 (fatia 6): o reporter `spec`, o padrao do `node --test` 24 fora de TTY, nao imprime `not ok`;
+    // os nomes moram na secao "failing tests" do fim da saida.
+    if (nomes.length === 0)
+        return falhasDeTeste(saida).map((f) => f.nome).slice(0, exports.LIMITE_DE_TESTES);
     return nomes;
 }
+/** As frases do `node --test` para a falha que e do relogio, e nao da asercao. */
+const ASSINATURA_DE_RELOGIO = /test timed out after \d+ms|test did not finish before its parent and was cancelled/;
+const TIPO_DE_RELOGIO = /failureType:\s*'(?:testTimeoutFailure|cancelledByParent)'/;
+/** O teste que so agrega os filhos (subtestes ou arquivo) nao e uma falha por si. */
+const TIPO_DE_AGREGADO = /failureType:\s*'subtestsFailed'/;
+/**
+ * RM-037 (fatia 6): os testes reprovados, folha a folha, com a natureza da falha, para o verify saber
+ * se a reprovacao e so de relogio. Le o TAP do `node --test` (o bloco YAML depois do `not ok`, pulando
+ * o agregado `subtestsFailed`) e a secao "failing tests" do reporter `spec`. Outros runners (jest,
+ * vitest) nao dizem a natureza: os nomes saem com `relogio: false`, e nada e atenuado.
+ */
+function falhasDeTeste(saida) {
+    const linhas = saida.split('\n');
+    const falhas = [];
+    const somar = (nome, relogio) => {
+        const limpo = nome.trim().slice(0, LIMITE_DO_NOME);
+        if (!limpo)
+            return;
+        const ja = falhas.find((f) => f.nome === limpo);
+        if (ja)
+            ja.relogio = ja.relogio && relogio;
+        else
+            falhas.push({ nome: limpo, relogio });
+    };
+    for (let i = 0; i < linhas.length; i++) {
+        const tap = /^\s*not ok \d+ - (.+?)\s*(?:#.*)?$/.exec(linhas[i]);
+        if (!tap)
+            continue;
+        const bloco = [];
+        for (let j = i + 1; j < linhas.length && !/^\s*(?:not )?ok \d+ /.test(linhas[j]); j++)
+            bloco.push(linhas[j]);
+        const texto = bloco.join('\n');
+        if (TIPO_DE_AGREGADO.test(texto))
+            continue;
+        somar(tap[1], TIPO_DE_RELOGIO.test(texto) || ASSINATURA_DE_RELOGIO.test(texto));
+    }
+    const inicio = linhas.findIndex((l) => /^\s*✖ failing tests:\s*$/.test(l));
+    if (inicio >= 0) {
+        for (let i = inicio + 1; i < linhas.length; i++) {
+            const cabeca = /^✖ (.+?)(?: \([\d.]+m?s\))?\s*$/.exec(linhas[i]);
+            if (!cabeca)
+                continue;
+            const corpo = [];
+            for (let j = i + 1; j < linhas.length && !/^(?:✖ |test at )/.test(linhas[j]); j++)
+                corpo.push(linhas[j]);
+            const primeira = corpo.find((l) => l.trim() !== '') ?? '';
+            somar(cabeca[1], ASSINATURA_DE_RELOGIO.test(primeira));
+        }
+    }
+    if (falhas.length === 0) {
+        for (const linha of linhas) {
+            const fail = /^\s*(?:FAIL|✕|×)\s+(\S.*?)\s*$/.exec(linha);
+            if (fail)
+                somar(fail[1], false);
+        }
+    }
+    return falhas;
+}