@orkastery/cli 0.6.1 → 0.6.2

package/dist/rede.js

@@ -73,7 +73,7 @@ exports.painelDaRede = painelDaRede;
  * fora de qualquer clone de projeto.
  *
  * D3: publicar exige o repositorio privado, conferido na forja antes de cada publicacao.
- * D5: o retrato e uma LISTA DE PERMISSAO (maquina, hostname, forjas, runtimes, hosts, projetos,
+ * D5: o retrato e uma LISTA DE PERMISSAO (maquina, alias legado, forjas, runtimes, hosts, projetos,
  * versao do `ork`, batida) e passa por uma varredura de segredo antes do push: um achado recusa a
  * publicacao inteira, e o erro diz o padrao e o campo, nunca o valor.
  * D6: cada maquina so escreve o proprio retrato; o `REDE.md` e indice derivado que quem publica
@@ -191,6 +191,17 @@ function hostnameSeguro() {
     const bruto = os.hostname().trim();
     return /^[A-Za-z0-9][A-Za-z0-9._-]{0,252}$/.test(bruto) ? bruto : bruto.replace(/[^A-Za-z0-9._-]+/g, '-').slice(0, 253) || 'desconhecido';
 }
+/**
+ * RM-062 F3: o nome que sai da maquina precisa ter sido escolhido localmente. O fallback historico
+ * para `os.hostname()` transformava um detalhe privado em nome de arquivo e em JSON. A configuracao
+ * fica em `~/.orkastery/maquina.json`; `--maquina` e `ORK_MAQUINA` cobrem a primeira entrada.
+ */
+function nomeGenericoDaRede(explicito) {
+    const nome = (explicito ?? '').trim() || (0, maquina_1.lerConfigDaMaquina)()?.nome || (process.env.ORK_MAQUINA ?? '').trim();
+    if (!nome)
+        throw new locale_1.ErroDoCatalogo((m) => m.network.nomeGenericoAusente);
+    return nomeSeguro(nome);
+}
 /** O retrato desta maquina, montado so com os campos da lista de permissao (D5). */
 function retratoDaMaquina(opcoes = {}) {
     return retratoComDescartes(opcoes).retrato;
@@ -199,7 +210,7 @@ function retratoDaMaquina(opcoes = {}) {
  * O retrato e os projetos que ficaram fora dele. Projeto vem de fora do nucleo (o registro da
  * RM-052, o cwd, o ultimo retrato): um valor dele com cara de segredo tira SO aquele projeto, com
  * aviso, em vez de travar a publicacao da maquina para sempre (A1 do CHECK 1). O que o nucleo monta
- * (maquina, hostname, forjas, runtimes, hosts) continua falhando fechado em `exigirRetratoSeguro`.
+ * (maquina, alias legado, forjas, runtimes, hosts) continua falhando fechado em `exigirRetratoSeguro`.
  */
 function retratoComDescartes(opcoes = {}) {
     const amb = opcoes.amb ?? {};
@@ -248,11 +259,12 @@ function retratoComDescartes(opcoes = {}) {
         descartados.push({ campo: `projetos[${exports.MAXIMO_DE_ITENS}..]`, padrao: `limite de ${exports.MAXIMO_DE_ITENS} projetos` });
         limpos.length = exports.MAXIMO_DE_ITENS;
     }
+    const maquina = nomeGenericoDaRede(opcoes.maquina);
     const retrato = {
         contrato: exports.CONTRATO_DO_RETRATO,
-        maquina: nomeSeguro((0, maquina_1.nomeDaMaquina)(opcoes.maquina)),
+        maquina,
         ...(opcoes.id ? { id: opcoes.id } : {}),
-        hostname: hostnameSeguro(),
+        hostname: maquina,
         adesao: opcoes.adesao ?? (0, rede_adesao_1.adesaoDaRede)().adesao ?? 'rede',
         forjas: identidades.map((i) => ({ forja: i.forja, host: i.host, cli: i.cli, versao: i.versao, usuario: i.usuario })),
         runtimes,
@@ -785,10 +797,9 @@ function gravarNaCasa(conferida, retrato, descartados, opcoes) {
             const idDoOutro = atual ? atual.id ?? null : idNoArquivo(cache, ponta, arquivoDoRetrato(maquina));
             const alheio = !!idDoOutro && idDoOutro !== retrato.id;
             if (alheio && !opcoes.tomarNome) {
-                // U7 da revisao 3: o hostname igual sugere a propria maquina, mas duas VMs podem se chamar `ubuntu`.
-                const mesmoHostname = atual?.hostname === hostnameSeguro();
+                // O campo legado `hostname` agora repete o alias generico e nao distingue instalacoes.
                 const outro = atual ? { hostname: atual.hostname, publicadoEm: atual.publicadoEm } : null;
-                throw new locale_1.ErroDoCatalogo((m) => m.network.nomeEmUso(maquina, outro ? m.network.quemHostname(String(outro.hostname), (0, horario_1.formatarDataHora)(outro.publicadoEm)) : m.network.quemIlegivel, mesmoHostname ? m.network.dicaMesmoHostname : m.network.dicaOutroNome));
+                throw new locale_1.ErroDoCatalogo((m) => m.network.nomeEmUso(maquina, outro ? m.network.quemHostname(String(outro.hostname), (0, horario_1.formatarDataHora)(outro.publicadoEm)) : m.network.quemIlegivel, m.network.dicaNomeEmUso));
             }
             const mudancas = [
                 { caminho: arquivoDoRetrato(maquina), conteudo: JSON.stringify(retrato, null, 2) + '\n' },
@@ -819,7 +830,7 @@ function publicarRede(opcoes = {}) {
     if (!adesao.membro)
         throw new locale_1.ErroDoCatalogo((m) => m.network.foraDaRede);
     const amb = opcoes.amb ?? {};
-    const maquina = nomeSeguro((0, maquina_1.nomeDaMaquina)(opcoes.maquina));
+    const maquina = nomeGenericoDaRede(opcoes.maquina);
     const id = (0, rede_adesao_1.idDaMaquina)();
     const agora = opcoes.agora ?? new Date().toISOString();
     const marca = lerMarcaDaRede();
@@ -860,12 +871,13 @@ const NOME_DE_MAQUINA = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
  * `ork network entrar`. M2 do CHECK 1: atomico do ponto de vista da maquina. Confere (e cria,
  * privada) a casa, publica o primeiro retrato e SO ENTAO grava o nome e a adesao; se a publicacao
  * falha, nada muda aqui. M3: o nome que vale e gravado, como no `ork fabrica entrar`: `--maquina`,
- * senao o ja gravado, senao `ORK_MAQUINA` ou o hostname; assim o cron publica com o mesmo nome.
+ * senao o ja gravado, senao `ORK_MAQUINA`; assim o cron publica com o mesmo nome. RM-062 F3:
+ * hostname nunca e fallback, porque nome de arquivo e JSON sao evidencia publicada.
  */
 function entrarNaRede(opcoes = {}) {
-    // O nome explicito tem de ser valido; o que vem do arquivo, de ORK_MAQUINA ou do hostname e saneado.
+    // O nome explicito tem de ser valido; o que vem do arquivo ou de ORK_MAQUINA e saneado.
     const explicito = (opcoes.maquina ?? '').trim();
-    const maquina = explicito || nomeSeguro((0, maquina_1.lerConfigDaMaquina)()?.nome || (0, maquina_1.nomeDaMaquina)());
+    const maquina = explicito || nomeGenericoDaRede();
     if (!NOME_DE_MAQUINA.test(maquina)) {
         throw new locale_1.ErroDoCatalogo((m) => m.network.nomeInvalido(maquina));
     }
@@ -896,7 +908,7 @@ function entrarNaRede(opcoes = {}) {
 function sairDaRede(opcoes = {}) {
     // U3 da revisao 3: a saida local vem primeiro; nada depois dela pode deixar a maquina membro.
     (0, rede_adesao_1.gravarConfigDaRede)({ membro: false });
-    const maquina = nomeSeguro((0, maquina_1.nomeDaMaquina)(opcoes.maquina));
+    const maquina = nomeGenericoDaRede(opcoes.maquina);
     const r = resolverCasa(opcoes);
     if (r.casa)
         (0, rede_adesao_1.gravarConfigDaRede)({ forja: r.casa.forja, host: r.casa.host, dono: r.casa.dono, repositorio: r.casa.repositorio });

package/dist/retry.js

@@ -288,6 +288,12 @@ exports.POLITICA_DE_RETRY = {
         automatica: true,
         ...TEXTOS_DA_POLITICA['lease.busy'],
     },
+    'concurrency.lease-indeterminado': {
+        motivo: 'concurrency.lease-indeterminado',
+        acao: 'esperar-janela',
+        automatica: false,
+        ...TEXTOS_DA_POLITICA['concurrency.lease-indeterminado'],
+    },
     // I-36 (T6): a vez chega quando a conducao atual terminar. Redespachar agora so recebe a mesma recusa,
     // e passar na frente de quem conduz e exatamente o incidente de 19/09/2026.
     'conducao.em-andamento': {
@@ -296,6 +302,12 @@ exports.POLITICA_DE_RETRY = {
         automatica: true,
         ...TEXTOS_DA_POLITICA['conducao.em-andamento'],
     },
+    'conducao.acao-necessaria': {
+        motivo: 'conducao.acao-necessaria',
+        acao: 'esperar-janela',
+        automatica: false,
+        ...TEXTOS_DA_POLITICA['conducao.acao-necessaria'],
+    },
     // I-41 (D10): formato e defeito de quem escreveu o pedido, e a spec dirigida conserta.
     // Escalar isto para o dono seria pedir que ele revise a sintaxe do robo.
     'hitl.formato': {

package/dist/security-scan/cli.js

@@ -55,7 +55,7 @@ function executarSecurityScan(argv, ctx) {
         const message = e.message;
         if (!/^security-scan\.(config-invalid|dismissal-invalid)/.test(message))
             throw e;
-        console.error(message);
+        console.error(json ? message : m.error(message));
         return 1;
     }
     const files = (0, report_1.writeReport)(ctx.estado, report);
@@ -68,7 +68,7 @@ function executarSecurityScan(argv, ctx) {
         if (notRun.length) {
             ctx.escrever(m.notRunHeading);
             for (const r of notRun)
-                ctx.escrever(m.notRun(r.name, m.states[r.state] ?? r.state, r.reason ?? ''));
+                ctx.escrever(m.notRun(r.name, m.states[r.state] ?? r.state, m.reason(r.reason ?? '')));
         }
         ctx.escrever(files.md);
     }

package/dist/security-scan/report.js

@@ -143,7 +143,7 @@ function renderMarkdown(report) {
     else {
         out.push(`| ${m.tableTool} | ${m.tableExecutor} | ${m.tableState} | ${m.tableReason} |`, '| --- | --- | --- | --- |');
         for (const r of report.tools) {
-            out.push(`| ${cell(r.name)} | ${r.executor ?? m.noExecutor} | ${m.states[r.state] ?? r.state} | ${cell(r.reason ?? '')} |`);
+            out.push(`| ${cell(r.name)} | ${r.executor ?? m.noExecutor} | ${m.states[r.state] ?? r.state} | ${cell(m.reason(r.reason ?? ''))} |`);
         }
     }
     const news = report.findings.filter(f => f.status === 'new');

package/dist/session-watcher.js

@@ -61,6 +61,17 @@ const session_watcher_claude_1 = require("./session-watcher-claude");
 const session_watcher_grok_1 = require("./session-watcher-grok");
 const conta_esgotada_1 = require("./conta-esgotada");
 const trabalho_thread_1 = require("./trabalho-thread");
+const pedido_conducao_1 = require("./pedido-conducao");
+/** O gate estreito da própria sessão vence diagnósticos genéricos do watcher. */
+function pedidoDaConducao(eventos, sessionId, despachoEm) {
+    const evento = eventos.filter(e => e.tipo === 'gate_blocked' && e.origem === 'mcp.request_conduction' &&
+        e.sessionId === sessionId && e.despachoEm === despachoEm && typeof e.motivo === 'string' &&
+        pedido_conducao_1.MOTIVOS_DE_PEDIDO_A_CONDUCAO.includes(e.motivo) &&
+        typeof e.comando === 'string' && typeof e.despacho === 'string').at(-1);
+    return evento ? { motivo: evento.motivo, comando: evento.comando,
+        detalhe: typeof evento.detalhe === 'string' ? evento.detalhe : 'sessão solicitou ação da condução',
+        despacho: evento.despacho } : null;
+}
 /** Falhas operacionais e bloqueios sem retry automático não alegam conclusão do produto. */
 function bloqueioPreservado(terminal) {
     return terminal.classificacao === 'gate_blocked' && terminal.motivo !== null &&
@@ -474,18 +485,25 @@ function reconciliarSessaoSemWatcher(carregado, threadId, agoraMs = Date.now())
             if (atuais.some(e => e.tipo === 'phase_result' && e.sessionId === sessao.sessionId &&
                 e.despachoEm === sessao.despachadaEm))
                 return;
+            const pedido = pedidoDaConducao(atuais, sessao.sessionId, sessao.despachadaEm);
             const dados = { fase: sessao.fase, sessionId: sessao.sessionId, despachoEm: sessao.despachadaEm,
-                sensorResultId, classificacao: 'gate_blocked', motivo: 'runtime.unavailable', runtime: sessao.runtime,
-                fonte: 'conducao.batida: sessão verificada sem watcher e sem evento útil', fonteVencedora: null,
+                sensorResultId, classificacao: 'gate_blocked', motivo: pedido?.motivo ?? 'runtime.unavailable', runtime: sessao.runtime,
+                fonte: pedido ? 'mcp.request_conduction: parada intencional tipada pela sessão'
+                    : 'conducao.batida: sessão verificada sem watcher e sem evento útil', fonteVencedora: null,
                 ok: false, conclusaoNativa: false, conclusaoNativaAusente: 'watcher ausente e fonte indisponível além do limite',
                 estado: 'bloqueada', observadoEm: new Date(agoraMs).toISOString(), gate: 'phase.dispatch',
-                origem: 'conducao.batida', morteLatenciaMs: agoraMs - ultimoUtil };
-            (0, ledger_1.registrar)(dir, threadId, 'sessao_morta', dados);
+                origem: 'conducao.batida', morteLatenciaMs: agoraMs - ultimoUtil,
+                ...(pedido ? { detalhe: pedido.detalhe, correcao: pedido.comando, comando: pedido.comando,
+                    pedidoConducao: { contrato: 'ork.pedido-conducao/v1', despacho: pedido.despacho, estado: 'aberto' } } : {}) };
+            if (!pedido)
+                (0, ledger_1.registrar)(dir, threadId, 'sessao_morta', dados);
             (0, ledger_1.registrar)(dir, threadId, 'gate_blocked', dados);
             (0, ledger_1.registrar)(dir, threadId, 'phase_result', dados);
         });
         return { thread: threadId, sessionId: sessao.sessionId, estado: 'parada',
-            detalhe: 'sessão verificada sem watcher e sem evento útil além do limite' };
+            detalhe: pedidoDaConducao((0, ledger_1.lerLedger)(dir), sessao.sessionId, sessao.despachadaEm)
+                ? 'sessão parou com pedido tipado para a condução'
+                : 'sessão verificada sem watcher e sem evento útil além do limite' };
     }
 }
 function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registrada }, opcoes) {
@@ -714,6 +732,7 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
                 }
                 if (!podeTerminar)
                     return { ...base, bytesLidos };
+                const pedido = pedidoDaConducao(atuais, sessionId, sessao.despachadaEm);
                 const semTerminal = !terminal;
                 // Fato registrado para a autoridade de revisão: `null` só com terminal nativo correlacionado.
                 const conclusaoNativa = incompleto || invalido || aberto || descorrelacionado
@@ -726,6 +745,11 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
                     terminal = { classificacao: 'gate_blocked', motivo: 'runtime.silencio',
                         timestamp: new Date(now).toISOString(), turnId: null, fonte: 'processo ausente e arquivos estáveis',
                         tokens: new codex_events_1.ParserCodex().estado.tokens, duracaoMs: null };
+                if (pedido && (terminal.classificacao === 'fase_concluida' ||
+                    terminal.classificacao === 'gate_blocked' && ['runtime.unavailable', 'runtime.silencio'].includes(terminal.motivo ?? ''))) {
+                    terminal = { ...terminal, classificacao: 'gate_blocked', motivo: pedido.motivo,
+                        fonte: `mcp.request_conduction: ${pedido.detalhe}` };
+                }
                 if (fechamento && (fechamento.exitCode !== 0 || fechamento.signal || fechamento.erro) &&
                     terminal.classificacao !== 'human.pending' && !bloqueioPreservado(terminal)) {
                     terminal = { ...terminal, classificacao: 'gate_blocked', motivo: 'runtime.unavailable' };
@@ -739,7 +763,7 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
                     ? (0, trabalho_thread_1.gravarRespostaFinalDaSessao)(carregado.raiz, thread.id, sessionId, terminal.respostaFinal) : null;
                 const dados = { fase: sessao.fase, sessionId, despachoEm: sessao.despachadaEm, sensorResultId: resultadoId,
                     classificacao: terminal.classificacao, motivo: terminal.motivo, runtime: 'codex', fonte: terminal.fonte,
-                    fonteVencedora: incompleto || invalido || aberto || descorrelacionado ? null : terminais[0]?.nome ?? null,
+                    fonteVencedora: pedido || incompleto || invalido || aberto || descorrelacionado ? null : terminais[0]?.nome ?? null,
                     turnId: terminal.turnId, numeroTurno: terminal.numeroTurno ?? null,
                     tokens: terminal.tokens, exitCode: fechamento?.exitCode ?? null, exitCodeFonte: fechamento?.fonte ?? 'unavailable',
                     signal: fechamento?.signal ?? null, duracaoMs: fechamento?.duracaoMs ?? terminal.duracaoMs,
@@ -750,11 +774,13 @@ function observarSessaoResolvida(carregado, sessionId, { thread, sessao: registr
                     estado: terminal.classificacao === 'fase_concluida' ? 'concluida' : 'bloqueada',
                     observadoEm: terminal.timestamp, gate: 'phase.dispatch', origem: 'sessions.watch',
                     morteLatenciaMs: morte ? now - cursor.progressoEm : null, ...(perfil ? { perfil } : {}),
+                    ...(pedido ? { detalhe: pedido.detalhe, correcao: pedido.comando, comando: pedido.comando,
+                        pedidoConducao: { contrato: 'ork.pedido-conducao/v1', despacho: pedido.despacho, estado: 'aberto' } } : {}),
                     ...(respostaFinal ? { respostaFinal: { arquivo: (0, trabalho_thread_1.caminhoDoTrabalho)(thread.id) + respostaFinal.arquivo,
                             sha256: respostaFinal.sha256, bytes: respostaFinal.bytes, truncada: respostaFinal.truncada } } : {}),
                     ...(conta ? { falhaDeConta: { motivo: conta.falha.motivo, resetEm: conta.falha.resetEm, fonte: conta.falha.fonte,
                             trecho: conta.falha.trecho } } : {}) };
-                const tipo = semTerminal && morte && !incompleto && !conta ? 'sessao_morta' : terminal.classificacao;
+                const tipo = semTerminal && morte && !incompleto && !conta && !pedido ? 'sessao_morta' : terminal.classificacao;
                 // I-33 (D12): o perfil sai do rodizio na primeira gravacao do resultado, onde a evidencia esta.
                 if (conta && perfil && !atuais.some(e => e.tipo === 'phase_result' && e.sensorResultId === resultadoId)) {
                     try {

package/dist/verify.js

@@ -78,6 +78,7 @@ const thread_1 = require("./thread");
 const estado_thread_1 = require("./estado-thread");
 const dependencias_da_worktree_1 = require("./dependencias-da-worktree");
 const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
 const node_fs_1 = require("node:fs");
 const path = __importStar(require("node:path"));
 const node_path_1 = require("node:path");
@@ -98,6 +99,7 @@ const check_modo_1 = require("./check-modo");
 const check_agil_1 = require("./check-agil");
 const check_paralelo_1 = require("./check-paralelo");
 const agendador_cpu_1 = require("./agendador-cpu");
+const changelog_check_1 = require("./changelog-check");
 /** 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. */
@@ -302,6 +304,7 @@ function comandoNoLedger(c) {
     // RM-072 (D2): a duracao vai tambem no comando que passa, para a meta do CHECK ser medida pelo ledger. RM-072 (D4, D5):
     // no Agile, o uso do preparo e as lanes; o Classic nao tem esses campos.
     const doAgile = { ...(c.preparo ? { preparo: c.preparo } : {}),
+        ...(c.lane ? { lane: c.lane } : {}),
         ...(c.lanes ? { lanes: c.lanes.map((l) => ({ ...l, comando: (0, redacao_url_1.redigirCredenciaisUrl)(l.comando) })) } : {}),
         ...(c.comandoExecutado ? { comandoExecutado: (0, redacao_url_1.redigirCredenciaisUrl)(c.comandoExecutado) } : {}) };
     if (c.ok)
@@ -327,6 +330,19 @@ function comandosDoManifesto(manifesto) {
     }
     return lista;
 }
+/** A regra estrutural do CHANGELOG entra no mesmo veredito e na mesma baseline dos comandos do manifesto. */
+function verificarChangelog(cwd, base, baseCarimbada) {
+    if (!(0, changelog_check_1.changelogAplicavel)(cwd))
+        return null;
+    const inicio = Date.now();
+    const comando = `node core/scripts/checar-changelog.cjs --base "${base}"`;
+    const r = (0, changelog_check_1.checarChangelog)(cwd, { base, head: 'HEAD', baseCarimbada });
+    return {
+        nome: 'changelog', comando, ok: r.ok, code: r.ok ? 0 : r.motivo === 'changelog.base-indisponivel' ? 2 : 1,
+        resumo: r.ok ? r.detalhe : `${r.motivo}: ${r.detalhe}\ncorrecao: ${r.correcao ?? 'corrija o CHANGELOG'}`,
+        causa: 'exit', prazoMs: 0, duracaoMs: Date.now() - inicio, executado: true,
+    };
+}
 /**
  * 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`,
@@ -464,12 +480,15 @@ function agileNoLedger(raiz, threadId, commit, pecasDoVerify, doAgile, guarda, r
     relatorio.fechar();
     const doRelatorio = (0, check_agil_1.pecasDoRelatorio)(linhas);
     const listas = (0, check_agil_1.listasDasLanes)(linhas);
+    const resultados = (0, check_agil_1.resultadosDasLanes)(linhas);
     const usos = claims.flatMap((c) => c.execucoes.map((e) => e.preparo).filter((u) => !!u));
+    const usosDasLanes = claims.flatMap((c) => c.execucoes.filter((e) => e.lane));
     const resumo = {
         pecas: [...pecasDoVerify, ...doRelatorio],
         grupo: { paralelo: doAgile?.paralelo ?? false, lanes: doAgile?.lanes ?? [] },
         produto: guarda.hashCurto(),
-        claims: { reaproveitadas: usos.filter((u) => u.reaproveitado).length, inteiras: usos.filter((u) => !u.reaproveitado).length },
+        claims: { reaproveitadas: usos.filter((u) => u.reaproveitado).length, inteiras: usos.filter((u) => !u.reaproveitado).length,
+            lanes: usosDasLanes.length },
         lanes: listas.map((l) => ({ lane: l.lane, arquivos: l.arquivos.length, sha256: l.sha256 })),
         orcamento: linhas.filter((l) => l.tipo === 'duracoes').map(({ tipo: _tipo, ...resto }) => resto),
     };
@@ -478,7 +497,7 @@ function agileNoLedger(raiz, threadId, commit, pecasDoVerify, doAgile, guarda, r
         const arquivo = path.join((0, thread_1.dirThread)(raiz, threadId), 'check', `${commit.slice(0, 12)}-lanes.json`);
         try {
             fs.mkdirSync(path.dirname(arquivo), { recursive: true, mode: 0o700 });
-            fs.writeFileSync(arquivo, JSON.stringify({ commit, lanes: listas.map((l) => ({ lane: l.lane, arquivos: l.arquivos })) }, null, 1) + '\n', { mode: 0o600 });
+            fs.writeFileSync(arquivo, JSON.stringify({ commit, lanes: listas.map((l) => ({ lane: l.lane, arquivos: l.arquivos })), resultados }, null, 1) + '\n', { mode: 0o600 });
             resumo.evidencia = path.relative((0, estado_thread_1.raizDoEstado)(raiz), arquivo);
         }
         catch { /* sem o arquivo, o ledger ainda guarda a contagem e o sha256 de cada lane */ }
@@ -529,7 +548,7 @@ function exigirDependenciasDaWorktree(carregado, threadId, cwd, operacao, conduc
 }
 /** `ork verify --baseline`: grava o estado do mundo ANTES do GO. Sem `executor`, o da rodada (`executorDaRodada`). */
 function gravarBaseline(carregado, threadId, executor, conducao = {}, origem = 'cli', leitor = steal_1.lerProcStat, modo) {
-    const pedido = pedidoDoVerify(carregado, threadId, 'baseline', comandosDoManifesto(carregado.manifesto).length, conducao);
+    const pedido = pedidoDoVerify(carregado, threadId, 'baseline', comandosDoManifesto(carregado.manifesto).length + 1, conducao);
     return (0, conducao_1.comConducao)(carregado.raiz, threadId, pedido, (tomada) => naFilaPesada(carregado, threadId, 'baseline', conducao, () => gravarBaselineSobConducao(carregado, threadId, executor, tomada, origem, leitor, modo)));
 }
 function gravarBaselineSobConducao(carregado, threadId, base, tomada, origem, leitor, modo) {
@@ -551,7 +570,7 @@ function gravarBaselineSobConducao(carregado, threadId, base, tomada, origem, le
     // seria reaproveitado e os comandos rodam como no Classic.
     // RM-072 (A6 do CHECK): as pecas do preparo, do grupo e do relatorio vao ao `baseline_recorded`, como no `verify_run`.
     const pecasDaBaseline = [];
-    const comandos = relatorio && manifesto.check?.agile?.produto?.length
+    const comandosDoManifestoExecutados = relatorio && manifesto.check?.agile?.produto?.length
         ? (() => {
             const p = (0, check_agil_1.prepararNoAgile)(manifesto, cwd, executor);
             pecasDaBaseline.push(...p.pecas);
@@ -560,6 +579,8 @@ function gravarBaselineSobConducao(carregado, threadId, base, tomada, origem, le
             return r.comandos;
         })()
         : comandosDoManifesto(manifesto).map((c) => executorDosComandos(c.nome, c.comando, cwd));
+    const changelog = verificarChangelog(cwd, manifesto.worktree.base_branch, thread.base?.commit);
+    const comandos = changelog ? [...comandosDoManifestoExecutados, changelog] : comandosDoManifestoExecutados;
     if (relatorio) {
         if (base)
             pecasDaBaseline.push(check_agil_1.PECA_SEM_RELATORIO);
@@ -582,7 +603,9 @@ function gravarBaselineSobConducao(carregado, threadId, base, tomada, origem, le
         commit: baseline.commit,
         cwd,
         comandos: comandos.map((c) => ({ nome: c.nome, comando: c.comando, ok: c.ok, code: c.code, prazoMs: c.prazoMs ?? null,
-            ...(c.duracaoMs !== undefined ? { duracaoMs: c.duracaoMs } : {}), ...(c.ok ? {} : { causa: c.causa ?? null }) })),
+            ...(c.duracaoMs !== undefined ? { duracaoMs: c.duracaoMs } : {}), ...(c.ok ? {} : { causa: c.causa ?? null }),
+            ...(c.testeQueCaiu?.length ? { testeQueCaiu: c.testeQueCaiu } : {}),
+            ...(c.lanes?.length ? { lanes: c.lanes.map((l) => ({ ...l, comando: (0, redacao_url_1.redigirCredenciaisUrl)(l.comando) })) } : {}) })),
         check: checkNoLedger(check),
         ...(pecasDaBaseline.length ? { agile: { pecas: pecasDaBaseline } } : {}),
         // RM-037 (defeito 1 de 19 e 20/10/2026): o que a baseline nao provou fica dito no proprio evento.
@@ -592,6 +615,38 @@ function gravarBaselineSobConducao(carregado, threadId, base, tomada, origem, le
     });
     return baseline;
 }
+function nomesUnicos(nomes) {
+    return [...new Set(nomes ?? [])];
+}
+/** Compara os conjuntos que o runner realmente nomeou; sucesso prova que o conjunto atual e vazio. */
+function compararComBaseline(atual, antes) {
+    if (atual.ok && antes.ok)
+        return null;
+    const nomesAntes = nomesUnicos(antes.testeQueCaiu);
+    const nomesAtuais = nomesUnicos(atual.testeQueCaiu);
+    const baselineNominal = antes.ok || nomesAntes.length > 0;
+    const rodadaNominal = atual.ok || nomesAtuais.length > 0;
+    if (baselineNominal && rodadaNominal) {
+        const antesSet = new Set(nomesAntes);
+        const atualSet = new Set(nomesAtuais);
+        return {
+            comando: atual.nome,
+            granularidade: 'teste',
+            regressoes: nomesAtuais.filter((nome) => !antesSet.has(nome)),
+            preExistentes: nomesAtuais.filter((nome) => antesSet.has(nome)),
+            corrigidos: nomesAntes.filter((nome) => !atualSet.has(nome)),
+        };
+    }
+    return {
+        comando: atual.nome,
+        granularidade: 'comando',
+        regressoes: [],
+        preExistentes: [],
+        corrigidos: [],
+        classificacaoDoComando: atual.ok ? 'corrigido' : antes.ok ? 'regressao' : 'pre-existente',
+        motivoDoFallback: baselineNominal ? 'rodada-sem-nomes' : 'baseline-sem-nomes',
+    };
+}
 /**
  * Reexecuta a claim no HEAD real e devolve o veredito com o motivo tipado.
  *
@@ -656,6 +711,7 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
     const inicioDaRodada = Date.now();
     const thread = (0, thread_1.lerThread)(raiz, threadId);
     const cwd = cwdDaThread(raiz, thread);
+    opcoes.progresso?.('preflight');
     exigirDependenciasDaWorktree(carregado, threadId, cwd, 'verify', conducao, opcoes.executor);
     const commit = commitReal(cwd);
     const dir = (0, thread_1.dirThread)(raiz, threadId);
@@ -673,14 +729,26 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
     // RM-072 (D8): no Agile, as pecas contam o que rodaram num relatorio da rodada, lido no fim.
     const agil = check.modo === 'agile';
     const relatorio = agil ? new check_agil_1.RelatorioDoCheck() : null;
-    const ambienteDaRodada = { ...ambienteDoModo(check), ...relatorio?.ambiente() };
+    const casaDaRodada = agil && !(process.env.ORKASTERY_HOME || '').trim()
+        ? fs.mkdtempSync(path.join(os.tmpdir(), 'ork-verify-casa-')) : null;
+    const ambienteFuncional = { ...ambienteDoModo(check), ...(casaDaRodada ? { ORKASTERY_HOME: casaDaRodada } : {}) };
+    const ambienteDaRodada = { ...ambienteFuncional, ...relatorio?.ambiente() };
     // 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(executorDaRodada(manifesto, instabilidade, opcoes.executor, leitor, ambienteDaRodada), manifesto, conducao);
+    const observar = (base) => opcoes.progresso
+        ? (nome, comando, dir) => { opcoes.progresso(nome); return base(nome, comando, dir); }
+        : base;
+    const executor = executorSobConducao(observar(executorDaRodada(manifesto, instabilidade, opcoes.executor, leitor, ambienteDaRodada)), manifesto, conducao);
     // RM-072 (A3 do CHECK): as claims recebem o modo, nunca o relatorio da rodada; o teste que roda a varredura dentro de uma
     // claim gravaria pecas de fixture no relatorio do verify. O relatorio fica com o preparo e o grupo.
     const executorDasClaims = relatorio
-        ? executorSobConducao(executorDaRodada(manifesto, instabilidade, opcoes.executor, leitor, ambienteDoModo(check)), manifesto, conducao)
+        ? executorSobConducao(observar(executorDaRodada(manifesto, instabilidade, opcoes.executor, leitor, ambienteFuncional)), manifesto, conducao)
+        : executor;
+    // Uma claim `node --test` elegivel usa o mesmo ambiente funcional das lanes: casa compartilhada, sem o modo da
+    // orquestracao. Assim o fallback da claim e a prova reaproveitada observam exatamente a mesma bateria.
+    const ambienteFuncionalDasLanes = { ...(casaDaRodada ? { ORKASTERY_HOME: casaDaRodada } : {}) };
+    const executorDasClaimsComoLane = relatorio
+        ? executorSobConducao(observar(executorDaRodada(manifesto, instabilidade, opcoes.executor, leitor, ambienteFuncionalDasLanes)), manifesto, conducao)
         : executor;
     // RM-072 (S-b do CHECK 2): fora do preparo, so a varredura e as lanes recebem o relatorio.
     const executorDosComandos = relatorio ? soAVarreduraEAsLanesComRelatorio(executor, executorDasClaims) : executor;
@@ -713,15 +781,34 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
         pecas.push(...(0, check_agil_1.refazerPreparo)(manifesto, cwd, executor, vigente, (p) => guardaDoPreparo(manifesto, cwd, p), quando));
     };
     let preparosRefeitos = 0;
+    let lanesVigentes = true;
     const refazerAntesDaClaim = (nome) => {
         if (!vigente || preparosRefeitos >= check_agil_1.MAXIMO_DE_PREPAROS_REFEITOS)
             return false;
         preparosRefeitos++;
+        lanesVigentes = false;
         refazer(`antes da claim ${nome}`);
         return true;
     };
+    // RM-074 M1: no Agile, as lanes rodam antes das claims para seus resultados nominais poderem provar `node --test`.
+    // Classic conserva a ordem anterior. O build continua vindo do preparo desta mesma rodada.
+    let doAgile = null;
+    const grupoAntesDasClaims = !opcoes.soClaims && !!vigente && vigente.guarda.conferir() === null
+        && Object.keys(manifesto.check?.agile?.test ?? {}).length > 0;
+    let comandosDoManifestoExecutados = grupoAntesDasClaims
+        ? (opcoes.progresso?.('grupo-agile'), doAgile = (0, check_agil_1.comandosNoAgile)(manifesto, cwd, comandosDoManifesto(manifesto), executorDosComandos, executorDoGrupo(manifesto, ambienteDaRodada, instabilidade, leitor, conducao, opcoes.executor ? executor : undefined, opcoes.medicaoCpuAgendador), vigente.guarda, vigente.preparo)).comandos
+        : [];
+    if (doAgile)
+        pecas.push(...doAgile.pecas);
+    const evidenciasDasLanes = relatorio && doAgile ? (0, check_agil_1.resultadosDasLanes)(relatorio.ler()) : [];
+    const ambienteEfetivoDasClaims = { ...ambienteDoVerify(), ...ambienteFuncionalDasLanes };
+    const executorComLanes = evidenciasDasLanes.length > 0
+        ? (0, check_agil_1.executorDaClaimPelasLanes)(executorDasClaims, evidenciasDasLanes, { head: commit, ambiente: ambienteEfetivoDasClaims,
+            podeReaproveitar: () => lanesVigentes && vigente?.guarda.conferir() === null,
+            executorEquivalente: executorDasClaimsComoLane })
+        : executorDasClaims;
     // Claim retirada sai do gate: o historico guarda a alegacao e o motivo da retirada.
-    const executorDaClaim = vigente ? (0, check_agil_1.executorDaClaimNoAgile)(manifesto, executorDasClaims, vigente, refazerAntesDaClaim) : executorDasClaims;
+    const executorDaClaim = vigente ? (0, check_agil_1.executorDaClaimNoAgile)(manifesto, executorComLanes, vigente, refazerAntesDaClaim) : executorComLanes;
     const claims = (0, claims_1.lerClaims)(raiz, threadId)
         .filter((c) => c.estado !== 'retirada')
         .map((c) => verificarClaim(c, cwd, executorDaClaim));
@@ -737,20 +824,33 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
         if (r.claim.estado !== estado)
             (0, claims_1.carimbarEstado)(raiz, r.claim, estado);
     }
-    // RM-072 (A1 do CHECK): o produto que mudou durante as claims tem o preparo refeito antes do grupo, que segue em paralelo.
-    // S-h do CHECK 3: o grupo tem a vaga dele, fora do teto das claims.
-    if (vigente && !opcoes.soClaims && vigente.guarda.conferir() === 'produto-mudou')
-        refazer('antes do grupo');
-    // RM-072 (D4, D6): no Agile, build do preparo e o resto no grupo paralelo, com a guarda valendo.
-    let doAgile = null;
-    const comandos = opcoes.soClaims
-        ? []
-        : vigente
-            ? (doAgile = (0, check_agil_1.comandosNoAgile)(manifesto, cwd, comandosDoManifesto(manifesto), executorDosComandos, executorDoGrupo(manifesto, ambienteDaRodada, instabilidade, leitor, conducao, opcoes.executor ? executor : undefined, opcoes.medicaoCpuAgendador), vigente.guarda, vigente.preparo)).comandos
-            : comandosDoManifesto(manifesto).map((c) => executor(c.nome, c.comando, cwd));
-    if (doAgile)
+    // Claim nao reaproveitada pode recompilar e mudar o produto depois das lanes. Nesse caso o preparo e o grupo rodam
+    // novamente sobre o produto final; na rodada comum, as claims de teste vieram das lanes e este caminho nao custa nada.
+    const guardaDepoisDasClaims = grupoAntesDasClaims ? vigente?.guarda.conferir() : null;
+    if (grupoAntesDasClaims && guardaDepoisDasClaims) {
+        if (guardaDepoisDasClaims === 'produto-mudou')
+            refazer('depois das claims');
+        opcoes.progresso?.('grupo-agile');
+        doAgile = (0, check_agil_1.comandosNoAgile)(manifesto, cwd, comandosDoManifesto(manifesto), executorDosComandos, executorDoGrupo(manifesto, ambienteDaRodada, instabilidade, leitor, conducao, opcoes.executor ? executor : undefined, opcoes.medicaoCpuAgendador), vigente.guarda, vigente.preparo);
+        comandosDoManifestoExecutados = doAgile.comandos;
         pecas.push(...doAgile.pecas);
+    }
+    if (!opcoes.soClaims && !grupoAntesDasClaims) {
+        comandosDoManifestoExecutados = vigente
+            ? (opcoes.progresso?.('grupo-agile'), doAgile = (0, check_agil_1.comandosNoAgile)(manifesto, cwd, comandosDoManifesto(manifesto), executorDosComandos, executorDoGrupo(manifesto, ambienteDaRodada, instabilidade, leitor, conducao, opcoes.executor ? executor : undefined, opcoes.medicaoCpuAgendador), vigente.guarda, vigente.preparo)).comandos
+            : comandosDoManifesto(manifesto).map((c) => executorDosComandos(c.nome, c.comando, cwd));
+        if (doAgile)
+            pecas.push(...doAgile.pecas);
+    }
+    const changelog = opcoes.soClaims ? null
+        : verificarChangelog(cwd, manifesto.worktree.base_branch, thread.base?.commit);
+    const comandos = opcoes.soClaims ? []
+        : changelog ? [...comandosDoManifestoExecutados, changelog] : comandosDoManifestoExecutados;
     const resumoDoAgile = vigente ? agileNoLedger(raiz, threadId, commit, pecas, doAgile, vigente.guarda, relatorio, claims) : null;
+    if (relatorio && !vigente)
+        relatorio.fechar();
+    if (casaDaRodada)
+        fs.rmSync(casaDaRodada, { recursive: true, force: true });
     // RM-062 (F2): a barreira de dado privado no diff da thread, so com a policy `dado_privado` no manifesto.
     const dadoPrivado = (0, dado_privado_1.barreiraDaThread)(carregado, thread, cwd, 'verify');
     const dadoPrivadoBloqueia = (0, policies_1.bloqueantes)(dadoPrivado?.violacoes ?? []);
@@ -758,23 +858,41 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
     const regressoes = [];
     const preExistentes = [];
     const falhasSemBaseline = [];
+    const comparacoes = [];
     const estouros = [];
     // RM-037 (defeito 1 de 19 e 20/10/2026): o comando sem veredito na baseline nao separa regressao de divida.
     const baselineSemVeredito = (baseline?.comandos ?? []).filter((c) => vereditoDaBaseline(c) === 'sem-veredito').map((c) => c.nome);
     for (const atual of comandos) {
-        if (atual.ok)
+        // I-54 (D11): comando que nao rodou nao tem resultado para comparar. O motivo tipado entra abaixo como
+        // `verify.sem-veredito`, sem tambem inventar regressao ou divida a partir da ausencia de nomes.
+        if (atual.executado === false)
             continue;
-        if (semVereditoPorTempo(atual)) {
+        if (!atual.ok && semVereditoPorTempo(atual)) {
             estouros.push(atual);
             continue;
         }
         const antes = baseline?.comandos.find((c) => c.nome === atual.nome);
-        if (!antes || vereditoDaBaseline(antes) === 'sem-veredito')
-            falhasSemBaseline.push(atual);
-        else if (antes.ok)
+        if (!antes || vereditoDaBaseline(antes) === 'sem-veredito') {
+            if (!atual.ok)
+                falhasSemBaseline.push(atual);
+            continue;
+        }
+        const comparacao = compararComBaseline(atual, antes);
+        if (!comparacao)
+            continue;
+        comparacoes.push(comparacao);
+        if (comparacao.granularidade === 'teste') {
+            if (comparacao.regressoes.length > 0)
+                regressoes.push(atual);
+            if (comparacao.preExistentes.length > 0)
+                preExistentes.push(atual);
+        }
+        else if (comparacao.classificacaoDoComando === 'regressao') {
             regressoes.push(atual);
-        else
+        }
+        else if (comparacao.classificacaoDoComando === 'pre-existente') {
             preExistentes.push(atual);
+        }
     }
     // I-54 (D11): o produto mudou entre o preparo e o fim da rodada? Entao nenhum veredito vale.
     const identidadeFinal = preparo ? identidadeDoProduto(cwd) : null;
@@ -823,6 +941,7 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
                 duracaoMs: c.execucoes.reduce((t, e) => t + (e.duracaoMs ?? 0), 0),
                 // RM-072 (D5): no Agile, o que a guarda fez com cada comando da claim.
                 ...(c.execucoes.some((e) => e.preparo) ? { preparo: c.execucoes.map((e) => e.preparo ?? null) } : {}),
+                ...(c.execucoes.some((e) => e.lane) ? { lane: c.execucoes.map((e) => e.lane ?? null) } : {}),
                 ...(falhou ? { execucao: comandoNoLedger(falhou) } : {}),
             };
         }),
@@ -831,6 +950,7 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
         regressoes: regressoes.map((r) => r.nome),
         preExistentes: preExistentes.map((r) => r.nome),
         falhasSemBaseline: falhasSemBaseline.map((r) => r.nome),
+        comparacoes,
         ...(baselineSemVeredito.length > 0 ? { baselineSemVeredito } : {}),
         estouros: estouros.map((r) => r.nome),
         prazoMs: manifesto.verify.timeout_ms ?? exports.TIMEOUT_VERIFY_MS,
@@ -871,7 +991,9 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
                     .map((c) => `${c.claim.id}: ${c.detalhe}`)
                     .join('; ')
                 : motivo === 'verify.regression'
-                    ? `regressao em: ${regressoes.map((r) => r.nome).join(', ')}`
+                    ? `regressao em: ${comparacoes.flatMap((c) => c.granularidade === 'teste'
+                        ? c.regressoes.map((teste) => `${c.comando}: ${teste}`)
+                        : c.classificacaoDoComando === 'regressao' ? [c.comando] : []).join(', ')}`
                     : motivo === 'verify.timeout'
                         ? `sem veredito por tempo (prazo estourado, ou teste com relogio sob steal acima de ${steal_1.LIMIAR_STEAL_PCT}%): ${[
                             ...estouros.map((r) => (0, check_agil_1.porQueDasLanes)(r) ? `${r.nome} (${(0, check_agil_1.porQueDasLanes)(r)})` : r.nome),
@@ -914,6 +1036,7 @@ function verificarSobConducao(carregado, threadId, opcoes, conducao, canal, fila
         regressoes,
         preExistentes,
         falhasSemBaseline,
+        comparacoes,
         estouros,
         preparo: preparo ? { ...preparo, identidadeFinal: identidadeFinal, produtoAlterado } : null,
         steal,
@@ -1017,13 +1140,22 @@ function textoDoVerify(r) {
         linhas.push('');
         linhas.push(m.semVeredito(r.estouros.map((c) => c.nome).join(', ')));
     }
-    if (r.regressoes.length > 0 || r.preExistentes.length > 0 || r.falhasSemBaseline.length > 0) {
+    if (r.comparacoes.length > 0 || r.falhasSemBaseline.length > 0) {
         linhas.push('');
-        linhas.push(m.classificacao(r.regressoes.length, r.preExistentes.length, r.falhasSemBaseline.length));
-        for (const c of r.regressoes)
-            linhas.push(m.regressao(c.nome, c.comando));
-        for (const c of r.preExistentes)
-            linhas.push(m.preExistente(c.nome, c.comando));
+        for (const c of r.comparacoes) {
+            if (c.granularidade === 'teste') {
+                linhas.push(m.comparacaoPorTeste(c.comando, c.regressoes.length, c.preExistentes.length, c.corrigidos.length));
+                for (const teste of c.regressoes)
+                    linhas.push(m.testeRegressao(teste));
+                for (const teste of c.preExistentes)
+                    linhas.push(m.testePreExistente(teste));
+                for (const teste of c.corrigidos)
+                    linhas.push(m.testeCorrigido(teste));
+            }
+            else {
+                linhas.push(m.comparacaoPorComando(c.comando, c.classificacaoDoComando, c.motivoDoFallback));
+            }
+        }
         // RM-037 (defeito 1 de 19 e 20/10/2026): a baseline existe, mas nao teve veredito deste comando.
         const semVeredito = new Set((r.baseline?.comandos ?? []).filter((c) => vereditoDaBaseline(c) === 'sem-veredito').map((c) => c.nome));
         for (const c of r.falhasSemBaseline) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orkastery/cli",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "A software factory of AI agents that proves its work: parallel threads, verified results, and short decisions only when they matter.",
   "license": "MIT",
   "homepage": "https://github.com/orkastery/orkastery#readme",