@orkastery/cli 0.6.0 → 0.6.2

package/dist/mcp-verify-async.js

@@ -0,0 +1,353 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTRATO_VERIFY_MCP = void 0;
+exports.iniciarVerifyMcp = iniciarVerifyMcp;
+exports.consultarVerifyMcp = consultarVerifyMcp;
+exports.executarVerifyMcpWorker = executarVerifyMcpWorker;
+/**
+ * Verify assíncrono do MCP: o transporte inicia uma rodada curta e um worker do próprio servidor
+ * executa o mesmo `verificar` do CLI. O estado fica no domínio canônico da thread; o modelo nunca
+ * escolhe raiz, comando, PID ou lease.
+ */
+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 hitl_gates_1 = require("./hitl-gates");
+const manifest_1 = require("./manifest");
+const mcp_artifacts_1 = require("./mcp-artifacts");
+const leases_1 = require("./leases");
+const thread_1 = require("./thread");
+const verify_1 = require("./verify");
+const conducao_1 = require("./conducao");
+const fila_pesada_1 = require("./fila-pesada");
+const mcp_verify_1 = require("./mcp-verify");
+const verify_2 = require("./verify");
+const claims_1 = require("./claims");
+const locale_1 = require("./locale");
+exports.CONTRATO_VERIFY_MCP = 'ork.verify-mcp/v1';
+const ESTADOS_VIVOS = new Set(['na-fila', 'rodando']);
+const UUID = /^[a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/i;
+const LIMITE_ESTADO = 16 * 1024 * 1024;
+function agora(dep) { return (dep?.agora?.() ?? new Date()).toISOString(); }
+function falhaDaExecucao(e) {
+    if (e instanceof fila_pesada_1.ErroDaFilaPesada)
+        return { motivo: e.recusa.motivo, detalhe: e.message, recusa: e.recusa };
+    if (e instanceof conducao_1.ErroDeConducao)
+        return { motivo: e.recusa.motivo, detalhe: e.message, recusa: e.recusa };
+    return { motivo: 'verify.worker-failed', detalhe: e.message };
+}
+function inicioDoProcesso(pid) {
+    try {
+        const stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8');
+        return stat.slice(stat.lastIndexOf(')') + 2).split(' ')[19] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function processoVivo(processo) {
+    try {
+        process.kill(processo.pid, 0);
+    }
+    catch {
+        return false;
+    }
+    return processo.inicio === null || inicioDoProcesso(processo.pid) === processo.inicio;
+}
+function mesmoLease(a, b) {
+    return !!a && a.nome === b.nome && a.thread === b.thread && a.pid === b.pid &&
+        a.adquiridoEm === b.adquiridoEm && a.expiraEm === b.expiraEm && a.motivo === b.motivo;
+}
+function diretorioDasRodadas(raiz, threadId, criar) {
+    (0, mcp_artifacts_1.validarArquivosEstadoMcp)(raiz, threadId);
+    const threadDir = fs.realpathSync((0, thread_1.dirThread)(raiz, threadId));
+    const estadoReal = fs.realpathSync(path.join(raiz, '.orkastery'));
+    if (!threadDir.startsWith(estadoReal + path.sep))
+        throw Error('mcp.verify.async.scope');
+    const dir = path.join(threadDir, 'verify-mcp');
+    const st = fs.lstatSync(dir, { throwIfNoEntry: false });
+    if (!st) {
+        if (!criar)
+            throw Error('mcp.verify.round.not-found');
+        fs.mkdirSync(dir, { mode: 0o700 });
+    }
+    const atual = fs.lstatSync(dir);
+    if (!atual.isDirectory() || atual.isSymbolicLink() || fs.realpathSync(dir) !== dir ||
+        (process.getuid && atual.uid !== process.getuid()))
+        throw Error('mcp.verify.async.scope');
+    return dir;
+}
+function lerArquivoSeguro(file, ausente) {
+    let fd;
+    try {
+        fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+    }
+    catch (e) {
+        if (ausente && e.code === 'ENOENT')
+            return null;
+        throw e;
+    }
+    try {
+        const st = fs.fstatSync(fd);
+        if (!st.isFile() || st.nlink !== 1 || st.size > LIMITE_ESTADO || (process.getuid && st.uid !== process.getuid()))
+            throw Error('mcp.verify.async.unsafe');
+        const bytes = fs.readFileSync(fd);
+        if (bytes.length > LIMITE_ESTADO)
+            throw Error('mcp.verify.async.too-large');
+        return bytes;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function validarEstado(v, threadId, rodadaId) {
+    const e = v;
+    if (!e || e.contrato !== exports.CONTRATO_VERIFY_MCP || e.threadId !== threadId || e.rodadaId !== rodadaId ||
+        !UUID.test(rodadaId) || !['na-fila', 'rodando', 'concluido', 'falhou'].includes(String(e.estado)) ||
+        typeof e.criadaEm !== 'string' || typeof e.atualizadaEm !== 'string' ||
+        !e.lease || e.lease.thread !== threadId || typeof e.host !== 'string')
+        throw Error('mcp.verify.async.invalid');
+    return e;
+}
+function lerEstado(dir, threadId, rodadaId) {
+    if (!UUID.test(rodadaId))
+        throw Error('mcp.verify.round.invalid');
+    const bytes = lerArquivoSeguro(path.join(dir, `${rodadaId}.json`), false);
+    try {
+        return validarEstado(JSON.parse(bytes.toString('utf8')), threadId, rodadaId);
+    }
+    catch (e) {
+        if (e.message.startsWith('mcp.'))
+            throw e;
+        throw Error('mcp.verify.async.invalid');
+    }
+}
+function gravarAtomico(dir, nome, valor) {
+    const destino = path.join(dir, nome);
+    const temp = path.join(dir, `.${nome}.${process.pid}.${(0, node_crypto_1.randomUUID)()}.tmp`);
+    const bytes = JSON.stringify(valor) + '\n';
+    if (Buffer.byteLength(bytes) > LIMITE_ESTADO)
+        throw Error('mcp.verify.async.too-large');
+    try {
+        fs.writeFileSync(temp, bytes, { flag: 'wx', mode: 0o600 });
+        fs.renameSync(temp, destino);
+    }
+    finally {
+        fs.rmSync(temp, { force: true });
+    }
+}
+function gravarEstado(dir, estado) {
+    gravarAtomico(dir, `${estado.rodadaId}.json`, estado);
+}
+function lerAtiva(dir, threadId) {
+    const bytes = lerArquivoSeguro(path.join(dir, 'active.json'), true);
+    if (!bytes)
+        return null;
+    let id;
+    try {
+        id = JSON.parse(bytes.toString('utf8')).rodadaId;
+    }
+    catch {
+        throw Error('mcp.verify.async.invalid');
+    }
+    if (typeof id !== 'string' || !UUID.test(id))
+        throw Error('mcp.verify.async.invalid');
+    return lerEstado(dir, threadId, id);
+}
+function publico(estado, reutilizada) {
+    const { host: _host, processo: _processo, lease: _lease, ...visivel } = estado;
+    return { ...visivel, ...(reutilizada === undefined ? {} : { reutilizada }) };
+}
+function vivo(estado, dep) {
+    return !!estado.processo && (dep?.processoVivo ?? processoVivo)(estado.processo);
+}
+function liberarLeaseExata(raiz, estado) {
+    if (mesmoLease((0, leases_1.lerLease)(raiz, estado.lease.nome), estado.lease))
+        (0, leases_1.liberar)(raiz, estado.lease.nome, estado.threadId);
+}
+function falhaDeProcesso(estado, instante) {
+    return { ...estado, estado: 'falhou', lane: null, atualizadaEm: instante,
+        falha: { motivo: 'verify.processo-morto', detalhe: 'o worker terminou sem gravar um veredito completo' } };
+}
+function prazoDaLease(raiz, threadId) {
+    const carregado = (0, manifest_1.exigirManifesto)(raiz);
+    const claims = (0, claims_1.lerClaims)(raiz, threadId).filter((c) => c.estado !== 'retirada');
+    const quantidade = claims.reduce((n, c) => n + c.verificar.length, 0) + (0, verify_2.comandosDoManifesto)(carregado.manifesto).length + 2;
+    const prazos = [carregado.manifesto.verify.timeout_ms ?? 600_000,
+        ...Object.values(carregado.manifesto.verify.timeout_ms_por_comando ?? {}).filter((n) => typeof n === 'number')];
+    return mcp_verify_1.ESPERA_DA_FILA_PESADA_MCP_MS + Math.max(conducao_1.PRAZO_DE_SESSAO_PADRAO_MS, (0, conducao_1.prazoDaVerificacao)(Math.max(...prazos), quantidade));
+}
+function lancarWorker(pedido) {
+    const child = (0, node_child_process_1.spawn)(process.execPath, [pedido.worker, pedido.raiz, pedido.threadId, pedido.rodadaId], {
+        cwd: pedido.raiz, detached: true, stdio: 'ignore', env: process.env,
+    });
+    if (!child.pid)
+        throw Error('mcp.verify.worker.spawn');
+    child.unref();
+    let inicio = null;
+    for (let i = 0; i < 20 && inicio === null; i++) {
+        inicio = inicioDoProcesso(child.pid);
+        if (inicio === null)
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5);
+    }
+    return { pid: child.pid, inicio };
+}
+function iniciarVerifyMcp(raiz, threadId, vinculo, dep = {}) {
+    const carregado = (0, manifest_1.exigirManifesto)(raiz);
+    if (fs.realpathSync(carregado.raiz) !== fs.realpathSync(raiz))
+        throw Error('mcp.verify.project');
+    (0, mcp_artifacts_1.validarArquivosEstadoMcp)(raiz, threadId);
+    const thread = (0, thread_1.lerThread)(raiz, threadId);
+    if (thread.status === 'fechada' || !thread.worktree)
+        throw Error('mcp.verify.thread');
+    return (0, hitl_gates_1.comLockHitl)(raiz, threadId, () => {
+        const dir = diretorioDasRodadas(raiz, threadId, true);
+        const ativa = lerAtiva(dir, threadId);
+        if (ativa && ESTADOS_VIVOS.has(ativa.estado) && vivo(ativa, dep))
+            return publico(ativa, true);
+        if (ativa) {
+            const reconciliada = ESTADOS_VIVOS.has(ativa.estado) ? falhaDeProcesso(ativa, agora(dep)) : ativa;
+            if (reconciliada !== ativa)
+                gravarEstado(dir, reconciliada);
+            liberarLeaseExata(raiz, reconciliada);
+        }
+        const nomeLease = `worktree-write:${threadId}`;
+        (0, leases_1.podarRegioesDeThreadsFechadas)(raiz, [nomeLease, 'main-tree'], threadId);
+        if ((0, leases_1.lerLease)(raiz, nomeLease) || (0, leases_1.leasesColidentes)(raiz, nomeLease).length || (0, leases_1.leasesColidentes)(raiz, 'main-tree').length)
+            throw Error('lease.busy: verify assíncrono exige a worktree livre');
+        const rodadaId = (0, node_crypto_1.randomUUID)();
+        const instante = agora(dep);
+        const regiao = (0, leases_1.adquirirRegiao)(raiz, nomeLease, { thread: threadId, motivo: `MCP VERIFY ASYNC ${rodadaId}`,
+            ttlMs: prazoDaLease(raiz, threadId), retomarVencido: false });
+        if (!regiao.ok || !regiao.lease)
+            throw Error('lease.busy: verify assíncrono não adquiriu a worktree');
+        let estado = { contrato: exports.CONTRATO_VERIFY_MCP, rodadaId, threadId, despacho: vinculo.despacho,
+            host: vinculo.host, estado: 'na-fila', lane: null, criadaEm: instante, atualizadaEm: instante,
+            processo: null, lease: regiao.lease };
+        gravarEstado(dir, estado);
+        gravarAtomico(dir, 'active.json', { contrato: exports.CONTRATO_VERIFY_MCP, rodadaId });
+        try {
+            const worker = path.resolve(__dirname, 'mcp-verify-worker.js');
+            const processo = (dep.lancar ?? lancarWorker)({ worker, raiz: fs.realpathSync(raiz), threadId, rodadaId });
+            estado = { ...estado, processo, atualizadaEm: agora(dep) };
+            gravarEstado(dir, estado);
+            return publico(estado, false);
+        }
+        catch (e) {
+            estado = { ...estado, estado: 'falhou', atualizadaEm: agora(dep),
+                falha: { motivo: 'verify.worker-failed', detalhe: e.message } };
+            gravarEstado(dir, estado);
+            liberarLeaseExata(raiz, estado);
+            return publico(estado, false);
+        }
+    });
+}
+function consultarVerifyMcp(raiz, threadId, rodadaId, dep = {}) {
+    (0, thread_1.lerThread)(raiz, threadId);
+    (0, mcp_artifacts_1.validarArquivosEstadoMcp)(raiz, threadId);
+    const estado = lerEstado(diretorioDasRodadas(raiz, threadId, false), threadId, rodadaId);
+    return publico(ESTADOS_VIVOS.has(estado.estado) && !vivo(estado, dep) ? falhaDeProcesso(estado, agora(dep)) : estado);
+}
+function atualizarRodada(raiz, threadId, rodadaId, mudar) {
+    return (0, hitl_gates_1.comLockHitl)(raiz, threadId, () => {
+        const dir = diretorioDasRodadas(raiz, threadId, false);
+        const atual = lerEstado(dir, threadId, rodadaId);
+        const proximo = mudar(atual);
+        gravarEstado(dir, proximo);
+        return proximo;
+    });
+}
+/** Entrada do processo destacado; exportada para o teste hermético executar a mesma rodada sem transporte. */
+function executarVerifyMcpWorker(raiz, threadId, rodadaId) {
+    const dir = diretorioDasRodadas(raiz, threadId, false);
+    let inicial = lerEstado(dir, threadId, rodadaId);
+    const inicioAtual = inicioDoProcesso(process.pid);
+    if (!inicial.processo || inicial.processo.pid !== process.pid ||
+        (inicial.processo.inicio !== null && inicial.processo.inicio !== inicioAtual))
+        throw Error('mcp.verify.worker.identity');
+    if (!mesmoLease((0, leases_1.lerLease)(raiz, inicial.lease.nome), inicial.lease))
+        throw Error('mcp.verify.worker.lease');
+    const atualizar = (mudanca) => {
+        inicial = atualizarRodada(raiz, threadId, rodadaId, (atual) => {
+            if (!mesmoLease((0, leases_1.lerLease)(raiz, atual.lease.nome), atual.lease))
+                return { ...atual, estado: 'falhou', lane: null, atualizadaEm: new Date().toISOString(),
+                    falha: { motivo: 'verify.lease-perdida', detalhe: 'a lease da worktree mudou durante a rodada' } };
+            return { ...atual, ...mudanca, atualizadaEm: new Date().toISOString() };
+        });
+        if (inicial.estado === 'falhou')
+            throw Error(inicial.falha?.motivo ?? 'verify.worker-failed');
+    };
+    // RM-064: o estado terminal só é gravado depois de a lease voltar. Quem lê `concluido` ou `falhou`
+    // pode contar com a worktree livre; a ordem inversa deixava a recusa visível com a lease ainda presa.
+    let terminal = null;
+    try {
+        atualizar({ estado: 'na-fila', lane: 'fila-pesada' });
+        const carregado = (0, manifest_1.exigirManifesto)(raiz);
+        const resultado = (0, locale_1.comLocale)('pt-BR', () => (0, verify_1.verificar)(carregado, threadId, {
+            operacao: 'mcp.verify',
+            conducao: { canal: inicial.host, identidade: inicial.despacho,
+                filaPesada: { esperarMs: mcp_verify_1.ESPERA_DA_FILA_PESADA_MCP_MS, aoEsperar: (ocupantes) => atualizar({ estado: 'na-fila',
+                        lane: 'fila-pesada', ocupantes: ocupantes.map((o) => ({ operacao: o.operacao, thread: o.thread })) }) } },
+            progresso: (lane) => atualizar({ estado: 'rodando', lane, ocupantes: undefined }),
+        }));
+        const locale = (0, locale_1.resolverLocale)(carregado.manifesto.owner?.language).locale;
+        const veredito = { ok: resultado.ok, commit: resultado.commit, motivos: resultado.motivos,
+            check: resultado.check, texto: (0, locale_1.comLocale)(locale, () => (0, verify_1.textoDoVerify)(resultado)), resultado };
+        terminal = { estado: 'concluido', lane: null, veredito, falha: undefined, ocupantes: undefined };
+    }
+    catch (e) {
+        terminal = { estado: 'falhou', lane: null, falha: falhaDaExecucao(e), ocupantes: undefined };
+    }
+    finally {
+        const atual = lerEstado(dir, threadId, rodadaId);
+        const leaseNossa = mesmoLease((0, leases_1.lerLease)(raiz, atual.lease.nome), atual.lease);
+        liberarLeaseExata(raiz, atual);
+        if (atual.estado === 'falhou')
+            terminal = null; // a falha já gravada (lease perdida, por exemplo) prevalece
+        else if (!leaseNossa)
+            terminal = { estado: 'falhou', lane: null, ocupantes: undefined,
+                falha: { motivo: 'verify.lease-perdida', detalhe: 'a lease da worktree mudou durante a rodada' } };
+        if (terminal) {
+            const fim = terminal;
+            try {
+                inicial = atualizarRodada(raiz, threadId, rodadaId, (a) => ({ ...a, ...fim, atualizadaEm: new Date().toISOString() }));
+            }
+            catch { /* a leitura abaixo projeta morte/falha; nunca inventa verde */ }
+        }
+    }
+    return consultarVerifyMcp(raiz, threadId, rodadaId);
+}

package/dist/mcp-verify-worker.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/** Processo destacado do verify MCP. Toda autoridade vem do estado criado pelo servidor. */
+const mcp_verify_async_1 = require("./mcp-verify-async");
+if (require.main === module) {
+    const [raiz, threadId, rodadaId, ...resto] = process.argv.slice(2);
+    if (!raiz || !threadId || !rodadaId || resto.length)
+        process.exitCode = 2;
+    else {
+        try {
+            (0, mcp_verify_async_1.executarVerifyMcpWorker)(raiz, threadId, rodadaId);
+        }
+        catch {
+            process.exitCode = 1;
+        }
+    }
+}

package/dist/mcp-verify.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ESPERA_DA_FILA_PESADA_MCP_MS = void 0;
+exports.diagnosticoDoVerifyMcp = diagnosticoDoVerifyMcp;
 exports.verificarMcp = verificarMcp;
 /** Operação estruturada: argumentos só identificam a thread; execução sempre confinada. */
 const fs = __importStar(require("node:fs"));
@@ -68,6 +69,14 @@ function mesmoLease(a, b) {
     return !!a && a.nome === b.nome && a.thread === b.thread && a.pid === b.pid &&
         a.adquiridoEm === b.adquiridoEm && a.expiraEm === b.expiraEm && a.motivo === b.motivo;
 }
+/** Parte pura do retorno MCP: permite provar o contrato mesmo quando o sandbox nao abre outro sandbox. */
+function diagnosticoDoVerifyMcp(r) {
+    return {
+        regressoes: r.regressoes.map(c => c.nome),
+        preExistentes: r.preExistentes.map(c => c.nome),
+        comparacoes: r.comparacoes,
+    };
+}
 /** Síncrono: prazo total/per-command, não cancelamento reativo do event loop. */
 function verificarMcp(raizEntrada, threadId, conducao = {}) {
     const deadline = Date.now() + PRAZO_TOTAL_MS;
@@ -167,7 +176,7 @@ function verificarMcp(raizEntrada, threadId, conducao = {}) {
             execucoes: execucoes.slice(0, LIMITE_RETORNO).map(c => ({ nome: c.nome, ok: c.ok, code: c.code,
                 executado: c.executado === true, resumo: c.resumo })),
             totalExecucoes: execucoes.length, omitidas: Math.max(0, execucoes.length - LIMITE_RETORNO),
-            regressoes: r.regressoes.map(c => c.nome), preExistentes: r.preExistentes.map(c => c.nome),
+            ...diagnosticoDoVerifyMcp(r),
             executor: 'codex-sandbox', prazoTotalMs: PRAZO_TOTAL_MS, limitePorComandoMs: COMANDO_MAX_MS,
         };
     }

package/dist/merge-da-entrega.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.branchRegistradaDaEntrega = branchRegistradaDaEntrega;
+exports.mergesDasEntregasNaBase = mergesDasEntregasNaBase;
+/**
+ * Reconhecimento unico do merge que entrega uma thread na linha de primeiro pai da base.
+ *
+ * A forja pode preservar o titulo `ship(<thread>)` no assunto ou usar sua mensagem padrao.
+ * Nos formatos padrao, a branch e o vinculo: ela precisa ser exatamente a branch registrada
+ * para a thread. O fallback pela convencao existe para o `docs verificar` no CI, que nao tem
+ * `.orkastery/`, e fecha o id antes de aceitar o sufixo da fase (`ork-abc` nao casa `ork-abcd`).
+ */
+const branch_de_estado_1 = require("./branch-de-estado");
+const ledger_1 = require("./ledger");
+const thread_1 = require("./thread");
+const util_1 = require("./util");
+/** A branch da thread como foi registrada, preferindo o evento especifico da worktree. */
+function branchRegistradaDaEntrega(raiz, thread) {
+    try {
+        const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, thread));
+        const worktree = [...eventos].reverse().find((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.worktreeCriada && (0, branch_de_estado_1.branchValida)(e.branch));
+        if (worktree)
+            return String(worktree.branch);
+        const criada = [...eventos].reverse().find((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.threadCriada);
+        const base = criada?.base;
+        if (base && typeof base === 'object' && !Array.isArray(base)) {
+            const branch = base.branch;
+            if ((0, branch_de_estado_1.branchValida)(branch))
+                return branch;
+        }
+    }
+    catch { /* checkout de CI ou thread sem estado local */ }
+    return null;
+}
+const branchConvencionalDaThread = (branch, thread) => {
+    const prefixo = `ork/${thread}`;
+    return branch === prefixo || branch.startsWith(`${prefixo}-`);
+};
+function threadDoAssunto(assunto, entregas, base) {
+    const ship = /^ship\(([^)]+)\)/.exec(assunto);
+    if (ship?.[1])
+        return ship[1];
+    const github = /^Merge pull request #[1-9][0-9]* from [^/\s]+\/(\S+)$/.exec(assunto);
+    const gitlab = /^Merge branch '(.+)' into '(.+)'$/.exec(assunto);
+    const branch = github?.[1] ?? (gitlab?.[2] === base ? gitlab[1] : null);
+    if (!branch)
+        return null;
+    return entregas.find((entrega) => entrega.branch === null
+        ? branchConvencionalDaThread(branch, entrega.thread)
+        : branch === entrega.branch)?.thread ?? null;
+}
+/**
+ * Merges das entregas na base, em ordem do git log (mais novo primeiro por omissao).
+ *
+ * O assunto e lido por `%s`, portanto uma citacao somente no corpo nao entra. `--first-parent`
+ * tira commits da branch lateral. O segundo pai continua opcional no retorno para preservar a
+ * recusa tipada `entrega.sem-vinculo` de squash/rebase quando a CI e obrigatoria.
+ */
+function mergesDasEntregasNaBase(raiz, refBase, base, entregas, reverse = false) {
+    const saida = new Map(entregas.map((e) => [e.thread, []]));
+    if (!(0, branch_de_estado_1.branchValida)(refBase) || !(0, branch_de_estado_1.branchValida)(base))
+        return saida;
+    const args = ['log', refBase, '--first-parent', '--format=%H%x09%P%x09%cI%x09%s', ...(reverse ? ['--reverse'] : []), '--'];
+    const r = (0, util_1.exec)('git', args, raiz, 60000);
+    if (!r.ok)
+        return saida;
+    for (const linha of r.stdout.split('\n')) {
+        const [sha, pais, em, assunto] = linha.split('\t');
+        if (!(0, branch_de_estado_1.shaValido)(sha) || typeof assunto !== 'string')
+            continue;
+        const thread = threadDoAssunto(assunto, entregas, base);
+        if (!thread)
+            continue;
+        const segundo = (pais ?? '').split(' ')[1] ?? null;
+        const ms = Date.parse(em ?? '');
+        const merges = saida.get(thread) ?? [];
+        merges.push({
+            mergeSha: sha,
+            headSha: segundo && (0, branch_de_estado_1.shaValido)(segundo) ? segundo : null,
+            em: Number.isFinite(ms) ? new Date(ms).toISOString() : null,
+        });
+        saida.set(thread, merges);
+    }
+    return saida;
+}

package/dist/network-roadmap.js

@@ -454,7 +454,7 @@ function maquinasDoPanorama(retratos, local, ctx, lacunas) {
         const idadeMs = Math.max(0, agora - Date.parse(m.publicadoEm));
         const semBatida = idadeMs > fabrica_estado_1.LIMIAR_SEM_BATIDA_MS;
         if (semBatida) {
-            lacunas.push(lacuna('maquina.sem-batida', 'fabrica', m.maquina, `${m.maquina} sem retrato novo há ${(0, horario_1.duracaoCurta)(Math.floor(idadeMs / 60000))} (último em ${(0, horario_1.formatarDataHora)(m.publicadoEm, { fuso: ctx.fuso })}): ` +
+            lacunas.push(lacuna('maquina.sem-batida', 'fabrica', m.maquina, `${m.maquina} sem retrato novo há ${(0, horario_1.duracaoCurta)(Math.floor(idadeMs / 60000))} (último em ${(0, horario_1.formatarDataHora)(m.publicadoEm, { fuso: ctx.fuso, agora: ctx.quando })}): ` +
                 'as threads dela podem ter andado', `confira a ${m.maquina}: ela publica ao criar thread, despachar fase, entregar e a cada batida do pulse`));
         }
         saida.push({ maquina: m.maquina, por: m.por, publicadoEm: m.publicadoEm, idadeMin: Math.floor(idadeMs / 60000), semBatida,
@@ -632,7 +632,7 @@ function lerProjetoDoClone(p, geral) {
             fontes.push({ parte, origem: 'clone', onde, ref: nome, commit: r.ponta, dataDoCommit, lidoEm: ctx.quando, atualizado: r.atualizado, existe: true });
             if (!r.atualizado) {
                 lacunas.push(lacuna(`${parte}.sem-leitura`, parte, onde, `sem leitura nova de ${onde}${porque(r.tentou)}; ` +
-                    `vale a última cópia desta máquina, commit ${r.ponta.slice(0, 7)} de ${(0, horario_1.formatarDataHora)(dataDoCommit, { fuso: ctx.fuso })}`, correcao()));
+                    `vale a última cópia desta máquina, commit ${r.ponta.slice(0, 7)} de ${(0, horario_1.formatarDataHora)(dataDoCommit, { fuso: ctx.fuso, agora: ctx.quando })}`, correcao()));
             }
             return r.ponta;
         }
@@ -1033,15 +1033,15 @@ function descreverProjeto(x) {
 function linhaDaFonte(f, quando, fuso) {
     const m = (0, locale_1.msg)().network.roadmap;
     const parte = m.fonteParte(f.parte);
-    const lido = f.lidoEm === quando ? m.lidoAgora : m.lidoEm((0, horario_1.formatarDataHora)(f.lidoEm, { fuso }));
+    const lido = f.lidoEm === quando ? m.lidoAgora : m.lidoEm((0, horario_1.formatarDataHora)(f.lidoEm, { fuso, agora: quando }));
     if (f.origem === 'estado-local')
         return m.fonteLocal(parte, f.onde, lido);
     if (!f.existe)
         return m.fonteInexistente(parte, f.onde, lido);
     const alvo = f.parte === 'roadmap' ? m.alvoDoRoadmap(f.onde) : f.onde;
-    return m.fonteCommit(parte, alvo, (f.commit ?? '').slice(0, 7), (0, horario_1.formatarDataHora)(f.dataDoCommit, { fuso }), f.atualizado ? lido : m.ultimaCopia);
+    return m.fonteCommit(parte, alvo, (f.commit ?? '').slice(0, 7), (0, horario_1.formatarDataHora)(f.dataDoCommit, { fuso, agora: quando }), f.atualizado ? lido : m.ultimaCopia);
 }
-function linhasDasMaquinas(x, fuso) {
+function linhasDasMaquinas(x, quando, fuso) {
     const m = (0, locale_1.msg)().network.roadmap;
     if (x.maquinas === null)
         return [m.maquinasNaoLidas];
@@ -1051,11 +1051,11 @@ function linhasDasMaquinas(x, fuso) {
         const quem = `${m.maquina}${m.estaMaquina ? (0, locale_1.msg)().network.roadmap.estaMaquina : ''}`;
         // Fatia 3: a maquina so da rede por pessoa; as threads dela neste projeto nao foram lidas.
         if (m.origem === 'rede') {
-            return [(0, locale_1.msg)().network.roadmap.maquinaSoNaRede(quem, (0, horario_1.formatarDataHora)(m.publicadoEm, { fuso }), (0, horario_1.duracaoCurta)(m.idadeMin), m.semBatida, fabrica_estado_1.BRANCH_DA_FABRICA)];
+            return [(0, locale_1.msg)().network.roadmap.maquinaSoNaRede(quem, (0, horario_1.formatarDataHora)(m.publicadoEm, { fuso, agora: quando }), (0, horario_1.duracaoCurta)(m.idadeMin), m.semBatida, fabrica_estado_1.BRANCH_DA_FABRICA)];
         }
         const rm = (0, locale_1.msg)().network.roadmap;
         const batida = m.origem === 'estado-local' ? rm.estadoLocalAgora
-            : rm.retrato((0, horario_1.formatarDataHora)(m.publicadoEm, { fuso }), (0, horario_1.duracaoCurta)(m.idadeMin), m.semBatida);
+            : rm.retrato((0, horario_1.formatarDataHora)(m.publicadoEm, { fuso, agora: quando }), (0, horario_1.duracaoCurta)(m.idadeMin), m.semBatida);
         const cabeca = rm.resumoMaquina(quem, m.ativas.length, m.entreguesSemMaster, batida);
         // RM-037 (rm037noite, defeito 4): o runtime e o modelo de cada thread, quando o retrato os traz.
         return [cabeca, ...m.ativas.map((t) => `  ${t.id} · ${t.modo} · ${t.fase} · ${t.roadmap ?? rm.semItem}` +
@@ -1063,30 +1063,34 @@ function linhasDasMaquinas(x, fuso) {
                 (t.esperaVoce ? rm.esperaVoce(t.pergunta ?? rm.veredito) : ''))];
     });
 }
-function linhasDasReservas(x, fuso) {
+function linhasDasReservas(x, quando, fuso) {
     const m = (0, locale_1.msg)().network.roadmap;
     if (x.reservas === null)
         return [m.reservasNaoLidas];
     if (x.reservas.length === 0)
         return [m.nenhumaReserva];
-    return x.reservas.map((r) => m.reserva(r.item, r.maquina, r.thread ?? m.semThread, (0, horario_1.formatarDataHora)(r.desdeEm, { fuso })));
+    return x.reservas.map((r) => m.reserva(r.item, r.maquina, r.thread ?? m.semThread, (0, horario_1.formatarDataHora)(r.desdeEm, { fuso, agora: quando })));
 }
 /** Fatia 3: a casa da rede por pessoa e as maquinas dela, com a batida e os projetos que declaram. */
 function linhasDaRede(r, quando, fuso) {
     const x = (0, locale_1.msg)().network.roadmap;
-    const lido = r.lidoEm === quando ? x.redeLidaAgora : x.redeLidaEm((0, horario_1.formatarDataHora)(r.lidoEm, { fuso }));
+    const lido = r.lidoEm === quando ? x.redeLidaAgora : x.redeLidaEm((0, horario_1.formatarDataHora)(r.lidoEm, { fuso, agora: quando }));
     const casa = !r.casa ? x.casaAusente
         : r.atualizado === null ? x.casaNaoLida(r.casa)
             : x.casaLida(r.casa, r.ponta ? r.ponta.slice(0, 7) : x.semCommit, r.atualizado ? lido : x.casaUltimaCopia);
     if (r.membros.length === 0)
         return [casa, x.nenhumRetrato];
-    return [casa, ...r.membros.map((m) => x.membro(m.maquina, m.estaMaquina ? x.estaMaquina : '', (0, horario_1.formatarDataHora)(m.publicadoEm, { fuso }), m.idadeMin === null ? x.batidaIlegivel : x.idade((0, horario_1.duracaoCurta)(m.idadeMin)), m.semBatida, m.versaoOrk ? x.versao(m.versaoOrk) : '', m.projetos.length ? x.projetos(m.projetos.join(', ')) : x.nenhumProjeto))];
+    return [casa, ...r.membros.map((m) => x.membro(m.maquina, m.estaMaquina ? x.estaMaquina : '', (0, horario_1.formatarDataHora)(m.publicadoEm, { fuso, agora: quando }), m.idadeMin === null ? x.batidaIlegivel : x.idade((0, horario_1.duracaoCurta)(m.idadeMin)), m.semBatida, m.versaoOrk ? x.versao(m.versaoOrk) : '', m.projetos.length ? x.projetos(m.projetos.join(', ')) : x.nenhumProjeto))];
 }
 const linhaDaLacuna = (l) => {
     const m = (0, locale_1.msg)().network.roadmap;
     return m.lacuna(l.tipo, l.alvo ? ` (${l.alvo})` : '', m.lacunaDetalhe(l.tipo, l.parte, l.alvo, l.detalhe), m.lacunaCorrecao(l.tipo, l.correcao));
 };
-/** O texto de `ork network roadmap`: o consultado e o nao consultado no alto, e cada parte com a fonte e a hora. */
+/**
+ * O texto de `ork network roadmap`: o consultado e o nao consultado no alto, e cada parte com a fonte e a hora. RM-074 (F4):
+ * as datas omitem o ano pelo ano da leitura (`consultadoEm`), nao pelo relogio de quem le o texto: o mesmo panorama da o
+ * mesmo texto em qualquer dia, e o retrato pt-BR F3c nao fica vermelho na virada do ano.
+ */
 function textoDoPanoramaDaRede(p) {
     const m = (0, locale_1.msg)().network.roadmap;
     if (p.contrato !== exports.CONTRATO_PANORAMA_DA_REDE)
@@ -1108,8 +1112,8 @@ function textoDoPanoramaDaRede(p) {
         // Fatia 2 do ensaio (P7): o fuso ja sai no fim do panorama (e no bloco, quando difere): sem a legenda do status.
         linhas.push(x.roadmap ? (0, roadmap_status_1.textoDoStatusDoRoadmap)(x.roadmap, fuso, { legenda: false })
             : m.roadmapNaoLido(x.projeto.nome, x.lacunas.map((l) => l.tipo).filter((t) => t !== 'projeto.sem-clone').join(', ') || m.semFonte));
-        linhas.push('', m.threadsPorMaquina, ...linhasDasMaquinas(x, fuso));
-        linhas.push('', m.reservas, ...linhasDasReservas(x, fuso));
+        linhas.push('', m.threadsPorMaquina, ...linhasDasMaquinas(x, p.consultadoEm, fuso));
+        linhas.push('', m.reservas, ...linhasDasReservas(x, p.consultadoEm, fuso));
         linhas.push('', m.fontes, ...(x.fontes.length ? x.fontes.map((f) => linhaDaFonte(f, p.consultadoEm, fuso)) : [m.nenhumaFonte]));
         linhas.push('', m.lacunas, ...(x.lacunas.length ? x.lacunas.map(linhaDaLacuna) : [m.nenhumaLacuna]));
         // A legenda e a da hora da leitura, como os horarios do panorama: com a de agora, o horario de verao mudava o texto.