@orkastery/cli 0.5.1 → 0.5.3

package/dist/sessoes-contas.js

@@ -0,0 +1,187 @@
+"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.pidVivo = pidVivo;
+exports.ehFantasma = ehFantasma;
+exports.contasDeSessoes = contasDeSessoes;
+exports.consultarContas = consultarContas;
+exports.estadosNasContas = estadosNasContas;
+exports.sessoesVivasPorPerfil = sessoesVivasPorPerfil;
+/**
+ * RM-056 (D4, D5): as sessoes desta maquina em TODAS as contas que o `ork` conhece.
+ *
+ * O `claude agents` e o `~/.codex/sessions` so respondem pela conta do ambiente de quem consulta:
+ * com perfis (`ork accounts`), uma sessao despachada pelo perfil X so aparece consultando com o
+ * `CLAUDE_CONFIG_DIR`/`CODEX_HOME` de X. Aqui a consulta passa pela conta do processo e por cada
+ * perfil do store, sem repetir diretorio, e cada sessao volta com o id do perfil dela (nunca o
+ * diretorio nem nada de dentro dele).
+ *
+ * Fantasma (D5): sessao claude-bg com estado nao terminal sem pid, ou com pid sem processo. O
+ * `claude agents` guarda o registro, mas nao ha quem trabalhe: ela nao ocupa vaga, e
+ * `ork sessions limpar-fantasmas` solta o vinculo do `ork` sem tocar no runtime.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const claude_bg_1 = require("./adapters/claude-bg");
+const codex_1 = require("./adapters/codex");
+const runtime_profiles_1 = require("./runtime-profiles");
+const TERMINAIS = ['done', 'completed', 'exited', 'stopped', 'failed'];
+const estadoDe = (s) => String(s.state ?? s.status ?? '').trim().toLowerCase();
+/** O processo existe? `EPERM` e processo de outro usuario: existe. */
+function pidVivo(pid) {
+    if (typeof pid !== 'number' || !Number.isSafeInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === 'EPERM';
+    }
+}
+/** D5: fantasma e so claude-bg (o codex nao expoe pid na fonte), em estado nao terminal. */
+function ehFantasma(runtime, s, vivo = pidVivo) {
+    return runtime === 'claude-bg' && !TERMINAIS.includes(estadoDe(s)) && !vivo(s.pid);
+}
+const real = (dir) => { try {
+    return fs.realpathSync(dir);
+}
+catch {
+    return path.resolve(dir);
+} };
+/**
+ * D4: as contas a consultar. Os perfis do store vem primeiro (inclusive desativado, que ainda pode
+ * ter sessao viva), para a sessao levar o id do perfil quando a conta do processo e a mesma pasta.
+ */
+function contasDeSessoes(raiz, env = process.env) {
+    const contas = [], fontes = [];
+    const vistos = new Set();
+    const incluir = (runtime, perfil, dir) => {
+        const chave = `${runtime}:${real(dir)}`;
+        if (vistos.has(chave))
+            return;
+        vistos.add(chave);
+        contas.push({ runtime, perfil, dir });
+    };
+    if (raiz) {
+        try {
+            for (const p of (0, runtime_profiles_1.lerPerfis)(raiz).perfis) {
+                const d = (0, runtime_profiles_1.perfilDeDespacho)(p);
+                incluir(d.runtime, d, (d.configDir ?? d.codexHome));
+            }
+        }
+        catch (e) {
+            fontes.push({ origem: 'perfis de conta (ork accounts)', ok: false, detalhe: e.message });
+        }
+    }
+    for (const runtime of runtime_profiles_1.RUNTIMES_COM_PERFIL)
+        incluir(runtime, null, (0, runtime_profiles_1.diretorioImplicito)(runtime, env));
+    return { contas, fontes };
+}
+const rotulo = (c) => c.perfil ? `perfil ${c.perfil.id}` : 'conta do processo';
+/**
+ * D4: as sessoes de todas as contas. Consulta que falha vira fonte `ok: false`, nunca "zero
+ * sessoes". `staleMin` e a janela de atividade que torna viva uma sessao codex (D3).
+ */
+function consultarContas(raiz, opcoes = {}) {
+    const base = opcoes.contas ? { contas: opcoes.contas, fontes: [] } : contasDeSessoes(raiz);
+    const fontes = [...base.fontes];
+    const sessoes = [];
+    const agoraMs = opcoes.agoraMs ?? Date.now();
+    const janelaMs = (opcoes.staleMin ?? 30) * 60_000;
+    for (const conta of base.contas) {
+        const perfil = conta.perfil?.id ?? null;
+        if (conta.runtime === 'claude-bg') {
+            let ambiente;
+            try {
+                ambiente = (0, claude_bg_1.ambienteDoPerfil)(conta.perfil);
+            }
+            catch (e) {
+                fontes.push({ origem: `claude agents (${rotulo(conta)})`, ok: false, detalhe: e.message });
+                continue;
+            }
+            const r = (0, claude_bg_1.consultarSessoes)(undefined, opcoes.todas, ambiente);
+            const origem = `claude agents --json${opcoes.todas ? ' --all' : ''} (${rotulo(conta)})`;
+            // Fatia 2 do ensaio da 0.5.0 (P1): só o ENOENT antes da consulta prova a fonte ausente; qualquer
+            // outra falha do `claude` continua deixando o inventário incompleto.
+            fontes.push(r.ausente
+                ? { origem, ok: true, ausente: true, detalhe: `${r.detalhe}: nenhuma sessão claude-bg a listar`,
+                    correcao: 'para despachar e listar pelo claude-bg, instale o Claude Code e garanta `claude` no PATH' }
+                : { origem, ok: r.ok, detalhe: r.detalhe });
+            for (const s of r.sessoes) {
+                const fantasma = ehFantasma('claude-bg', s);
+                sessoes.push({ ...s, runtime: 'claude-bg', perfil, fantasma, viva: !fantasma && !TERMINAIS.includes(estadoDe(s)) });
+            }
+        }
+        else {
+            const r = (0, codex_1.consultarRollouts)(opcoes.todas, conta.dir);
+            // A conta do processo segue com o caminho de antes; a do perfil vai pelo id, nunca pela pasta.
+            fontes.push(...(conta.perfil ? r.resultadosFontes.map(f => ({ ...f,
+                origem: `codex (${rotulo(conta)}): ${path.relative(conta.dir, f.origem)}` })) : r.resultadosFontes));
+            for (const s of r.sessoes) {
+                const recente = typeof s.atividadeEm === 'number' && agoraMs - s.atividadeEm <= janelaMs;
+                sessoes.push({ ...s, runtime: 'codex', perfil, fantasma: false, viva: estadoDe(s) !== 'completed' && recente });
+            }
+        }
+    }
+    return { sessoes, fontes, contas: base.contas };
+}
+/**
+ * D7: o mapa sessionId -> estado que o escalonador e o monitor usam, agora de todas as contas.
+ * Fantasma vira `fantasma` (nem `working` nem `blocked`: nao ocupa vaga nem pede o dono); codex
+ * vivo vira `working`. `null` ("runtime nao consultado") quando nenhuma conta claude-bg respondeu e
+ * nenhuma sessao codex apareceu: um mapa vazio ali diria "nada rodando" sem ter olhado.
+ */
+function estadosNasContas(raiz, opcoes = {}) {
+    const r = consultarContas(raiz, opcoes);
+    const claude = r.fontes.filter(f => f.origem.startsWith('claude agents'));
+    if (claude.length > 0 && !claude.some(f => f.ok) && !r.sessoes.some(s => s.runtime === 'codex'))
+        return null;
+    return new Map(r.sessoes.map(s => [s.sessionId,
+        s.fantasma ? 'fantasma' : s.runtime === 'codex' ? (s.viva ? 'working' : estadoDe(s)) : estadoDe(s)]));
+}
+/**
+ * RM-056 (D3): sessoes vivas de cada perfil do runtime nesta maquina, a carga do rodizio por
+ * carga. So as contas dos perfis sao consultadas (a do processo nao recebe despacho com perfis).
+ */
+function sessoesVivasPorPerfil(raiz, runtime, staleMin, agoraMs) {
+    const contas = contasDeSessoes(raiz).contas.filter(c => c.runtime === runtime && c.perfil);
+    const carga = new Map(contas.map(c => [c.perfil.id, 0]));
+    for (const s of consultarContas(raiz, { contas, staleMin, agoraMs }).sessoes) {
+        if (s.viva && s.perfil)
+            carga.set(s.perfil, (carga.get(s.perfil) ?? 0) + 1);
+    }
+    return carga;
+}

package/dist/sessoes-inventario.js

@@ -38,9 +38,8 @@ exports.inventariarSessoes = inventariarSessoes;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const os = __importStar(require("node:os"));
-const claude_bg_1 = require("./adapters/claude-bg");
-const codex_1 = require("./adapters/codex");
 const estado_thread_1 = require("./estado-thread");
+const sessoes_contas_1 = require("./sessoes-contas");
 const thread_1 = require("./thread");
 /** Projeto canônico mais próximo de cada cwd declarado, sem varrer o HOME inteiro. */
 function raizesDeRegistros(cwds) {
@@ -71,22 +70,10 @@ function raizesDeRegistros(cwds) {
 }
 function inventariarSessoes(raiz, opcoes = {}) {
     const canonica = (0, estado_thread_1.raizDoEstado)(raiz);
-    const claude = (0, claude_bg_1.consultarSessoes)(undefined, opcoes.todas);
-    const codex = (0, codex_1.consultarRollouts)(opcoes.todas);
-    const origemClaude = `claude agents --json${opcoes.todas ? ' --all' : ''}`;
-    // Fatia 2 do ensaio da 0.5.0 (P1): como o diretório opcional do Codex, só o ENOENT antes da consulta
-    // prova a fonte ausente; qualquer outra falha do `claude` continua deixando o inventário incompleto.
-    const fontes = [
-        claude.ausente
-            ? { origem: origemClaude, ok: true, ausente: true, detalhe: `${claude.detalhe}: nenhuma sessão claude-bg a listar`,
-                correcao: 'para despachar e listar pelo claude-bg, instale o Claude Code e garanta `claude` no PATH' }
-            : { origem: origemClaude, ok: claude.ok, detalhe: claude.detalhe },
-        ...codex.resultadosFontes,
-    ];
-    const todas = [
-        ...claude.sessoes.map(s => ({ ...s, runtime: 'claude-bg', vinculos: [] })),
-        ...codex.sessoes.map(s => ({ ...s, runtime: 'codex', vinculos: [] })),
-    ];
+    // RM-056 (D4): a conta do processo e cada perfil do store, sem repetir diretorio.
+    const contas = (0, sessoes_contas_1.consultarContas)(canonica, { todas: opcoes.todas });
+    const fontes = contas.fontes;
+    const todas = contas.sessoes.map(s => ({ ...s, vinculos: [] }));
     // O cruzamento usa o universo global mesmo quando a apresentação é local.
     try {
         const projetos = raizesDeRegistros([canonica, ...todas.map(s => s.cwd)]);
@@ -161,5 +148,6 @@ function inventariarSessoes(raiz, opcoes = {}) {
         escopo: { usuario: os.userInfo().username, global: !!opcoes.global, historico: !!opcoes.todas, raiz: canonica },
         fontes, sessoes, total: sessoes.length,
         semThread: sessoes.filter(s => s.vinculos.length === 0).length, ambiguas,
+        fantasmas: sessoes.filter(s => s.fantasma).length,
     };
 }

package/dist/sessoes.js

@@ -44,19 +44,29 @@ exports.tabelaDeSessoes = tabelaDeSessoes;
 exports.logsDaSessao = logsDaSessao;
 exports.pararSessao = pararSessao;
 exports.comandoDeAttach = comandoDeAttach;
+exports.limparFantasmas = limparFantasmas;
+exports.sessoesSemFim = sessoesSemFim;
+exports.textoDaLimpeza = textoDaLimpeza;
 const adapter = __importStar(require("./adapters/claude-bg"));
 const sessoes_inventario_1 = require("./sessoes-inventario");
 const runtime_profiles_1 = require("./runtime-profiles");
 const util_1 = require("./util");
+const estado_thread_1 = require("./estado-thread");
+const ledger_1 = require("./ledger");
+const thread_1 = require("./thread");
 function textoDoInventario(r) {
     const linhas = [
         `Inventário ${r.escopo.global ? 'global' : 'do projeto'} da conta ${r.escopo.usuario}; histórico: ${r.escopo.historico ? 'incluído' : 'omitido'}.`,
         `Fontes: ${r.fontes.map(f => `${f.origem} (${f.ausente ? 'ausente' : f.ok ? 'ok' : 'FALHA'})`).join('; ')}`,
-        `Total: ${r.total}; sem thread: ${r.semThread}; ambíguas: ${r.ambiguas}; consulta: ${r.ok ? 'válida' : 'INCOMPLETA'}.`,
+        `Total: ${r.total}; sem thread: ${r.semThread}; ambíguas: ${r.ambiguas}; fantasmas: ${r.fantasmas}; consulta: ${r.ok ? 'válida' : 'INCOMPLETA'}.`,
     ];
+    // RM-056 (D4): a coluna PERFIL e o id do perfil (`processo` sem perfil), nunca o diretorio da conta.
     if (r.sessoes.length)
-        linhas.push((0, util_1.tabela)(['ID', 'RUNTIME', 'ESTADO', 'THREAD/FASE'], r.sessoes.map(s => [s.sessionId, s.runtime, s.state ?? s.status ?? 'unknown',
+        linhas.push((0, util_1.tabela)(['ID', 'RUNTIME', 'PERFIL', 'ESTADO', 'THREAD/FASE'], r.sessoes.map(s => [s.sessionId, s.runtime, s.perfil ?? 'processo',
+            `${s.state ?? s.status ?? 'unknown'}${s.fantasma ? ' (fantasma)' : ''}`,
             s.vinculos.map(v => `${v.thread}/${v.fase}`).join(', ') || '(fora do ork)'])));
+    if (r.fantasmas > 0)
+        linhas.push('Fantasma: registro sem processo vivo, não ocupa vaga; `ork sessions limpar-fantasmas` solta o vínculo do ork sem tocar no runtime.');
     for (const f of r.fontes.filter(f => !f.ok))
         linhas.push(`Falha: ${f.detalhe}`);
     // Fatia 2 do ensaio da 0.5.0 (P1): a fonte ausente nao e falha, mas diz o que falta e como ter.
@@ -120,3 +130,74 @@ function comandoDeAttach(chave, raiz) {
     const { sessao, perfil, configDir } = l.achada;
     return { texto: adapter.comandoAttach(sessao.sessionId, perfil ? configDir : null), codigo: 0 };
 }
+const ENCERRAM_A_SESSAO = ['phase_result', 'sessao_morta', 'session_superseded'];
+/**
+ * RM-056 (D6): solta o vinculo do `ork` com cada sessao fantasma (sem pid e sem processo) deste
+ * projeto, gravando `sessao_morta` no ledger da thread: e o evento que libera a conducao
+ * (`fimDaSessao`) e a vaga. Nunca chama o runtime: o registro no `claude agents` fica onde esta.
+ */
+function limparFantasmas(raiz, opcoes = {}) {
+    const canonica = (0, estado_thread_1.raizDoEstado)(raiz);
+    const inv = (0, sessoes_inventario_1.inventariarSessoes)(canonica, { global: true });
+    const itens = [];
+    for (const s of inv.sessoes.filter(x => x.fantasma)) {
+        // Fechamento (RM-056, ao fechar): so os vinculos da thread que fecha; o resto fica como estava.
+        const vinculos = opcoes.thread ? s.vinculos.filter(v => v.thread === opcoes.thread && v.raiz === canonica) : s.vinculos;
+        if (opcoes.thread && vinculos.length === 0)
+            continue;
+        if (vinculos.length === 0) {
+            itens.push({ sessionId: s.sessionId, perfil: s.perfil, thread: null, fase: null, acao: 'sem-thread' });
+            continue;
+        }
+        for (const v of vinculos) {
+            const base = { sessionId: s.sessionId, perfil: s.perfil, thread: v.thread, fase: v.fase };
+            if (v.raiz !== canonica) {
+                itens.push({ ...base, acao: 'outro-projeto' });
+                continue;
+            }
+            const dir = (0, thread_1.dirThread)(canonica, v.thread);
+            if ((0, ledger_1.lerLedger)(dir).some(e => ENCERRAM_A_SESSAO.includes(e.tipo) && e.sessionId === s.sessionId)) {
+                itens.push({ ...base, acao: 'ja-solto' });
+                continue;
+            }
+            if (!opcoes.dryRun)
+                (0, ledger_1.registrar)(dir, v.thread, 'sessao_morta', {
+                    fase: v.fase, sessionId: s.sessionId, runtime: s.runtime, ...(s.perfil ? { perfilId: s.perfil } : {}),
+                    origem: opcoes.origem ?? 'sessions.limpar-fantasmas', estadoNoRuntime: s.state ?? s.status ?? null,
+                    evidencia: 'claude agents lista a sessao sem pid ou com pid sem processo (fantasma, RM-056 D5)',
+                    razao: 'solta o vinculo do ork (conducao e vaga) sem tocar no runtime: claude stop e claude rm nao acham o job',
+                });
+            itens.push({ ...base, acao: 'solto' });
+        }
+    }
+    return { ok: inv.ok, dryRun: opcoes.dryRun === true, itens, falhas: inv.fontes.filter(f => !f.ok).map(f => `${f.origem}: ${f.detalhe}`) };
+}
+/**
+ * RM-056 (ao fechar): as sessoes registradas na thread que o ledger dela ainda nao encerra. E o filtro
+ * barato do fechamento: so com alguma delas o `liberarAoFechar` consulta o inventario (o `claude agents`
+ * de cada conta). Sessao sem fim pode estar viva; quem decide se e fantasma e o inventario.
+ */
+function sessoesSemFim(raiz, threadId) {
+    const canonica = (0, estado_thread_1.raizDoEstado)(raiz);
+    const t = (0, thread_1.lerThread)(canonica, threadId);
+    const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(canonica, threadId));
+    const encerradas = new Set(eventos.filter(e => ENCERRAM_A_SESSAO.includes(e.tipo)).map(e => String(e.sessionId ?? '')));
+    const ids = (Array.isArray(t.sessoes) ? t.sessoes : []).map(s => s?.sessionId).filter((id) => typeof id === 'string');
+    return [...new Set(ids)].filter(id => !encerradas.has(id));
+}
+function textoDaLimpeza(r) {
+    if (r.itens.length === 0)
+        return `Nenhuma sessão fantasma${r.ok ? '' : ' nas contas que responderam'}.` +
+            r.falhas.map(f => `\nFalha: ${f}`).join('');
+    const verbo = {
+        solto: r.dryRun ? 'soltaria (sessao_morta no ledger)' : 'solto: sessao_morta no ledger',
+        'ja-solto': 'já encerrada no ledger', 'sem-thread': 'fora do ork: nada a soltar',
+        'outro-projeto': 'vínculo de outro projeto: rode lá',
+    };
+    return [
+        `Sessões fantasma (sem pid e sem processo)${r.dryRun ? ', ensaio: nada foi gravado' : ''}. O runtime não foi tocado.`,
+        (0, util_1.tabela)(['ID', 'PERFIL', 'THREAD/FASE', 'AÇÃO'], r.itens.map(i => [i.sessionId, i.perfil ?? 'processo',
+            i.thread ? `${i.thread}/${i.fase}` : '-', verbo[i.acao]])),
+        ...r.falhas.map(f => `Falha: ${f}`),
+    ].join('\n');
+}

package/dist/ship.js

@@ -50,6 +50,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.commitQueIncorporou = commitQueIncorporou;
 exports.autorizacaoDePush = autorizacaoDePush;
 exports.arvoreComBranch = arvoreComBranch;
 exports.prepararArvore = prepararArvore;
@@ -62,6 +63,7 @@ exports.ship = ship;
 exports.textoDoShip = textoDoShip;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
 const gates_1 = require("./gates");
 const leases_1 = require("./leases");
 const ledger_1 = require("./ledger");
@@ -76,6 +78,45 @@ const contrato_publico_1 = require("./contrato-publico");
 const prova_minima_1 = require("./prova-minima");
 const horario_1 = require("./horario");
 const fabrica_publicar_1 = require("./fabrica-publicar");
+const branch_de_estado_1 = require("./branch-de-estado");
+/**
+ * RM-037 (fatia 5, A1): o commit de primeiro pai da base que incorporou o `shaDe`: o merge que trouxe a branch, ou
+ * o proprio `shaDe` quando a base avancou por fast-forward ate ele. Com a branch ja incorporada, a ponta da base e
+ * outra coisa: no `ship_done` da ork-docsusuarios (27/09/2026), o unico do `ork ship` com `jaIncorporado` nos ledgers
+ * deste projeto, ela era o merge de outra thread. O que trouxe a branch e o commit mais velho do primeiro pai da base
+ * que descende do `shaDe`. GO-FIX (rodada 1 do CHECK): `--first-parent` junto com `--ancestry-path` so propaga a
+ * descendencia pelos commits de primeiro pai, e o merge do PR que recebeu "Update branch" no GitHub (o pai dele e um
+ * merge que descende do `shaDe`, nao o `shaDe`) sumia da lista; agora sao duas listas e a intersecao. `null` quando o
+ * git nao responde.
+ */
+function commitQueIncorporou(raiz, shaDe, ponta, passos = []) {
+    if (shaDe === ponta)
+        return shaDe;
+    // `passos` recebe os comandos que de fato rodaram, na ordem: e a evidencia do ship (sugestao da conferencia da rodada 2).
+    const curto = (sha) => sha.slice(0, 8);
+    // As listas crescem com o historico entre a branch e a ponta: o buffer vai alem do 1 MiB padrao do spawnSync.
+    const listar = (args) => {
+        passos.push(`git ${args.map((a) => a.replace(/^([0-9a-f]{40,64})\.\.([0-9a-f]{40,64})$/, (_, x, y) => `${curto(x)}..${curto(y)}`)).join(' ')}`);
+        const r = (0, node_child_process_1.spawnSync)('git', args, { cwd: raiz, encoding: 'utf8', timeout: 120000, maxBuffer: 256 * 1024 * 1024 });
+        return r.status === 0 && !r.error ? r.stdout.split('\n').filter((l) => /^[0-9a-f]{40,64}$/.test(l)) : null;
+    };
+    const primeiroPai = listar(['rev-list', '--first-parent', `${shaDe}..${ponta}`]);
+    const descendentes = listar(['rev-list', '--ancestry-path', `${shaDe}..${ponta}`]);
+    if (!primeiroPai || !descendentes)
+        return null;
+    const doShaDe = new Set(descendentes);
+    // Do mais velho para o mais novo: o primeiro de primeiro pai que descende do `shaDe`.
+    const maisVelho = [...primeiroPai].reverse().find((c) => doShaDe.has(c));
+    if (!maisVelho)
+        return null;
+    // O primeiro pai dele e o proprio `shaDe`: a branch ja estava no primeiro pai da base (fast-forward). Sem a resposta
+    // do git, nada e gravado: devolver o mais velho poria no `mergeSha` o filho do `shaDe` (sugestao da rodada 2).
+    passos.push(`git rev-parse ${curto(maisVelho)}^1`);
+    const pai = (0, util_1.exec)('git', ['rev-parse', `${maisVelho}^1`], raiz);
+    if (!pai.ok)
+        return null;
+    return pai.stdout.trim() === shaDe ? shaDe : maisVelho;
+}
 /** Os caminhos de contrato publico que a entrega traz sobre a base (diff desde o merge-base). */
 function contratosDaEntrega(raiz, shaPara, shaDe) {
     const base = (0, util_1.exec)('git', ['merge-base', shaPara, shaDe], raiz);
@@ -185,7 +226,7 @@ function prepararArvore(raiz, para) {
     }
     const dir = dirTemporarioDeShip(raiz, para);
     fs.mkdirSync(path.dirname(dir), { recursive: true });
-    const r = (0, util_1.exec)('git', ['worktree', 'add', dir, para], raiz);
+    const r = (0, util_1.exec)('git', ['worktree', 'add', '--', dir, para], raiz);
     if (!r.ok) {
         throw new Error(`nao foi possivel montar a arvore de merge de "${para}": ${(r.stderr || r.stdout).trim()}`);
     }
@@ -211,7 +252,8 @@ function shaDaRef(dir, ref) {
  * codigo de saida do `git push` nao prova que o remoto ficou com o commit certo.
  */
 function shaNoRemoto(dir, remoto, branch) {
-    const r = (0, util_1.exec)('git', ['ls-remote', remoto, `refs/heads/${branch}`], dir, 120000);
+    // RM-047: so nome de remoto chega ao git, e depois do `--` (nunca vira opcao nem transporte).
+    const r = (0, util_1.exec)('git', ['ls-remote', '--', (0, branch_de_estado_1.exigirRemoto)(remoto, 'ship'), `refs/heads/${branch}`], dir, 120000);
     if (!r.ok)
         return null;
     const linha = r.stdout.split('\n').find((l) => l.trim() !== '');
@@ -222,7 +264,7 @@ function shaNoRemoto(dir, remoto, branch) {
 }
 /** O remoto esta configurado neste repositorio? */
 function remotoConfigurado(dir, remoto) {
-    return (0, util_1.exec)('git', ['remote', 'get-url', remoto], dir).ok;
+    return (0, util_1.exec)('git', ['remote', 'get-url', '--', (0, branch_de_estado_1.exigirRemoto)(remoto, 'ship')], dir).ok;
 }
 function baseDoResultado(thread, de, opcoes) {
     return {
@@ -237,6 +279,7 @@ function baseDoResultado(thread, de, opcoes) {
         shaDe: '',
         shaParaAntes: '',
         mergeSha: null,
+        pontaDaBase: null,
         jaIncorporado: false,
         remoto: opcoes.remoto ?? 'origin',
         shaRemoto: null,
@@ -329,7 +372,10 @@ function ship(carregado, threadId, opcoes) {
     const dir = (0, thread_1.dirThread)(raiz, threadId);
     const de = opcoes.de ?? thread.base.branch;
     const para = opcoes.para;
-    const remoto = opcoes.remoto ?? 'origin';
+    // RM-047: o `--remoto` vem da linha de comando. Antes de qualquer git (inclusive a leitura da reversao),
+    // so nome de remoto passa; o resto recusa com `ship.remoto-invalido`, e o ship nao entrega sem push provado
+    // por um remoto que nunca existiu.
+    const remoto = (0, branch_de_estado_1.exigirRemoto)(opcoes.remoto ?? 'origin', 'ship');
     const r = baseDoResultado(thread, de, opcoes);
     // I-43 (T7): antes de qualquer coisa, se a entrega ANTERIOR desta thread foi
     // revertida na base, isso vira `rollback_done`. E o insumo de maior peso do indice
@@ -449,7 +495,7 @@ function ship(carregado, threadId, opcoes) {
     }
     // 4. Lease `main-tree`: so uma thread mergeia por vez.
     if (r.dryRun) {
-        const ocupado = (0, leases_1.lerLease)(raiz, leases_1.LEASE_MAIN_TREE);
+        const ocupado = (0, leases_1.leasesColidentes)(raiz, leases_1.LEASE_MAIN_TREE)[0] ?? null;
         r.leaseOcupadoPor = ocupado;
         // O ensaio tambem responde ONDE o merge aconteceria e se aquela arvore esta limpa:
         // descobrir isso so na hora do merge real seria descobrir tarde demais.
@@ -458,11 +504,17 @@ function ship(carregado, threadId, opcoes) {
             ? `${dona} (arvore que tem ${para} em check-out; ${temAlteracaoNaoCommitada(dona) ? 'SUJA, o ship reprovaria com tree.blocked' : 'limpa'})`
             : `worktree temporaria em ${path.join((0, manifest_1.dirEstado)(raiz), 'tmp')} (ninguem tem ${para} em check-out)`;
         r.detalhe = `arvore de merge: ${arvoreDoMerge}`;
+        // Ensaio de 03/10 (R5): sem remoto (ou com --sem-push), o ensaio diz o mesmo que o ship real, e nao
+        // promete um push e uma prova que nao vao acontecer.
+        const semPushNoReal = opcoes.semPush ? 'push nao executado por --sem-push (merge local concluido)'
+            : !remotoConfigurado(raiz, remoto) ? `remoto "${remoto}" nao configurado: merge local concluido, sem push a provar` : null;
         r.passos = [
             `arvore de merge: ${arvoreDoMerge}`,
             `git merge --no-ff ${de} -m "<mensagem de ship>"`,
-            `git push ${remoto} ${para}`,
-            `git ls-remote ${remoto} refs/heads/${para}   (prova do push)`,
+            ...(semPushNoReal ? [`sem push: ${semPushNoReal}`] : [
+                `git push ${remoto} ${para}`,
+                `git ls-remote ${remoto} refs/heads/${para}   (prova do push)`,
+            ]),
         ];
         (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.shipIniciado, {
             de,
@@ -493,11 +545,11 @@ function ship(carregado, threadId, opcoes) {
             posicao: aquisicao.posicaoNaFila,
             naFrente: (0, leases_1.esperandoPor)(raiz, leases_1.LEASE_MAIN_TREE).length,
             bloqueadaPor: dono?.thread ?? '(desconhecida)',
-            motivo: 'lease.busy',
+            motivo: aquisicao.motivo ?? 'lease.busy',
         });
-        return bloquear('lease.busy', `lease ${leases_1.LEASE_MAIN_TREE} esta com a thread ${dono?.thread ?? '(desconhecida)'} ` +
+        return bloquear(aquisicao.motivo ?? 'lease.busy', aquisicao.falhaRetomada ? aquisicao.detalhe : `lease ${leases_1.LEASE_MAIN_TREE} esta com a thread ${dono?.thread ?? '(desconhecida)'} ` +
             `desde ${dono?.adquiridoEm ?? '?'} (${dono?.motivo ?? 'sem motivo'}); ` +
-            `esta thread entrou na merge queue na posicao ${aquisicao.posicaoNaFila}`, `espere a vez na fila (ork lease list), ou libere com: ork lease release ${leases_1.LEASE_MAIN_TREE} --forcar`);
+            `esta thread entrou na merge queue na posicao ${aquisicao.posicaoNaFila}`, aquisicao.correcao);
     }
     r.lease = aquisicao.lease;
     (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.leaseAdquirido, {
@@ -532,6 +584,9 @@ function ship(carregado, threadId, opcoes) {
         const jaIncorporado = (0, util_1.exec)('git', ['merge-base', '--is-ancestor', shaDe, shaPara], raiz).ok;
         r.jaIncorporado = jaIncorporado;
         let mergeSha = shaPara;
+        // RM-037 (fatia 5, A1): a ponta que o push prova. Com o merge feito aqui, e ele; com a branch ja incorporada, a
+        // ponta de antes, que pode trazer outros merges depois do que entregou esta thread.
+        let pontaDaBase = shaPara;
         if (!jaIncorporado) {
             const mensagem = opcoes.mensagem ??
                 `ship(${threadId}): merge de ${de} em ${para}\n\n` +
@@ -539,7 +594,8 @@ function ship(carregado, threadId, opcoes) {
                     `modo: ${(0, modos_1.tagDoModo)(thread.modo)}\n` +
                     `autorizado por: ${autorizacao.por} (${autorizacao.tipo})\n` +
                     `verificado em: HEAD ${verificacao.commit}\n`;
-            const merge = (0, util_1.exec)('git', ['merge', '--no-ff', de, '-m', mensagem], arvore.dir, 300000);
+            // RM-047: o merge e do sha verificado, e nao do nome que veio de `--de` (nome nunca vira opcao do git).
+            const merge = (0, util_1.exec)('git', ['merge', '--no-ff', '-m', mensagem, shaDe], arvore.dir, 300000);
             passos.push(`git merge --no-ff ${de}`);
             if (!merge.ok) {
                 (0, util_1.exec)('git', ['merge', '--abort'], arvore.dir);
@@ -551,6 +607,7 @@ function ship(carregado, threadId, opcoes) {
                 return bloquear('artifact.missing', 'nao foi possivel ler o HEAD apos o merge', 'confira o repositorio');
             }
             mergeSha = novo;
+            pontaDaBase = novo;
             // Verificacao independente do merge: a origem precisa ser ancestral do resultado.
             const incorporou = (0, util_1.exec)('git', ['merge-base', '--is-ancestor', shaDe, mergeSha], arvore.dir).ok;
             passos.push(`git merge-base --is-ancestor ${shaDe.slice(0, 8)} ${mergeSha.slice(0, 8)}`);
@@ -559,9 +616,16 @@ function ship(carregado, threadId, opcoes) {
             }
         }
         else {
-            passos.push(`(nada a mergear: ${de} ja e ancestral de ${para})`);
+            // RM-037 (fatia 5, A1): o merge que trouxe a branch, e nao a ponta da base.
+            const incorporadoEm = commitQueIncorporou(raiz, shaDe, shaPara, passos);
+            if (!incorporadoEm) {
+                return bloquear('artifact.missing', `${de} ja e ancestral de ${para}, mas o git nao achou o commit de primeiro pai que o incorporou`, 'confira o repositorio: o ship_done precisa do merge que entregou a thread');
+            }
+            mergeSha = incorporadoEm;
+            passos.push(`(nada a mergear: ${de} ja e ancestral de ${para}, incorporado em ${mergeSha.slice(0, 8)})`);
         }
         r.mergeSha = mergeSha;
+        r.pontaDaBase = pontaDaBase;
         opcoes.revalidarGit?.('push', arvore.dir);
         // 6. Push PROVADO por ls-remote.
         const temRemoto = remotoConfigurado(arvore.dir, remoto);
@@ -575,8 +639,8 @@ function ship(carregado, threadId, opcoes) {
         else {
             const existeNoRemoto = shaNoRemoto(arvore.dir, remoto, para) !== null;
             const argsPush = existeNoRemoto
-                ? ['push', remoto, `${para}:refs/heads/${para}`]
-                : ['push', '-u', remoto, `${para}:refs/heads/${para}`];
+                ? ['push', '--', remoto, `refs/heads/${para}:refs/heads/${para}`]
+                : ['push', '-u', '--', remoto, `refs/heads/${para}:refs/heads/${para}`];
             const push = (0, util_1.exec)('git', argsPush, arvore.dir, 300000);
             passos.push(`git ${argsPush.join(' ')}`);
             if (!push.ok) {
@@ -587,10 +651,10 @@ function ship(carregado, threadId, opcoes) {
             const shaRemoto = shaNoRemoto(arvore.dir, remoto, para);
             passos.push(`git ls-remote ${remoto} refs/heads/${para}`);
             r.shaRemoto = shaRemoto;
-            r.pushVerificado = shaRemoto !== null && shaRemoto === mergeSha;
+            r.pushVerificado = shaRemoto !== null && shaRemoto === pontaDaBase;
             if (!r.pushVerificado) {
                 r.passos = passos;
-                return bloquear('runtime.unavailable', `ls-remote devolveu ${shaRemoto ?? '(nada)'} e o destino local esta em ${mergeSha}: ` +
+                return bloquear('runtime.unavailable', `ls-remote devolveu ${shaRemoto ?? '(nada)'} e o destino local esta em ${pontaDaBase}: ` +
                     'o push nao ficou provado', 'rode o ship de novo e confira o remoto');
             }
         }
@@ -609,6 +673,8 @@ function ship(carregado, threadId, opcoes) {
             shaDe,
             shaParaAntes: shaPara,
             mergeSha,
+            // RM-037 (fatia 5, A1): a ponta da base vai em campo proprio; o `mergeSha` e o merge que entregou a thread.
+            pontaDaBase,
             jaIncorporado,
             remoto: r.remoto,
             shaRemoto: r.shaRemoto,
@@ -676,7 +742,7 @@ function textoDoShip(r) {
             `${v.comandos.filter((c) => c.ok).length}/${v.comandos.length} comandos)`);
     }
     if (r.ci) {
-        linhas.push(`  ci             ${r.ci.required ? `${r.ci.state.toUpperCase()} ${r.ci.context} em ${r.ci.sha.slice(0, 8)}` : 'não exigido'}`);
+        linhas.push(`  ci            ${r.ci.required ? `${r.ci.state.toUpperCase()} ${r.ci.context} em ${r.ci.sha.slice(0, 8)}` : 'não exigido'}`);
     }
     linhas.push(...(0, policies_1.linhasDeAviso)(r.violacoes ?? []));
     if (r.leaseOcupadoPor) {
@@ -705,11 +771,11 @@ function textoDoShip(r) {
     }
     linhas.push('');
     linhas.push(r.jaIncorporado
-        ? `Nada a mergear: ${r.de} ja estava em ${r.para}.`
+        ? `Nada a mergear: ${r.de} ja estava em ${r.para}, incorporado em ${r.mergeSha}.`
         : `Merge --no-ff concluido: ${r.mergeSha}`);
     if (r.pushVerificado) {
         linhas.push(`Push PROVADO: ls-remote de ${r.remoto}/${r.para} devolveu ${r.shaRemoto}`);
-        linhas.push(`  e o destino local esta no mesmo sha: ${r.mergeSha}`);
+        linhas.push(`  e o destino local esta no mesmo sha: ${r.pontaDaBase ?? r.mergeSha}`);
     }
     else {
         linhas.push(`Push nao provado: ${local(r.detalhe) || 'sem remoto configurado'}`);