@orkastery/cli 0.6.0 → 0.6.1

package/dist/agendador-cpu.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JANELA_DA_SONDA_MS = exports.LIMIAR_STEAL_DO_AGENDADOR_PCT = exports.RESERVA_DO_GRUPO = exports.ENV_CPUS_DOCKER = exports.ENV_CPUS_DA_LANE = void 0;
+exports.cargaDoProcLoadavg = cargaDoProcLoadavg;
+exports.medirCpuDoGrupo = medirCpuDoGrupo;
+exports.planejarCpuDoGrupo = planejarCpuDoGrupo;
+exports.paredeClassicaSimulada = paredeClassicaSimulada;
+exports.paredeAgileSimulada = paredeAgileSimulada;
+/**
+ * RM-074: o plano de CPU do grupo do Agile Check.
+ *
+ * A lane hermetica deixa duas CPUs para a varredura e para a integracao. Cada conteiner recebe uma cota dessa fatia,
+ * em vez de enxergar a maquina inteira. Antes de lancar os comandos, o auxiliar do verify mede `/proc/loadavg` e uma
+ * janela de `/proc/stat`; sob carga ou steal, as pecas voltam a ordem do Classic e usam uma CPU a menos que a maquina.
+ */
+const node_fs_1 = require("node:fs");
+const steal_1 = require("./steal");
+exports.ENV_CPUS_DA_LANE = 'ORK_CHECK_CPUS_DA_LANE';
+exports.ENV_CPUS_DOCKER = 'ORK_CHECK_CPUS_DOCKER';
+exports.RESERVA_DO_GRUPO = 2;
+exports.LIMIAR_STEAL_DO_AGENDADOR_PCT = 10;
+exports.JANELA_DA_SONDA_MS = 250;
+const cpusValidas = (cpus) => Math.max(1, Math.floor(Number.isFinite(cpus) ? cpus : 1));
+/** A carga de um minuto de `/proc/loadavg`; entrada invalida ou ausencia nao inventam saturacao. */
+function cargaDoProcLoadavg(conteudo) {
+    if (!conteudo)
+        return null;
+    const carga = Number(conteudo.trim().split(/\s+/)[0]);
+    return Number.isFinite(carga) && carga >= 0 ? carga : null;
+}
+function lerProc(arquivo) {
+    try {
+        return (0, node_fs_1.readFileSync)(arquivo, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Mede a maquina dentro do proprio grupo, antes de qualquer comando: a carga nas duas pontas e o steal da janela.
+ * A leitura maior da carga impede uma subida durante a sonda de desaparecer na media de um minuto.
+ */
+async function medirCpuDoGrupo(janelaMs = exports.JANELA_DA_SONDA_MS) {
+    const statInicial = (0, steal_1.amostraDoProcStat)(lerProc('/proc/stat'));
+    const cargaInicial = cargaDoProcLoadavg(lerProc('/proc/loadavg'));
+    await new Promise((resolve) => setTimeout(resolve, janelaMs));
+    const cargaFinal = cargaDoProcLoadavg(lerProc('/proc/loadavg'));
+    const cargas = [cargaInicial, cargaFinal].filter((x) => x !== null);
+    return {
+        carga1: cargas.length ? Math.max(...cargas) : null,
+        stealPct: (0, steal_1.stealDaJanela)(statInicial, (0, steal_1.amostraDoProcStat)(lerProc('/proc/stat'))),
+    };
+}
+/** O plano unico que alimenta concorrencia das lanes, varredura e `docker run --cpus`. */
+function planejarCpuDoGrupo(cpusInformadas, medicao) {
+    const cpus = cpusValidas(cpusInformadas);
+    const classic = Math.max(1, cpus - 1);
+    const motivos = [];
+    if (cpus < 3)
+        motivos.push(`${cpus} CPU(s), sem duas CPUs livres para o grupo paralelo`);
+    if (medicao.carga1 !== null && medicao.carga1 >= classic)
+        motivos.push(`carga ${medicao.carga1} em /proc/loadavg (limiar ${classic})`);
+    if (medicao.stealPct !== null && medicao.stealPct >= exports.LIMIAR_STEAL_DO_AGENDADOR_PCT) {
+        motivos.push(`steal ${medicao.stealPct}% em /proc/stat (limiar ${exports.LIMIAR_STEAL_DO_AGENDADOR_PCT}%)`);
+    }
+    const saturado = motivos.length > 0;
+    const fatia = saturado ? classic : Math.min(exports.RESERVA_DO_GRUPO, cpus - 1);
+    const ferramentas = Math.max(1, Math.floor(fatia));
+    return {
+        cpus,
+        ordem: saturado ? 'classic' : 'paralela',
+        saturado,
+        motivo: motivos.join('; ') || `carga e steal abaixo dos limiares; ${fatia} CPU(s) reservadas ao grupo`,
+        cpusHermetica: saturado ? classic : Math.max(1, cpus - fatia),
+        cpusIntegracao: ferramentas,
+        cpusDaFatia: fatia,
+        ferramentasDaVarredura: ferramentas,
+        cpusPorContainer: Math.max(0.01, Math.floor((fatia / ferramentas) * 100) / 100),
+        medicao,
+    };
+}
+function paredeClassicaSimulada(cpus, trabalho) {
+    const concorrencia = Math.max(1, cpusValidas(cpus) - 1);
+    return (trabalho.hermetica + trabalho.varredura + trabalho.integracao) / concorrencia;
+}
+function paredeAgileSimulada(plano, trabalho) {
+    if (plano.ordem === 'classic') {
+        return trabalho.hermetica / plano.cpusHermetica + trabalho.varredura / plano.cpusDaFatia
+            + trabalho.integracao / plano.cpusIntegracao;
+    }
+    return Math.max(trabalho.hermetica / plano.cpusHermetica, trabalho.varredura / plano.cpusDaFatia + trabalho.integracao / plano.cpusIntegracao);
+}

package/dist/branch-de-estado.js

@@ -192,12 +192,17 @@ function gravarNaBranch(raiz, remoto, branch, ponta, mudancas, mensagem, prefixo
             exigirGit(raiz, ['read-tree', ponta], prefixo, { env });
         else
             exigirGit(raiz, ['read-tree', '--empty'], prefixo, { env });
-        for (const m of mudancas) {
+        for (const [i, m] of mudancas.entries()) {
             if (m.conteudo === null) {
                 exigirGit(raiz, ['update-index', '--force-remove', m.caminho], prefixo, { env });
             }
             else {
-                const blob = exigirGit(raiz, ['hash-object', '-w', '--stdin'], prefixo, { input: m.conteudo }).trim();
+                // `spawnSync` nem sempre fecha o pipe de entrada em runtimes hospedados, deixando o
+                // `hash-object --stdin` preso mesmo depois de receber todos os bytes. Um arquivo privado no
+                // mesmo diretorio temporario conserva o conteudo exato e torna o termino deterministico.
+                const conteudo = path.join(path.dirname(indice), `conteudo-${i}`);
+                fs.writeFileSync(conteudo, m.conteudo, { mode: 0o600 });
+                const blob = exigirGit(raiz, ['hash-object', '-w', conteudo], prefixo).trim();
                 exigirGit(raiz, ['update-index', '--add', '--cacheinfo', `100644,${blob},${m.caminho}`], prefixo, { env });
             }
         }

package/dist/check-agil.js

@@ -43,6 +43,7 @@ exports.prepararNoAgile = prepararNoAgile;
 exports.executorDaClaimNoAgile = executorDaClaimNoAgile;
 exports.refazerPreparo = refazerPreparo;
 exports.testDasLanes = testDasLanes;
+exports.porQueDasLanes = porQueDasLanes;
 exports.comandosNoAgile = comandosNoAgile;
 exports.pecasDoRelatorio = pecasDoRelatorio;
 exports.listasDasLanes = listasDasLanes;
@@ -74,13 +75,11 @@ const fs = __importStar(require("node:fs"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const check_modo_1 = require("./check-modo");
+const agendador_cpu_1 = require("./agendador-cpu");
 const redacao_url_1 = require("./redacao-url");
-/**
- * Quantas ferramentas a varredura roda ao mesmo tempo dentro do grupo, ao lado das lanes: um terco das CPUs que sobram
- * de uma, e no minimo duas. Numa maquina de 7 CPUs, duas.
- */
+/** Quantas ferramentas cabem na fatia de duas CPUs reservada pelo plano paralelo. */
 function paralelismoDaVarreduraNoGrupo(cpus = os.availableParallelism()) {
-    return Math.max(2, Math.floor((cpus - 1) / 3));
+    return (0, agendador_cpu_1.planejarCpuDoGrupo)(cpus, { carga1: 0, stealPct: 0 }).ferramentasDaVarredura;
 }
 const SEPARADOR = ' && ';
 /** Os passos de um comando encadeado por `&&` no nivel do texto (o preparo e escrito assim no manifesto). */
@@ -311,21 +310,25 @@ function caiuDeVerdade(r) {
 /**
  * O `test` das lanes (D4): ok so com todas ok; a evidencia de quem caiu; a parede e a da lane mais longa. A falha de
  * verdade de uma lane manda, como num comando so do Classic: o estouro ou o relogio sob steal de outra lane nao a esconde.
- * O relogio sob steal so vale quando toda lane que caiu caiu so nele, e a pior causa so vale sem falha de verdade. N1 do
- * CHECK 2 e N6 do CHECK 4: com uma lane caida sem veredito (fora o caso em que todas as caidas estouraram ou cairam so
- * no relogio, que o agregado ja diz por tempo), o `test` nao tem veredito inteiro (`executado` falso): no verify ele
- * bloqueia como sem veredito, mesmo com a baseline `ja-falhava`, e na baseline ele e `sem-veredito`, em qualquer ordem das
- * lanes; com falha de verdade junto, a causa, os testes e o trecho continuam os dela. A lane sozinha que sai com 124 antes
- * do prazo de fora fica sem veredito, mais estrita que o comando unico do Classic, que a compara com a baseline.
+ * O relogio sob steal so vale quando toda lane que caiu caiu so nele, e a pior causa so vale sem falha de verdade.
+ *
+ * RM-074 (F4): a lane que nao terminou sozinha fora do tempo (sinal, comando ausente, o codigo de quem nao a deixou
+ * terminar, de 124 em diante antes do prazo de fora) da ao `test` o codigo dela, e o `test` segue com veredito, como o
+ * comando unico do Classic que terminasse assim: no verify ele e comparado com a baseline (regressao, ja falhava ou falha
+ * sem baseline), e na baseline ele e `sem-veredito`, porque o codigo nao e da propria lane, em qualquer ordem das lanes;
+ * com falha de verdade junto, a causa, os testes e o trecho continuam os dela. So a lane que nao rodou (`executado`
+ * falso, como o comando que o Classic nao lancou) deixa o `test` sem veredito inteiro. O caso por tempo segue o de antes
+ * (N1 do CHECK 2 e N6 do CHECK 4): o estouro ou o relogio de uma lane junto de falha de verdade de outra tambem deixa o
+ * `test` sem veredito inteiro, e as caidas so por tempo dao o agregado por tempo.
  */
 function testDasLanes(lanes) {
     const caidas = lanes.filter((l) => !l.resultado.ok);
     const deVerdade = caidas.filter((l) => caiuDeVerdade(l.resultado));
     const semVeredito = caidas.filter((l) => !caiuDeVerdade(l.resultado));
-    // N6 do CHECK 4: so o estouro e o relogio sob steal ja dizem "sem veredito" pelo agregado (a causa ou o relogio dele);
-    // qualquer outra lane sem veredito deixa o `test` sem veredito inteiro, em qualquer ordem das lanes.
-    const soPorTempo = deVerdade.length === 0 && semVeredito.length > 0
-        && semVeredito.every((l) => l.resultado.causa === 'timeout' || (l.resultado.relogioSobSteal?.length ?? 0) > 0);
+    const porTempo = (r) => r.causa === 'timeout' || (r.relogioSobSteal?.length ?? 0) > 0;
+    // RM-074 (F4): a lane sem veredito fora do tempo da o codigo ao `test`, que o verify compara com a baseline.
+    const foraDoTempo = semVeredito.filter((l) => !porTempo(l.resultado));
+    const tempoComFalha = deVerdade.length > 0 && semVeredito.some((l) => porTempo(l.resultado));
     const juntar = (f) => lanes.flatMap((l) => f(l.resultado) ?? []);
     const causas = lanes.map((l) => l.resultado.causa).filter((c) => !!c);
     const causa = deVerdade.length ? deVerdade[0].resultado.causa ?? 'exit' : PIOR_CAUSA.find((c) => causas.includes(c));
@@ -338,12 +341,12 @@ function testDasLanes(lanes) {
         nome: 'test',
         comando: lanes.map((l) => `${l.lane}: ${l.resultado.comando}`).join('; '),
         ok: caidas.length === 0,
-        code: (deVerdade[0] ?? caidas[0])?.resultado.code ?? 0,
+        code: (foraDoTempo[0] ?? deVerdade[0] ?? caidas[0])?.resultado.code ?? 0,
         resumo: (caidas.length ? caidas : lanes).map((l) => `[${l.lane}] ${l.resultado.resumo}`).join('\n').slice(-800),
         ...(causa ? { causa } : {}),
         prazoMs: Math.max(...lanes.map((l) => l.resultado.prazoMs ?? 0)),
         duracaoMs: Math.max(...lanes.map((l) => l.resultado.duracaoMs ?? 0)),
-        executado: semVeredito.length === 0 || soPorTempo ? lanes.every((l) => l.resultado.executado !== false) : false,
+        executado: !tempoComFalha && lanes.every((l) => l.resultado.executado !== false),
         ...(testes.length ? { testeQueCaiu: testes } : {}),
         ...(falhas.length ? { falhasDeTeste: falhas } : {}),
         ...(trechos.length ? { trecho: trechos.join('\n').slice(0, 1024) } : {}),
@@ -353,6 +356,30 @@ function testDasLanes(lanes) {
             ...(l.resultado.causa ? { causa: l.resultado.causa } : {}), duracaoMs: l.resultado.duracaoMs ?? 0 })),
     };
 }
+/**
+ * RM-074 (F4): por que cada lane caida do `test` ficou como ficou, para o texto do gate dizer qual lane ficou sem veredito
+ * e por que. Le so o que o ledger grava da lane (codigo e causa); o relogio sob steal vem do agregado, que so o traz quando
+ * toda lane caida caiu so nele. Vazio fora do Agile (sem lanes) e com todas as lanes ok.
+ */
+function porQueDasLanes(c) {
+    const caidas = (c.lanes ?? []).filter((l) => !l.ok);
+    const porque = (l) => {
+        if (l.causa === 'timeout')
+            return 'estourou o prazo';
+        if (l.causa === 'nao-encontrado')
+            return `comando nao encontrado (codigo ${l.code})`;
+        if (l.code === -1)
+            return 'sem codigo de saida: nao rodou, ou o auxiliar do grupo morreu antes de gravar o resultado';
+        if (l.causa === 'sinal')
+            return `morta por sinal (codigo ${l.code})`;
+        if (c.relogioSobSteal?.length)
+            return `caiu so em teste com relogio sob steal (${c.relogioSobSteal.join(', ')})`;
+        if (Number.isInteger(l.code) && l.code >= 1 && l.code <= MAIOR_CODIGO_DA_LANE)
+            return `caiu com o codigo ${l.code}`;
+        return `saiu com ${l.code}, o codigo de quem nao a deixou terminar`;
+    };
+    return caidas.map((l) => `lane ${l.lane}: ${porque(l)}`).join('; ');
+}
 /**
  * Os comandos do manifesto no Agile (D4): `build` reaproveitado do preparo com a guarda valendo; o resto num grupo
  * paralelo, com as lanes no lugar do `verify.test`, so com a guarda valendo; sem ela, tudo em serie (o Classic).
@@ -391,16 +418,17 @@ function comandosNoAgile(manifesto, cwd, lista, executor, grupo, guarda, preparo
         if (c.nome === 'test' && lanesDeclaradas.length > 0) {
             for (const [lane, comando] of lanesDeclaradas) {
                 if (depoisDaVarredura.has(lane))
-                    encadeados.push({ nome: `test:${lane}`, comando, apos: ['security_scan'] });
+                    encadeados.push({ nome: `test:${lane}`, comando, apos: ['security_scan'], papelCpu: 'integracao' });
                 else
-                    itens.push({ nome: `test:${lane}`, comando });
+                    itens.push({ nome: `test:${lane}`, comando, papelCpu: lane === 'hermetica' ? 'hermetica' : 'outro' });
             }
         }
         else
-            itens.push({ nome: c.nome, comando: c.comando });
+            itens.push({ nome: c.nome, comando: c.comando, papelCpu: c.nome === 'security_scan' ? 'varredura' : 'outro' });
     }
     itens.push(...encadeados);
     const resultados = itens.length > 1 ? grupo(itens, cwd) : itens.map((i) => executor(i.nome, i.comando, cwd));
+    pecas.push(...(grupo.pecas ?? []));
     const lanes = [];
     itens.forEach((item, i) => {
         if (item.nome.startsWith('test:'))

package/dist/check-paralelo.js

@@ -51,13 +51,13 @@ const node_child_process_1 = require("node:child_process");
 const fs = __importStar(require("node:fs"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
+const agendador_cpu_1 = require("./agendador-cpu");
 const TIMEOUT_BIN = '/usr/bin/timeout';
 const NICE_BIN = '/usr/bin/nice';
-/** O argv de um item: `nice` (se pedido e existir), `timeout(1)` (se existir) e `bash -c`. */
+/** O argv de um item: `nice` (se pedido e existir), `timeout(1)` (se existir) e o `argv` do item ou `bash -c`. */
 function argvDoItem(item, comGrupo = fs.existsSync(TIMEOUT_BIN), comNice = fs.existsSync(NICE_BIN)) {
-    const base = comGrupo
-        ? [TIMEOUT_BIN, '--kill-after=15', `${Math.ceil(item.prazoMs / 1000)}`, 'bash', '-c', item.comando]
-        : ['bash', '-c', item.comando];
+    const programa = item.argv?.length ? item.argv : ['bash', '-c', item.comando];
+    const base = comGrupo ? [TIMEOUT_BIN, '--kill-after=15', `${Math.ceil(item.prazoMs / 1000)}`, ...programa] : programa;
     return item.nice && comNice ? [NICE_BIN, '-n', String(item.nice), ...base] : base;
 }
 /** As vagas do grupo: no maximo `max` comandos ao mesmo tempo, na ordem em que pediram. */
@@ -83,12 +83,24 @@ function vagas(max) {
  */
 async function rodarEspecificacao(esp) {
     const comGrupo = fs.existsSync(TIMEOUT_BIN);
-    const limite = vagas(esp.maxParalelo && esp.maxParalelo > 0 ? esp.maxParalelo : esp.itens.length);
+    const usaAgendador = esp.itens.some((i) => i.papelCpu === 'hermetica');
+    const plano = usaAgendador ? (0, agendador_cpu_1.planejarCpuDoGrupo)(esp.cpus ?? os.availableParallelism(), esp.medicaoCpu ?? await (0, agendador_cpu_1.medirCpuDoGrupo)()) : undefined;
+    const itens = plano ? aplicarPlano(esp.itens, plano) : esp.itens;
+    const limite = vagas(esp.maxParalelo && esp.maxParalelo > 0 ? esp.maxParalelo : itens.length);
     const porNome = new Map();
-    const terminados = await Promise.all(esp.itens.map((item, i) => {
-        const vez = (async () => {
-            for (const nome of item.apos ?? [])
-                await porNome.get(nome);
+    const indice = new Map(itens.map((item, i) => [item.nome, i]));
+    const vezDoItem = (item, i) => {
+        const existente = porNome.get(item.nome);
+        if (existente)
+            return existente;
+        // O primeiro `then` deixa a promessa entrar no mapa antes de resolver dependencias; assim `apos` funciona mesmo
+        // quando o plano põe uma dependencia que aparece depois na ordem canonica dos resultados.
+        const vez = Promise.resolve().then(async () => {
+            for (const nome of item.apos ?? []) {
+                const j = indice.get(nome);
+                if (j !== undefined)
+                    await vezDoItem(itens[j], j);
+            }
             await limite.tomar();
             try {
                 return await lancar(item, i);
@@ -96,11 +108,12 @@ async function rodarEspecificacao(esp) {
             finally {
                 limite.soltar();
             }
-        })();
+        });
         porNome.set(item.nome, vez);
         return vez;
-    }));
-    fs.writeFileSync(path.join(esp.dir, 'resultado.json'), JSON.stringify(terminados), { mode: 0o600 });
+    };
+    const terminados = await Promise.all(itens.map(vezDoItem));
+    fs.writeFileSync(path.join(esp.dir, 'resultado.json'), JSON.stringify({ terminados, ...(plano ? { agendamentoCpu: plano } : {}) }), { mode: 0o600 });
     function lancar(item, i) {
         return new Promise((resolve) => {
             const saida = fs.openSync(path.join(esp.dir, `${i}.out`), 'w', 0o600);
@@ -127,12 +140,50 @@ async function rodarEspecificacao(esp) {
         });
     }
 }
+/** Aplica a mesma conta aos processos, as lanes e aos conteineres que eles criarem. */
+function aplicarPlano(originais, plano) {
+    const itens = originais.map((item) => ({ ...item, ambiente: { ...item.ambiente } }));
+    const porPapel = (papel) => itens.filter((i) => i.papelCpu === papel);
+    const hermetica = porPapel('hermetica')[0];
+    const varredura = porPapel('varredura')[0];
+    const integracoes = porPapel('integracao');
+    const outros = porPapel('outro');
+    const depender = (item, nomes) => {
+        if (!item)
+            return;
+        item.apos = [...new Set([...(item.apos ?? []), ...nomes.filter((n) => !!n && n !== item.nome)])];
+    };
+    const ambiente = (item, valores) => {
+        if (item)
+            item.ambiente = { ...item.ambiente, ...valores };
+    };
+    const cpusContainer = String(plano.cpusPorContainer);
+    ambiente(hermetica, { [agendador_cpu_1.ENV_CPUS_DA_LANE]: String(plano.cpusHermetica), [agendador_cpu_1.ENV_CPUS_DOCKER]: cpusContainer });
+    ambiente(varredura, {
+        ORK_CHECK_VARREDURA_PARALELA: String(plano.ferramentasDaVarredura),
+        [agendador_cpu_1.ENV_CPUS_DOCKER]: cpusContainer,
+    });
+    let anterior = varredura?.nome;
+    for (const item of integracoes) {
+        ambiente(item, { [agendador_cpu_1.ENV_CPUS_DA_LANE]: String(plano.cpusIntegracao), [agendador_cpu_1.ENV_CPUS_DOCKER]: cpusContainer });
+        depender(item, [anterior]);
+        anterior = item.nome;
+    }
+    if (plano.saturado)
+        depender(varredura, [hermetica?.nome]);
+    // Comandos sem papel conhecido nao disputam CPU com as tres pecas: fecham a cadeia, um por vez.
+    for (const item of outros) {
+        depender(item, [hermetica?.nome, anterior]);
+        anterior = item.nome;
+    }
+    return itens;
+}
 /**
  * A espera do grupo inteiro: o maior prazo, ou a soma deles quando ha fila (item com `apos` ou vagas a menos que itens),
  * que e o teto do pior caso.
  */
 function esperaDoGrupo(itens, maxParalelo) {
-    const comFila = itens.some((i) => i.apos?.length) || (!!maxParalelo && maxParalelo < itens.length);
+    const comFila = itens.some((i) => i.apos?.length || i.papelCpu) || (!!maxParalelo && maxParalelo < itens.length);
     return comFila ? itens.reduce((t, i) => t + i.prazoMs, 0) : Math.max(...itens.map((i) => i.prazoMs));
 }
 /**
@@ -145,18 +196,19 @@ function rodarEmParalelo(itens, ambiente = process.env, opcoes = {}) {
     const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ork-check-paralelo-'));
     try {
         const especificacao = path.join(dir, 'especificacao.json');
-        const esp = { itens, dir, ...(opcoes.maxParalelo ? { maxParalelo: opcoes.maxParalelo } : {}) };
+        const esp = { itens, dir, ...(opcoes.maxParalelo ? { maxParalelo: opcoes.maxParalelo } : {}),
+            ...(opcoes.cpus ? { cpus: opcoes.cpus } : {}), ...(opcoes.medicaoCpu ? { medicaoCpu: opcoes.medicaoCpu } : {}) };
         fs.writeFileSync(especificacao, JSON.stringify(esp), { mode: 0o600 });
         const prazo = esperaDoGrupo(itens, opcoes.maxParalelo) + 60_000;
         const r = (0, node_child_process_1.spawnSync)(process.execPath, [__filename, especificacao], { env: ambiente, encoding: 'utf8', timeout: prazo,
             killSignal: 'SIGKILL' });
-        let terminados = [];
+        let lido = { terminados: [] };
         try {
-            terminados = JSON.parse(fs.readFileSync(path.join(dir, 'resultado.json'), 'utf8'));
+            lido = JSON.parse(fs.readFileSync(path.join(dir, 'resultado.json'), 'utf8'));
         }
         catch { /* abaixo */ }
-        return itens.map((item, i) => {
-            const t = terminados[i];
+        const processos = itens.map((item, i) => {
+            const t = lido.terminados[i];
             const ler = (sufixo) => { try {
                 return fs.readFileSync(path.join(dir, `${i}.${sufixo}`), 'utf8');
             }
@@ -172,6 +224,9 @@ function rodarEmParalelo(itens, ambiente = process.env, opcoes = {}) {
             return { nome: item.nome, ok: t.code === 0, code: t.code ?? -1, signal: t.signal, ...(t.error ? { error: t.error } : {}),
                 stdout: ler('out'), stderr: ler('err'), duracaoMs: t.duracaoMs, comGrupo: t.comGrupo };
         });
+        if (lido.agendamentoCpu)
+            processos.agendamentoCpu = lido.agendamentoCpu;
+        return processos;
     }
     finally {
         fs.rmSync(dir, { recursive: true, force: true });

package/dist/conducao.js

@@ -113,6 +113,11 @@ exports.CANAIS_DE_CONDUCAO = {
         origem: 'sessao do Codex',
         declaracao: 'servidor MCP iniciado com --host codex',
     },
+    // RM-067 (F4b, G5): o servidor do grok so serve a sessao filha; o canal e o do host dele, como no codex.
+    grok: {
+        origem: 'sessao filha do Grok Build',
+        declaracao: 'servidor MCP iniciado com --host grok, so na sessao filha vinculada a thread',
+    },
     mcp: {
         origem: 'cliente MCP sem host homologado',
         declaracao: 'reservado: o servidor MCP atual exige host homologado e declara o canal dele',

package/dist/docs.js

@@ -81,6 +81,7 @@ const thread_1 = require("./thread");
 const ledger_1 = require("./ledger");
 const branch_de_estado_1 = require("./branch-de-estado");
 const locale_1 = require("./locale");
+const merge_da_entrega_1 = require("./merge-da-entrega");
 exports.DIR_PRODUTO = 'docs/produto';
 exports.DIR_ROADMAP = 'docs/roadmap';
 exports.DIR_PADROES = 'docs/padroes';
@@ -279,7 +280,7 @@ function verificarDocs(raiz, opcoes = {}) {
             verificarTabelasDeEstado(d, achados);
         }
     }
-    verificarIndices(raiz, docs, achados, opcoes.pr === true);
+    verificarIndices(raiz, docs, achados);
     return { docs, achados };
 }
 function verificarChaves(d, achados) {
@@ -653,7 +654,7 @@ const INDICES_GERADOS = [
  * do mesmo jeito: sem a RM-051 e com a RM-031 de antes. Divergente reprova; vazio (o modelo recem-copiado
  * pelo `ork docs init`) so avisa; sem os marcadores, nao ha indice gerado para conferir.
  */
-function verificarIndices(raiz, docs, achados, pr = false) {
+function verificarIndices(raiz, docs, achados) {
     for (const [arquivo, gerar] of INDICES_GERADOS) {
         const abs = path.join(raiz, arquivo);
         if (!fs.existsSync(abs))
@@ -668,7 +669,7 @@ function verificarIndices(raiz, docs, achados, pr = false) {
             }
         }
         else if (atual !== gerar(docs)) {
-            achados.push((pr ? aviso : erro)(arquivo, undefined, 'docs.paridade.indice', (m) => m.indiceDiverge(pr), (m) => m.indiceDivergeCorrecao));
+            achados.push(erro(arquivo, undefined, 'docs.paridade.indice', (m) => m.indiceDiverge(false), (m) => m.indiceDivergeCorrecao));
         }
     }
 }
@@ -779,22 +780,14 @@ function mergeDaThread(raiz, thread, base) {
     return null;
 }
 /**
- * Os commits `ship(<thread>)` da base, do mais velho ao mais novo, so pelo git (o CI nao tem ledger).
+ * Os merges da entrega na base, do mais velho ao mais novo, so pelo git (o CI pode nao ter ledger).
  * RM-037 (fatia 3): um lugar so para o `sincronizarDocs` e o `verificarDocs` acharem o mesmo merge.
  */
 function mergesDaThreadNoGit(raiz, thread, base) {
-    // Sem `-n 1`: o git corta antes de inverter, e `--reverse -n 1` devolveria o mais recente.
-    // GO-FIX 2 (achado 4 do CHECK): so a linha de primeiro pai da base e o assunto que COMECA com
-    // `ship(<thread>)`, como no `mergeDaEntrega`. Commit que cita o merge no corpo, ou o Revert dele, nao e merge.
-    // RM-047 (fronteira de confiança): a base pode ser o `worktree.base_branch` cru do clone.
-    if (!(0, branch_de_estado_1.branchValida)(base))
-        return [];
-    const log = git(raiz, ['log', base, '--first-parent', '--reverse', '--format=%H%x09%s', '--fixed-strings', `--grep=ship(${thread})`]);
-    if (!log.ok)
-        return [];
-    return log.saida.split('\n').map((l) => l.split('\t'))
-        .filter(([sha, assunto]) => !!sha && typeof assunto === 'string' && assunto.startsWith(`ship(${thread})`))
-        .map(([sha]) => sha);
+    // O ref resolvido pode ser local, remoto abreviado ou remoto completo; a mensagem padrao do GitLab leva so a base.
+    const destino = base.replace(/^refs\/heads\//, '').replace(/^refs\/remotes\/[^/]+\//, '').replace(/^origin\//, '');
+    const branch = (0, merge_da_entrega_1.branchRegistradaDaEntrega)(raiz, thread);
+    return ((0, merge_da_entrega_1.mergesDasEntregasNaBase)(raiz, base, destino, [{ thread, branch }], true).get(thread) ?? []).map((m) => m.mergeSha);
 }
 function temBranch(raiz, thread) {
     const r = git(raiz, ['for-each-ref', '--format=%(refname:short)', `refs/heads/ork/${thread}-*`, `refs/remotes/origin/ork/${thread}-*`]);

package/dist/doctor-forja.js

@@ -263,7 +263,7 @@ const PROJETO_DO_GITLAB = zod_1.z.object({
 const REPOSITORIO_DO_GITHUB = zod_1.z.object({
     allow_merge_commit: zod_1.z.boolean().optional(), allow_squash_merge: zod_1.z.boolean().optional(), allow_rebase_merge: zod_1.z.boolean().optional(),
 });
-/** O metodo de merge e o resto do que decide se o merge `ship(<thread>)` chega a base. So avisa; o projeto nao lido reprova. */
+/** O metodo de merge e o que decide se a entrega chega a base com segundo pai. So avisa; o projeto nao lido reprova. */
 function projetoDaForja(f, api, linha) {
     const m = (0, locale_1.msg)().forja.doctor;
     const caminho = f.tipo === 'gitlab' ? (0, pedidos_1.projetoNaApi)(f.repo) : `repos/${f.repo}`;
@@ -282,8 +282,6 @@ function projetoDaForja(f, api, linha) {
         const avisos = [];
         if (p.merge_method === 'ff')
             avisos.push(m.avisoFf);
-        else if (!(p.merge_commit_template ?? '').trimStart().startsWith('%{title}'))
-            avisos.push(m.avisoMensagemPadrao);
         if (p.squash_option === 'always' || p.squash_option === 'default_on')
             avisos.push(m.avisoSquash(p.squash_option));
         const detalhe = [m.projetoGitlab(p.merge_method, p.squash_option ?? '?', estado(p.merge_pipelines_enabled), estado(p.merge_trains_enabled)),

package/dist/doctor.js

@@ -105,7 +105,7 @@ function checarSeparacaoDaConducao(raiz, inventario, env = process.env) {
     try {
         if (dirAtual) {
             const p = (0, runtime_profiles_1.lerPerfisComContas)(raiz).perfis.find((x) => x.runtime === runtime &&
-                real(((0, runtime_profiles_1.perfilDeDespacho)(x).configDir ?? (0, runtime_profiles_1.perfilDeDespacho)(x).codexHome)) === real(dirAtual));
+                real((0, runtime_profiles_1.diretorioDoPerfil)((0, runtime_profiles_1.perfilDeDespacho)(x))) === real(dirAtual));
             perfil = p?.id ?? null;
         }
     }

package/dist/entrega-pr.js

@@ -37,19 +37,19 @@ const util_1 = require("./util");
 const executor_1 = require("./forja/executor");
 const registro_1 = require("./forja/registro");
 const locale_1 = require("./locale");
-/** O merge `ship(<thread>)` mais recente na base remota, com o head do PR (segundo pai). */
+const merge_da_entrega_1 = require("./merge-da-entrega");
+const worktree_1 = require("./worktree");
+/** O merge da entrega mais recente na base remota, com o head do PR (segundo pai). */
 function mergeDaEntrega(raiz, thread, remoto, base) {
-    const r = (0, util_1.exec)('git', ['log', `refs/remotes/${remoto}/${base}`, '--first-parent', '--format=%H%x09%P%x09%s', `--grep=^ship(${thread})`], raiz);
-    if (!r.ok)
+    let branch;
+    try {
+        branch = (0, merge_da_entrega_1.branchRegistradaDaEntrega)(raiz, thread) ?? (0, worktree_1.branchDaWorktree)((0, thread_1.lerThread)(raiz, thread));
+    }
+    catch {
         return null;
-    for (const linha of r.stdout.split('\n')) {
-        const [sha, pais, assunto] = linha.split('\t');
-        if (!sha || !assunto || !assunto.startsWith(`ship(${thread})`))
-            continue;
-        const segundo = (pais ?? '').split(' ')[1] ?? null;
-        return { mergeSha: sha, headSha: segundo };
     }
-    return null;
+    const merge = (0, merge_da_entrega_1.mergesDasEntregasNaBase)(raiz, `refs/remotes/${remoto}/${base}`, base, [{ thread, branch }]).get(thread)?.[0];
+    return merge ? { mergeSha: merge.mergeSha, headSha: merge.headSha } : null;
 }
 /**
  * A thread chega ao SHIP quando o ciclo dela tem SHIP, e so AVANCA: o segundo PR da mesma entrega (os

package/dist/fabrica-estado.js

@@ -85,6 +85,8 @@ const versao_1 = require("./versao");
 const saida_segura_1 = require("./saida-segura");
 const vida_da_thread_1 = require("./vida-da-thread");
 const locale_1 = require("./locale");
+const merge_da_entrega_1 = require("./merge-da-entrega");
+const worktree_1 = require("./worktree");
 exports.CONTRATO_MAQUINA = 'ork.fabrica-maquina/v1';
 exports.BRANCH_DA_FABRICA = 'ork/fabrica-estado';
 /** O diretorio dos retratos na branch; a leitura sem clone (RM-054) le o mesmo. */
@@ -133,8 +135,8 @@ function arquivoDaMaquina(maquina) {
     return `${nome}.json`;
 }
 /**
- * As entregas que ja estao na base: `ship(<thread>): ...` e o assunto do merge que o fluxo de
- * entrega usa, o mesmo fato que o `ork docs sincronizar` le. Um `git log` so, para todas.
+ * As entregas que ja estao na base, pelo mesmo reconhecedor do registro do PR e da paridade de docs.
+ * Um `git log` so, para todas as threads deste checkout.
  */
 function entregasNaBase(raiz, base, remoto = 'origin') {
     // A base vem do manifesto: a ref vai sempre qualificada (`refs/...`), e um valor como
@@ -142,16 +144,23 @@ function entregasNaBase(raiz, base, remoto = 'origin') {
     // Na ordem: a copia remota da base, a branch local, e a base escrita como remota (`origin/main`).
     const candidatas = [`refs/remotes/${remoto}/${base}`, `refs/heads/${base}`, `refs/remotes/${base}`];
     const ref = candidatas.find((c) => (0, branch_de_estado_1.git)(raiz, ['rev-parse', '--verify', '--quiet', c]).ok) ?? candidatas[1];
-    // Regex basica do git: o `(` e literal.
-    const r = (0, branch_de_estado_1.git)(raiz, ['log', ref, '--format=%h%x09%s', '--grep=^ship(']);
     const entregas = new Map();
-    if (!r.ok)
-        return entregas;
-    for (const linha of r.stdout.split('\n')) {
-        const m = /^([0-9a-f]+)\tship\(([A-Za-z0-9._-]+)\)/.exec(linha);
-        // O log vem do mais novo para o mais velho: a primeira entrega de cada thread e a que vale.
-        if (m && !entregas.has(m[2]))
-            entregas.set(m[2], m[1]);
+    const threads = [];
+    for (const id of (0, thread_1.listarIds)(raiz)) {
+        try {
+            threads.push((0, thread_1.lerThread)(raiz, id));
+        }
+        catch { /* thread ilegivel fica de fora */ }
+    }
+    const destino = base.startsWith(`${remoto}/`) ? base.slice(remoto.length + 1) : base;
+    const reconhecidas = (0, merge_da_entrega_1.mergesDasEntregasNaBase)(raiz, ref, destino, threads.map((t) => ({
+        thread: t.id,
+        branch: (0, merge_da_entrega_1.branchRegistradaDaEntrega)(raiz, t.id) ?? (0, worktree_1.branchDaWorktree)(t),
+    })));
+    for (const [thread, merges] of reconhecidas) {
+        const merge = merges[0];
+        if (merge)
+            entregas.set(thread, merge.mergeSha.slice(0, 7));
     }
     return entregas;
 }

package/dist/horario.js

@@ -215,8 +215,11 @@ function duracaoRelativa(minutos) {
 }
 function sigla(fuso, ms, locale = (0, locale_1.localeAtivo)()) {
     try {
-        return new Intl.DateTimeFormat(locale === 'en' ? 'en-US' : 'pt-BR', { timeZone: fuso, timeZoneName: 'short' })
+        const valor = new Intl.DateTimeFormat(locale === 'en' ? 'en-US' : 'pt-BR', { timeZone: fuso, timeZoneName: 'short' })
             .formatToParts(new Date(ms)).find(p => p.type === 'timeZoneName')?.value ?? '';
+        // RM-074 (F4): o deslocamento zero sai `GMT+0` no Node 20.20.2 e no 22.23.2; um ICU antigo escreve so `GMT`. O texto
+        // fica o mesmo em qualquer ICU.
+        return valor === 'GMT' ? 'GMT+0' : valor;
     }
     catch {
         return '';