@orkastery/cli 0.5.3 → 0.6.0

package/dist/pulse.js

@@ -3,7 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.JANELA_DAS_DECISOES_MS = exports.CONTRATO_PULSE = void 0;
 exports.apresentacaoCurtaDoItem = apresentacaoCurtaDoItem;
 exports.comporPulse = comporPulse;
+exports.comandoDaAcaoDaVarredura = comandoDaAcaoDaVarredura;
+exports.textoDaAcaoDaVarredura = textoDaAcaoDaVarredura;
+exports.varreduraDoPulse = varreduraDoPulse;
 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. */
@@ -14,12 +18,18 @@ const master_1 = require("./master");
 const master_batch_1 = require("./master-batch");
 const orquestracao_1 = require("./orquestracao");
 const impedimento_1 = require("./impedimento");
+const runtime_escada_1 = require("./runtime-escada");
+const autorizacao_duravel_1 = require("./autorizacao-duravel");
+const varredura_acoes_1 = require("./varredura-acoes");
+const conducao_batida_1 = require("./conducao-batida");
+const maquina_ociosa_1 = require("./maquina-ociosa");
 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");
@@ -173,21 +183,47 @@ function comporPulse(carregado, entrada) {
                 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 => `${a.chave}. ${a.texto}`);
-                    item.comandoResposta = `ork retry run ${l.thread}`;
+                    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.');
                 }
             }
+            // RM-063 (F4): a escada de recuperacao do runtime que acabou sai como o impedimento, com o comando que confere o
+            // runtime, o que retoma a fase com o mesmo prompt e o pedido curto com as tres alternativas (RM-057).
+            if (p.escada) {
+                item.impedimento = { motivo: p.motivo, comando: p.escada.conferir, retry: p.escada.retomar };
+                item.comandoResposta = p.escada.retomar;
+                try {
+                    const curto = (0, runtime_escada_1.pedidoCurtoDaEscada)({ thread: l.thread, fase: p.fase, desdeEm: p.desdeEm, escada: p.escada }, 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)}`));
+                    const recomendada = curto.alternativas.find(a => a.recomendada);
+                    if (recomendada)
+                        item.recomendacao = `${recomendada.chave}. ${recomendada.texto}: ${recomendada.recomendada.porque}`;
+                }
+                catch {
+                    item.evidencia.push('Pedido curto da escada 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);
         }
+    // RM-063 (F5): o MASTER por omissao da varredura nao vira item do dono (I-45: a entrega sem nota fica na faixa
+    // automatica). Ele completa o item da entrega com o comando desta thread so (RM-008) e com quem o faz agora.
+    const v = entrada.varredura;
+    const recomendacaoDaVarredura = (a) => a.quemFaz === 'varredura' && v.autorizacao.por && v.autorizacao.ate
+        ? (0, locale_1.textoDoCatalogo)((m) => m.pulse.varredura.daVarredura(v.autorizacao.por, (0, horario_1.formatarDataHoraRotulada)(v.autorizacao.ate, { agora: quando })))
+        : a.bloqueio ? (0, locale_1.textoDoCatalogo)((m) => m.pulse.varredura.comBloqueioRecomendacao(a.thread, a.comando))
+            : (0, locale_1.textoDoCatalogo)((m) => m.pulse.varredura.doDono(a.acao));
+    const masterDaVarredura = new Map((v?.pendentes ?? []).filter(a => a.acao === 'master').map(a => [a.thread, a]));
     for (const b of batch) {
         const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(carregado.raiz, b.thread.id));
         const desde = eventos.filter(e => e.tipo === 'ship_done').at(-1)?.ts ??
@@ -204,19 +240,45 @@ function comporPulse(carregado, entrada) {
             recomendacao: 'Aceitar por padrão com registro; a nota humana, quando vier, sobrescreve.',
             comandoResposta: 'ork master --aceitar-omissao',
             evidencia: [`ork master; regime ${b.regime}`], fontes: ['master'], contextoLogs: [] });
+        const daVarredura = masterDaVarredura.get(b.thread.id);
+        if (daVarredura) {
+            const item = automaticas[automaticas.length - 1];
+            item.comandoResposta = comandoDaAcaoDaVarredura(daVarredura);
+            item.recomendacao = recomendacaoDaVarredura(daVarredura);
+            if (daVarredura.bloqueio || daVarredura.recusa)
+                item.pergunta = `${item.pergunta} ${textoDaAcaoDaVarredura(daVarredura)}`;
+            item.evidencia.push(daVarredura.evidencia);
+            if (!item.fontes.includes('varredura'))
+                item.fontes.push('varredura');
+            masterDaVarredura.delete(b.thread.id);
+        }
     }
     for (const o of orfas) {
         if (ehRegistro(o.thread))
             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}`,
             evidencia: [...o.evidencia, `retry ${o.retry.tentativas}/${o.retry.limite}`], fontes: ['liveness'], contextoLogs: [] };
         (o.retry.automatica ? automaticas : humanos).push(item);
     }
+    // RM-063 (F5): cada acao da varredura e um item. Sem a autorizacao do dono para ela (ou com bloqueio, ou com a tentativa
+    // recusada), e do dono, com o comando pronto; autorizada, e acao automatica da proxima batida. O MASTER ja foi no item
+    // da entrega sem nota; so o que sobrou dele (sem item de entrega) entra aqui, na faixa automatica.
+    for (const a of v?.pendentes ?? []) {
+        if (a.acao === 'master' && !masterDaVarredura.has(a.thread))
+            continue;
+        const daVarredura = a.quemFaz === 'varredura' || a.acao === 'master';
+        const item = { id: `varredura:${a.acao}:${a.thread}${a.sessionId ? `:${a.sessionId.slice(0, 8)}` : ''}`,
+            classe: 'varredura', motivo: `varredura.${a.acao}`, thread: a.thread, fase: a.fase, sessionId: null, desdeEm: a.desdeEm,
+            paradaHaMin: minutos(a.desdeEm, quando), impacto: impacto(a.fase), pergunta: textoDaAcaoDaVarredura(a), opcoes: [],
+            recomendacao: recomendacaoDaVarredura(a), comandoResposta: comandoDaAcaoDaVarredura(a), evidencia: [a.evidencia],
+            fontes: ['varredura'], contextoLogs: [] };
+        (daVarredura ? automaticas : humanos).push(item);
+    }
     const unicos = (items) => [...new Map(items.map(i => [i.id, i])).values()].sort(ordenar);
     const h = unicos(humanos), a = unicos(automaticas);
     for (const item of h) {
@@ -253,7 +315,30 @@ function comporPulse(carregado, entrada) {
     }
     return { contrato: exports.CONTRATO_PULSE, consultadoEm: quando, runtime: { ok: radar.runtimeConsultado, detalhe: radar.runtimeDetalhe },
         precisaDeHumanoAgora: h, acoesAutomaticas: a, resumo: { humanos: h.length, automaticas: a.length, scores: batch.length, fasesOrfas: orfas.length },
-        ...(entregas?.parados.length ? { paradoNoCondutor: entregas.parados } : {}) };
+        ...(entregas?.parados.length ? { paradoNoCondutor: entregas.parados } : {}),
+        ...(v && (v.pendentes.length || v.feitas.length || v.autorizacao.estado !== 'ausente') ? { varredura: v } : {}) };
+}
+/** RM-063 (F5): com bloqueio, o comando do dono e olhar a thread: a acao iria por cima do trabalho que esta nela. */
+function comandoDaAcaoDaVarredura(a) {
+    return a.bloqueio ? `ork thread status ${a.thread}` : a.comando;
+}
+/** RM-063 (F5): o que a acao faz, com o motivo da ultima recusa ou do bloqueio quando ha. */
+function textoDaAcaoDaVarredura(a) {
+    return a.recusa ? (0, locale_1.textoDoCatalogo)((m) => m.pulse.varredura.comRecusa(a.oQue, a.recusa.detalhe))
+        : a.bloqueio ? (0, locale_1.textoDoCatalogo)((m) => m.pulse.varredura.comBloqueio(a.oQue, a.bloqueio)) : a.oQue;
+}
+/** RM-063 (F5): os estados em que a sessao da consulta ja nao trabalha na worktree. */
+const TERMINAIS_DA_CONSULTA = ['failed', 'done', 'stopped', 'completed', 'exited'];
+/** RM-063 (F5): a autorizacao e as acoes como o pulse as leva: cada acao com quem a faz agora. */
+function varreduraDoPulse(leitura, pendentes, feitas) {
+    const a = leitura.valida ? leitura.autorizacao : null;
+    return {
+        autorizacao: { estado: leitura.valida ? 'valida' : leitura.motivo === 'autorizacao.ausente' ? 'ausente' : 'invalida',
+            motivo: leitura.valida ? null : leitura.motivo, detalhe: leitura.valida ? null : leitura.detalhe,
+            por: a?.por ?? null, ate: a?.ate ?? null, pode: a ? [...a.pode] : [] },
+        pendentes: pendentes.map((p) => ({ ...p, quemFaz: (0, autorizacao_duravel_1.autorizada)(leitura, p.acao) && !p.bloqueio && !p.recusa ? 'varredura' : 'dono' })),
+        feitas: feitas.map((f) => ({ acao: f.acao, thread: f.thread, detalhe: f.detalhe, em: f.em, eventId: f.eventId })),
+    };
 }
 function montarPulse(carregado, opcoes = {}) {
     if (opcoes.registrar)
@@ -261,11 +346,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'] });
@@ -284,8 +370,9 @@ 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) => {
-                const leitura = (0, parado_no_condutor_1.lerPrsDaForja)(carregado, { quando, executor: opcoes.executorDoGh, 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, rodar: opcoes.rodarDaForja,
+                    sondas: opcoes.sondasDaForja });
                 if (leitura.ok) {
                     try {
                         (0, parado_no_condutor_1.gravarRetratoDePrs)(carregado.raiz, leitura.retrato);
@@ -315,8 +402,34 @@ function montarPulse(carregado, opcoes = {}) {
     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-063 (F5): o que a varredura faria sozinha, com a autorizacao duravel desta maquina. Leitura; falhar aqui nunca
+    // derruba a fila de atencao.
+    let varredura;
+    try {
+        const leitura = (0, autorizacao_duravel_1.lerAutorizacao)(carregado.raiz, { projeto: carregado.manifesto.project.name, agora: new Date(quando) });
+        // Com a consulta injetada (os testes) ou sem o runtime, as sessoes vem dela: sem a leitura, nada se afirma, e o
+        // registro e o MASTER ficam com o dono (`sessoes-sem-leitura`).
+        const injetada = opcoes.fantasmas || opcoes.consulta || opcoes.semRuntime;
+        const consultada = consulta;
+        const pendentes = (0, varredura_acoes_1.acoesPendentes)(carregado, { quando, ...(injetada ? {
+                fantasmas: opcoes.fantasmas ?? (() => null),
+                vivas: () => consultada.ok ? consultada.sessoes.filter((s) => typeof s.cwd === 'string' && !TERMINAIS_DA_CONSULTA.includes((0, hitl_1.estadoBruto)(s)))
+                    .map((s) => ({ sessionId: s.sessionId, cwd: s.cwd })) : null,
+            } : {}) });
+        // RM-063 (F7): o merge e o despacho que a ultima batida da conducao deixou pendentes (check pendente, sem autorizacao,
+        // conflito em codigo, PR em rascunho, fase sem prompt gravado), do retrato dela, enquanto ele vale.
+        pendentes.push(...(0, conducao_batida_1.pendentesDaUltimaBatida)(carregado.raiz, quando));
+        const feitas = (0, varredura_acoes_1.acoesFeitasDesde)(carregado.raiz, new Date(Date.parse(quando) - exports.JANELA_DAS_DECISOES_MS).toISOString());
+        varredura = varreduraDoPulse(leitura, pendentes, feitas);
+    }
+    catch (e) {
+        diagnosticos.push(`varredura.indisponivel: ${e.message.slice(0, 120)}`);
+    }
+    const pulse = comporPulse(carregado, { radar, monitor, orfas, batch: (0, master_1.pendentesDeScore)(carregado.raiz), ...(entregas ? { entregas } : {}),
+        ...(varredura ? { varredura } : {}) });
+    // 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.
@@ -337,43 +450,96 @@ function montarPulse(carregado, opcoes = {}) {
     catch (e) {
         diagnosticos.push(`hitl-conducao.indisponivel: ${e.message.slice(0, 120)}`);
     }
+    // RM-063 (F6): a maquina ociosa, leitura pura das vagas, das reservas locais e do passo do condutor.
+    try {
+        const ociosa = (0, maquina_ociosa_1.maquinaOciosa)(carregado, { quando });
+        if (ociosa)
+            pulse.maquinaOciosa = ociosa;
+    }
+    catch (e) {
+        diagnosticos.push(`ociosidade.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', 'prs.sem-leitura', 'entregas.indisponiveis'].some(d => p.runtime.detalhe.includes(d))) {
-        linhas.push(`[diagnostico] ${local(p.runtime.detalhe)}`);
+        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 }));
     }
     // 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('', `HITL de condução: ${h.abertas.length} aberta(s); ${(0, hitl_tempo_parado_1.textoDaMediana)(h)}`);
+        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('', `Ações automáticas pendentes: ${p.resumo.automaticas}`);
+    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)));
+    // RM-063 (F5): a autorizacao da varredura e o que ela fez sozinha na semana.
+    if (p.varredura) {
+        const v = p.varredura, a = v.autorizacao;
+        linhas.push('', a.estado === 'valida' ? m.varredura.autorizacaoValida(String(a.por), (0, horario_1.formatarDataHoraRotulada)(String(a.ate), { agora: p.consultadoEm }), a.pode.join(', ')) : a.estado === 'ausente' ? m.varredura.autorizacaoAusente : m.varredura.autorizacaoInvalida(String(a.motivo), String(a.detalhe)));
+        if (v.feitas.length) {
+            linhas.push(m.varredura.feitas(v.feitas.length));
+            for (const f of v.feitas)
+                linhas.push(m.varredura.feita(f.thread, f.acao, f.detalhe));
+        }
+    }
+    // RM-063 (F6): a maquina ociosa e as proximas threads sugeridas.
+    if (p.maquinaOciosa) {
+        const o = p.maquinaOciosa;
+        linhas.push('', m.ociosa.linha(o.maquina, o.livres, o.limite, o.reservados));
+        for (const s of o.sugeridas)
+            linhas.push(m.ociosa.sugerida(s.item, s.thread ? `${s.thread}, ${s.fase}` : m.ociosa.semThread, (0, locale_1.remontar)(s.passo), s.comando));
+    }
     return linhas.join('\n');
 }

package/dist/ratelimit.js

@@ -59,6 +59,7 @@ exports.dirRetry = dirRetry;
 exports.caminhoDaFila = caminhoDaFila;
 exports.lerFilaDeRetomada = lerFilaDeRetomada;
 exports.janelaPadraoMs = janelaPadraoMs;
+exports.arcoDoPedido = arcoDoPedido;
 exports.enfileirar = enfileirar;
 exports.prazoDaConta = prazoDaConta;
 exports.prazoDaCotaVista = prazoDaCotaVista;
@@ -73,6 +74,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; } });
@@ -103,6 +105,11 @@ function lerFilaDeRetomada(raiz) {
 function janelaPadraoMs(manifesto) {
     return manifesto.retry.janela_padrao_min * 60 * 1000;
 }
+/** RM-058 N4 (D17): o arco #Noctum do pedido, quando o despacho que caiu no limite de uso era dele. */
+function arcoDoPedido(pedido) {
+    const c = pedido.correlacao;
+    return typeof c === 'string' && c.startsWith('noctum:') && c.length > 'noctum:'.length ? c.slice('noctum:'.length) : null;
+}
 /**
  * Enfileira a fase morta por rate limit.
  *
@@ -136,6 +143,7 @@ function enfileirar(carregado, novo, agoraMs = Date.now()) {
         ...(novo.runtime !== undefined ? { runtime: novo.runtime } : {}),
         ...(novo.perfil !== undefined ? { perfil: novo.perfil } : {}),
         ...(novo.motivo !== undefined ? { motivo: novo.motivo } : {}),
+        ...(novo.correlacao ? { correlacao: novo.correlacao } : {}),
     };
     (0, util_1.anexarJsonl)(caminhoDaFila(raiz), pedido);
     return pedido;
@@ -204,26 +212,28 @@ 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)()) {
     const fila = lerFilaDeRetomada(raiz).sort((a, b) => a.id.localeCompare(b.id, 'en', { numeric: true }));
+    const m = (0, locale_1.msg)().retry.complementar;
     if (fila.length === 0) {
-        return 'Fila de rate limit vazia: nenhuma fase morreu por limite de uso neste projeto.';
+        return m.filaVazia;
     }
     const linhas = fila.map((p) => [
         p.id,
         p.thread,
         p.fase,
-        p.estado,
+        m.estados[p.estado] ?? p.estado,
         (0, horario_1.formatarDataHora)(p.liberaEm, { agora: quando }),
-        p.janelaEstimada ? `estimada (${p.sinal.fonte})` : `dita pelo runtime (${p.sinal.fonte})`,
+        p.janelaEstimada ? m.horaEstimada(p.sinal.fonte) : m.horaRuntime(p.sinal.fonte),
         p.estado === 'aguardando' ? faltaPara(p, quando) : '',
         String(p.tentativas),
     ]);
-    return (0, util_1.tabela)(['ID', 'THREAD', 'FASE', 'ESTADO', 'LIBERA EM', 'ORIGEM DA HORA', 'FALTA', 'TENT'], linhas) + `\n${(0, horario_1.legendaDoFuso)(undefined, quando)}`;
+    return (0, util_1.tabela)([...m.colunasFila], linhas) + `\n${(0, horario_1.legendaDoFuso)(undefined, quando)}`;
 }

package/dist/recall.js

@@ -65,6 +65,7 @@ const memoria_1 = require("./memoria");
 const orkmind_1 = require("./orkmind");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
+const locale_1 = require("./locale");
 /** Momento do ponteiro e momento pedido casam? Comparacao exata, sem case. */
 function momentoCasa(ponteiro, momento) {
     return ponteiro.retrieve_when.trim().toLowerCase() === momento.trim().toLowerCase();
@@ -291,18 +292,18 @@ function recallDaThread(carregado, memoria, threadId, opcoes = {}) {
 }
 /** Texto de `ork recall`. */
 function textoDoRecall(r, comConteudo = true) {
+    const m = (0, locale_1.msg)().operacao.restante.recall;
     const linhas = [];
-    linhas.push(`Recall da thread ${r.thread} no momento ${r.momento ?? '(todos)'} ` +
-        `(regime efetivo ${r.regime}, handoff escrito em regime ${r.regimeDoHandoff})`);
+    linhas.push(m.titulo(r.thread, r.momento ?? m.todos, r.regime, r.regimeDoHandoff));
     linhas.push('');
-    linhas.push(`RESOLVIDOS (${r.resolvidos.length}, entram no contexto agora):`);
+    linhas.push(m.resolvidos(r.resolvidos.length));
     for (const p of r.resolvidos) {
         linhas.push(`  ${p.id}  ${p.titulo}`);
-        linhas.push(`        via       ${p.via} (${p.metodo})`);
-        linhas.push(`        location  ${p.location}`);
+        linhas.push(m.via(p.via, p.metodo));
+        linhas.push(m.location(p.location));
         if (p.orkmind)
             linhas.push(`        orkmind   ${p.orkmind}`);
-        linhas.push(`        quando    ${p.retrieve_when}`);
+        linhas.push(m.quando(p.retrieve_when));
         if (comConteudo) {
             linhas.push('');
             for (const l of p.conteudo.split('\n'))
@@ -311,20 +312,20 @@ function textoDoRecall(r, comConteudo = true) {
         }
     }
     linhas.push('');
-    linhas.push(`ADIADOS (${r.adiados.length}, existem e NAO entram agora):`);
+    linhas.push(m.adiados(r.adiados.length));
     for (const p of r.adiados) {
         linhas.push(`  ${p.id}  ${p.titulo}`);
-        linhas.push(`        quando    ${p.retrieve_when}`);
-        linhas.push(`        onde      ${p.location}`);
-        linhas.push(`        recuperar ork recall ${r.thread} --fase ${p.retrieve_when}`);
+        linhas.push(m.quando(p.retrieve_when));
+        linhas.push(m.onde(p.location));
+        linhas.push(m.recuperar(r.thread, p.retrieve_when));
     }
     if (r.falhas.length > 0) {
         linhas.push('');
-        linhas.push(`FALHAS (${r.falhas.length}):`);
+        linhas.push(m.falhas(r.falhas.length));
         for (const p of r.falhas) {
             linhas.push(`  ${p.id}  ${p.titulo}`);
-            linhas.push(`        motivo    ${p.motivo}`);
-            linhas.push(`        detalhe   ${p.detalhe}`);
+            linhas.push(m.motivo(p.motivo));
+            linhas.push(m.detalhe(p.detalhe));
         }
     }
     return linhas.join('\n');

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;
+}

package/dist/rede-adesao.js

@@ -64,6 +64,7 @@ const path = __importStar(require("node:path"));
 const maquina_1 = require("./maquina");
 const monitor_lock_1 = require("./monitor-lock");
 const util_1 = require("./util");
+const locale_1 = require("./locale");
 exports.CONTRATO_DA_ADESAO = 'ork.rede/v1';
 exports.REPOSITORIO_PADRAO = 'orkastery-network';
 /**
@@ -78,6 +79,8 @@ exports.pastaDaRede = pastaDaRede;
 const arquivoDaConfig = () => path.join((0, maquina_1.pastaDoUsuario)(), 'rede.json');
 const arquivoDaTentativa = () => path.join((0, exports.pastaDaRede)(), 'tentativa.json');
 const IDENTIFICADOR = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/;
+/** O dono da casa: o login, ou o caminho de um grupo com subgrupos (`time/sub`). */
+const DONO = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}(?:\/[A-Za-z0-9][A-Za-z0-9._-]{0,99}){0,19}$/;
 const HOST = /^[A-Za-z0-9.-]+(?::\d+)?$/;
 const texto = (v, padrao) => typeof v === 'string' && padrao.test(v) ? v : null;
 function lerConfigDaRede() {
@@ -88,7 +91,7 @@ function lerConfigDaRede() {
         return {
             contrato: exports.CONTRATO_DA_ADESAO, membro: bruto.membro,
             forja: bruto.forja === 'github' || bruto.forja === 'gitlab' ? bruto.forja : null,
-            host: texto(bruto.host, HOST), dono: texto(bruto.dono, IDENTIFICADOR), repositorio: texto(bruto.repositorio, IDENTIFICADOR),
+            host: texto(bruto.host, HOST), dono: texto(bruto.dono, DONO), repositorio: texto(bruto.repositorio, IDENTIFICADOR),
             atualizadoEm: typeof bruto.atualizadoEm === 'string' ? bruto.atualizadoEm : '',
         };
     }
@@ -108,11 +111,13 @@ function gravarConfigDaRede(mudanca) {
         repositorio: mudanca.repositorio !== undefined ? mudanca.repositorio : atual?.repositorio ?? null,
         atualizadoEm: new Date().toISOString(),
     };
-    if (config.host !== null && !HOST.test(config.host))
-        throw new Error(`rede.config: host invalido ("${config.host}")`);
-    for (const [campo, valor] of [['dono', config.dono], ['repositorio', config.repositorio]]) {
-        if (valor !== null && !IDENTIFICADOR.test(valor))
-            throw new Error(`rede.config: ${campo} invalido ("${valor}")`);
+    if (config.host !== null && !HOST.test(config.host)) {
+        const host = config.host;
+        throw new locale_1.ErroDoCatalogo((m) => m.network.hostInvalido(host));
+    }
+    for (const [campo, valor, padrao] of [['dono', config.dono, DONO], ['repositorio', config.repositorio, IDENTIFICADOR]]) {
+        if (valor !== null && !padrao.test(valor))
+            throw new locale_1.ErroDoCatalogo((m) => m.network.campoInvalido(campo, valor));
     }
     const dir = (0, maquina_1.pastaDoUsuario)();
     fs.mkdirSync(dir, { recursive: true });
@@ -180,7 +185,7 @@ function idDaMaquina() {
     }
     const persistido = lerId(arquivo);
     if (!persistido)
-        throw new Error(`rede.id: nao consegui gravar nem ler ${arquivo}`);
+        throw new locale_1.ErroDoCatalogo((m) => m.network.idNaoGravou(arquivo));
     return persistido;
 }
 function gravarTemporario(conteudo) {
@@ -290,7 +295,7 @@ function trocarIdInvalido(arquivo, st) {
             return;
     }
     else {
-        throw new Error(`rede.id: ${arquivo} nao e um arquivo; apague-o e rode de novo`);
+        throw new locale_1.ErroDoCatalogo((m) => m.network.idNaoArquivo(arquivo));
     }
     // X6 do CHECK 6: a reserva da troca e chaveada pelo que todo host ve igual do arquivo ruim (conteudo,
     // tamanho e hora); `dev` e local a cada host e fica so no id derivado, o caminho de quando a reserva falha.