@orkastery/cli 0.6.0 → 0.6.2

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,8 @@ 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");
+const changelog_check_1 = require("./changelog-check");
 exports.DIR_PRODUTO = 'docs/produto';
 exports.DIR_ROADMAP = 'docs/roadmap';
 exports.DIR_PADROES = 'docs/padroes';
@@ -264,6 +266,12 @@ function verificarDocs(raiz, opcoes = {}) {
     if (!opcoes.semGit && !base) {
         achados.push(aviso('.', undefined, 'docs.git.base', (m) => m.baseAusente(opcoes.baseBranch ?? 'main'), (m) => m.baseAusenteCorrecao));
     }
+    if (opcoes.pr && base) {
+        const changelog = (0, changelog_check_1.checarChangelog)(raiz, { base, head: 'HEAD', baseCarimbada: opcoes.baseCarimbada });
+        if (!changelog.ok) {
+            achados.push(erro(changelog_check_1.CHANGELOG, undefined, changelog.motivo ?? 'changelog.invalido', () => changelog.detalhe, () => changelog.correcao ?? 'corrija o CHANGELOG e repita a verificação'));
+        }
+    }
     const comandos = opcoes.ajudaDoCli ? comandosDaAjuda(opcoes.ajudaDoCli) : null;
     for (const d of docs) {
         if (!TIPOS.includes(d.tipo))
@@ -279,7 +287,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 +661,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 +676,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 +787,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/fila-pesada.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErroDaFilaPesada = exports.ENV_DONO_DA_FILA = exports.CONTRATO_FILA_PESADA = void 0;
+exports.avaliarVidaDoOcupante = avaliarVidaDoOcupante;
 exports.kernelDisponivel = kernelDisponivel;
 exports.tentarTravaExclusiva = tentarTravaExclusiva;
 exports.dirDaFilaPesada = dirDaFilaPesada;
@@ -66,6 +67,7 @@ const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const node_crypto_1 = require("node:crypto");
 const node_child_process_1 = require("node:child_process");
+const node_worker_threads_1 = require("node:worker_threads");
 const estado_thread_1 = require("./estado-thread");
 const horario_1 = require("./horario");
 exports.CONTRATO_FILA_PESADA = 'ork.fila-pesada/v1';
@@ -75,11 +77,27 @@ const FLOCK = '/usr/bin/flock';
 const DIR = 'fila-pesada';
 /** Entre uma tentativa e outra. A vez costuma durar minutos; meio segundo não pesa em ninguém. */
 const PAUSA_MS = 500;
+/** A batida e complementar ao flock: atravessa a observacao de um sandbox com outro namespace de PID. */
+const BATIDA_CADA_MS = 1_000;
+const BATIDA_VALE_MS = 5_000;
+function avaliarVidaDoOcupante(e) {
+    if (e.trava === 'ocupada')
+        return { vida: 'vivo', prova: 'trava-kernel' };
+    if (e.trava === 'livre')
+        return { vida: 'morto', prova: 'trava-livre' };
+    if (e.batidaValida)
+        return { vida: 'vivo', prova: 'batida' };
+    if (e.mesmoHost && e.mesmoEspacoPids && e.processo === 'vivo')
+        return { vida: 'vivo', prova: 'processo' };
+    if (e.mesmoHost && e.mesmoEspacoPids && e.processo === 'ausente')
+        return { vida: 'morto', prova: 'processo-ausente' };
+    return { vida: 'desconhecido', prova: 'indeterminada' };
+}
 /** A recusa é resposta, não falha: o CLI a imprime como a da condução, e sai com 3. */
 class ErroDaFilaPesada extends Error {
     recusa;
     constructor(recusa) {
-        super(`fila-pesada.ocupada: ${recusa.texto}`);
+        super(`${recusa.motivo}: ${recusa.texto}`);
         this.name = 'ErroDaFilaPesada';
         this.recusa = recusa;
     }
@@ -88,11 +106,17 @@ exports.ErroDaFilaPesada = ErroDaFilaPesada;
 function kernelDisponivel() {
     return process.platform === 'linux' && fs.existsSync(FLOCK);
 }
-/** O `flock` exclusivo sem espera sobre um descritor já aberto. O helper tranca a descrição de arquivo, que fica do processo. */
-function trancar(fd) {
+/** Diferencia a contencao provada do erro de observacao; erro nunca vira trava livre. */
+function observarTrava(fd) {
     const r = (0, node_child_process_1.spawnSync)(FLOCK, ['--exclusive', '--nonblock', '3'], { stdio: ['ignore', 'ignore', 'ignore', fd], timeout: 5000 });
-    return r.status === 0 && !r.error;
+    if (!r.error && r.status === 0)
+        return 'adquirida';
+    if (!r.error && r.status === 1)
+        return 'ocupada';
+    return 'desconhecida';
 }
+/** Tomar a trava exige prova positiva. Contencao e observacao inconclusiva falham fechadas. */
+function trancar(fd) { return observarTrava(fd) === 'adquirida'; }
 function abrirTrava(arquivo, criar) {
     const fd = fs.openSync(arquivo, fs.constants.O_RDWR | fs.constants.O_NOFOLLOW | (criar ? fs.constants.O_CREAT : 0), 0o600);
     const st = fs.fstatSync(fd);
@@ -210,11 +234,57 @@ function minhaVez(dir, senha) {
     }
     return true;
 }
+function hashLocal(valor) { return (0, node_crypto_1.createHash)('sha256').update(valor).digest('hex').slice(0, 24); }
+/** Identidades opacas: provam igualdade sem publicar hostname, boot id ou inode do namespace. */
+function identidadeDaMaquina() {
+    let host = null, espacoPids = null;
+    try {
+        host = hashLocal(fs.readFileSync('/proc/sys/kernel/random/boot_id', 'utf8').trim());
+    }
+    catch { /* nao observavel */ }
+    try {
+        espacoPids = hashLocal(fs.readlinkSync('/proc/self/ns/pid'));
+    }
+    catch { /* nao observavel */ }
+    return { host, espacoPids };
+}
 function gravarDono(fd, dono, posse) {
     const bytes = Buffer.from(JSON.stringify({ contrato: exports.CONTRATO_FILA_PESADA, ...dono, posse }) + '\n', 'utf8');
     fs.ftruncateSync(fd, 0);
     fs.writeSync(fd, bytes, 0, bytes.length, 0);
 }
+function arquivoDaBatida(dir, slot, posse) {
+    return path.join(dir, `vaga-${slot}.${posse}.heartbeat.json`);
+}
+/** Worker nativo: a batida continua enquanto o verify sincrono bloqueia a thread JS, sem processo shell perdido. */
+function iniciarBatida(dir, slot, posse) {
+    const arquivo = arquivoDaBatida(dir, slot, posse);
+    try {
+        const worker = new node_worker_threads_1.Worker(`
+      const fs = require('node:fs');
+      const { parentPort, workerData } = require('node:worker_threads');
+      const { randomUUID } = require('node:crypto');
+      let ativo = true;
+      parentPort.on('message', () => { ativo = false; });
+      function bater() {
+        if (!ativo) return;
+        const tmp = workerData.arquivo + '.' + randomUUID() + '.tmp';
+        try {
+          fs.writeFileSync(tmp, JSON.stringify({ contrato: 'ork.fila-pesada-heartbeat/v1', posse: workerData.posse,
+            expiraEm: new Date(Date.now() + workerData.validadeMs).toISOString() }) + '\\n', { flag: 'wx', mode: 0o600 });
+          fs.renameSync(tmp, workerData.arquivo);
+        } catch (_) { try { fs.unlinkSync(tmp); } catch (_) {} }
+        if (ativo) setTimeout(bater, workerData.intervaloMs);
+      }
+      bater();
+    `, { eval: true, workerData: { arquivo, posse, intervaloMs: BATIDA_CADA_MS, validadeMs: BATIDA_VALE_MS } });
+        worker.unref();
+        return { worker, arquivo };
+    }
+    catch {
+        return null;
+    }
+}
 /** O artefato primeiro, depois a primeira vaga livre; sem vaga, solta o artefato. Nunca espera segurando nada. */
 function tentarVaga(dir, pedido) {
     const fdArtefato = tentarTravaExclusiva(path.join(dir, `artefato-${chaveDoArtefato(pedido.artefato)}.lock`));
@@ -224,17 +294,29 @@ function tentarVaga(dir, pedido) {
         const fdVaga = tentarTravaExclusiva(path.join(dir, `vaga-${slot}.lock`));
         if (fdVaga === null)
             continue;
-        const dono = { slot, operacao: pedido.operacao, thread: pedido.thread, artefato: path.resolve(pedido.artefato),
-            pid: process.pid, desde: new Date().toISOString() };
         const id = (0, node_crypto_1.randomUUID)();
+        const identidade = identidadeDaMaquina();
+        const dono = { slot, operacao: pedido.operacao, thread: pedido.thread, artefato: path.resolve(pedido.artefato),
+            pid: process.pid, desde: new Date().toISOString(), inicio: inicioDoProcesso(process.pid), ...identidade };
         gravarDono(fdVaga, dono, id);
         gravarDono(fdArtefato, dono, id);
-        return { fdArtefato, fdVaga, slot, id };
+        const batida = iniciarBatida(dir, slot, id);
+        return { fdArtefato, fdVaga, slot, id, batida: batida?.worker ?? null, arquivoDaBatida: batida?.arquivo ?? null };
     }
     fs.closeSync(fdArtefato);
     return null;
 }
 function soltar(posse) {
+    try {
+        posse.batida?.postMessage('parar');
+        void posse.batida?.terminate();
+    }
+    catch { /* o processo tambem encerra o worker */ }
+    if (posse.arquivoDaBatida)
+        try {
+            fs.unlinkSync(posse.arquivoDaBatida);
+        }
+        catch { /* batida expira sozinha */ }
     for (const fd of [posse.fdVaga, posse.fdArtefato]) {
         try {
             fs.ftruncateSync(fd, 0);
@@ -264,7 +346,8 @@ function ocupantesDaFilaPesada(raiz) {
             continue;
         }
         try {
-            if (trancar(fd))
+            const trava = observarTrava(fd);
+            if (trava === 'adquirida')
                 continue;
             const slot = Number(/^vaga-(\d+)\.lock$/.exec(nome)[1]);
             let dono = {};
@@ -272,9 +355,31 @@ function ocupantesDaFilaPesada(raiz) {
                 dono = JSON.parse(fs.readFileSync(path.join(dir, nome), 'utf8'));
             }
             catch { /* dono ainda gravando */ }
+            let batidaExpiraEm = null;
+            if (typeof dono.posse === 'string') {
+                try {
+                    const batida = JSON.parse(fs.readFileSync(arquivoDaBatida(dir, slot, dono.posse), 'utf8'));
+                    if (batida.posse === dono.posse && typeof batida.expiraEm === 'string')
+                        batidaExpiraEm = batida.expiraEm;
+                }
+                catch { /* batida ausente, vencida ou ainda sendo publicada */ }
+            }
+            const local = identidadeDaMaquina();
+            const mesmoHost = typeof dono.host === 'string' && local.host === dono.host;
+            const mesmoEspacoPids = typeof dono.espacoPids === 'string' && local.espacoPids === dono.espacoPids;
+            let processo = 'desconhecido';
+            if (mesmoHost && mesmoEspacoPids && typeof dono.pid === 'number' && typeof dono.inicio === 'string') {
+                const atual = inicioDoProcesso(dono.pid);
+                processo = atual === dono.inicio ? 'vivo' : atual === null ? 'ausente' : 'ausente';
+            }
+            const estado = avaliarVidaDoOcupante({ trava: trava === 'ocupada' ? 'ocupada' : 'desconhecida',
+                batidaValida: batidaExpiraEm !== null && Date.parse(batidaExpiraEm) > Date.now(), mesmoHost, mesmoEspacoPids, processo });
             ocupantes.push({ slot, operacao: typeof dono.operacao === 'string' ? dono.operacao : 'desconhecida',
                 thread: typeof dono.thread === 'string' ? dono.thread : null, artefato: typeof dono.artefato === 'string' ? dono.artefato : '',
-                pid: typeof dono.pid === 'number' ? dono.pid : 0, desde: typeof dono.desde === 'string' ? dono.desde : '' });
+                pid: typeof dono.pid === 'number' ? dono.pid : 0, desde: typeof dono.desde === 'string' ? dono.desde : '',
+                inicio: typeof dono.inicio === 'string' ? dono.inicio : null, host: typeof dono.host === 'string' ? dono.host : null,
+                espacoPids: typeof dono.espacoPids === 'string' ? dono.espacoPids : null,
+                posse: typeof dono.posse === 'string' ? dono.posse : undefined, batidaExpiraEm, ...estado });
         }
         finally {
             fs.closeSync(fd);
@@ -283,19 +388,24 @@ function ocupantesDaFilaPesada(raiz) {
     return ocupantes;
 }
 function recusaDaFila(pedido, esperouMs, ocupantes) {
+    const indeterminado = ocupantes.some(o => o.vida === 'desconhecido');
+    const motivo = indeterminado ? 'concurrency.lease-indeterminado' : 'fila-pesada.ocupada';
     const espera = esperouMs < 60000 ? `${Math.round(esperouMs / 1000)} s` : `${Math.round(esperouMs / 60000)} min`;
     const linhas = [
         `Operação pesada não executada: ${pedido.operacao}${pedido.thread ? ` da thread ${pedido.thread}` : ''} esperou ${espera} ` +
             `e a fila de recursos pesados não liberou a vez (até ${pedido.slots} ao mesmo tempo, concurrency.max_parallel_heavy). ` +
             'Verify e build juntos nesta máquina dão regressão falsa.',
         ...(ocupantes.length ? ocupantes.map(o => `  Quem ocupa: ${o.operacao}${o.thread ? ` da thread ${o.thread}` : ''}, ` +
-            `desde ${(0, horario_1.formatarDesde)(o.desde)}, processo ${o.pid}.`) : ['  Quem ocupa: a vez é de outro pedido que chegou antes e ainda espera.']),
+            `desde ${(0, horario_1.formatarDesde)(o.desde)}, processo ${o.pid}${o.vida === 'desconhecido' ? '; vida indeterminada' : ''}.`) :
+            ['  Quem ocupa: a vez é de outro pedido que chegou antes e ainda espera.']),
+        ...(indeterminado ? ['A vida do lease não pôde ser comprovada deste ambiente; “não sei” nunca é órfão. ' +
+                'Espere com --esperar ou devolva à condução com concurrency.lease-indeterminado.'] : []),
         'O que você pode fazer:',
         '  1. Esperar a vez: o dono da vaga segue rodando e, quando ele termina ou morre, a vaga volta sozinha.',
         ...(pedido.comandoDeEsperar ? [`     ${pedido.comandoDeEsperar}`] : []),
         '  2. Desligar a fila só nesta máquina, se ela aguenta: concurrency.max_parallel_heavy no orkastery.yaml (0 desliga).',
     ];
-    return { contrato: 'ork.fila-pesada-recusa/v1', motivo: 'fila-pesada.ocupada', operacao: pedido.operacao, thread: pedido.thread,
+    return { contrato: 'ork.fila-pesada-recusa/v1', motivo, operacao: pedido.operacao, thread: pedido.thread,
         slots: pedido.slots, esperouMs, ocupantes, texto: linhas.join('\n') };
 }
 const pausa = new Int32Array(new SharedArrayBuffer(4));

package/dist/hitl-classificacao.js

@@ -71,6 +71,7 @@ exports.MOTIVOS_DO_ORQUESTRADOR = Object.freeze([
     'verify.failed', 'verify.regression', 'verify.timeout', 'verify.sem-veredito',
     'claims.failed', 'claims.unverifiable', 'ci.failed', 'hitl.formato',
     'lease.busy', 'vaga.stale', 'conducao.em-andamento', 'concurrency.limite',
+    'concurrency.lease-indeterminado', 'conducao.acao-necessaria',
 ]);
 function quemDecide(motivo) {
     return exports.MOTIVOS_DO_ORQUESTRADOR.includes(String(motivo ?? '')) ? 'orquestrador' : 'dono';

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 '';