@orkastery/cli 0.5.0 → 0.5.1

package/dist/roadmap-status.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TETO_DO_FECHO = exports.GRUPO_DO_CICLO = exports.GRUPOS_DO_ROADMAP = exports.CONTRATO_STATUS_DO_ROADMAP = void 0;
 exports.esperaDoDono = esperaDoDono;
 exports.fatosLocais = fatosLocais;
+exports.batidaDaFabrica = batidaDaFabrica;
 exports.montarStatusDoRoadmap = montarStatusDoRoadmap;
 exports.montarStatusDeFatos = montarStatusDeFatos;
 exports.textoDoStatusDoRoadmap = textoDoStatusDoRoadmap;
@@ -34,6 +35,12 @@ const hitl_gates_1 = require("./hitl-gates");
 const hitl_classificacao_1 = require("./hitl-classificacao");
 const horario_1 = require("./horario");
 const projeto_alvo_1 = require("./projeto-alvo");
+const fabrica_estado_1 = require("./fabrica-estado");
+const hitl_resumo_1 = require("./hitl-resumo");
+const manifest_1 = require("./manifest");
+const maquina_1 = require("./maquina");
+const parado_no_condutor_1 = require("./parado-no-condutor");
+const util_1 = require("./util");
 exports.CONTRATO_STATUS_DO_ROADMAP = 'ork.roadmap-status/v1';
 /** Os grupos, na ordem e com os icones que o dono aprovou. */
 exports.GRUPOS_DO_ROADMAP = Object.freeze([
@@ -79,7 +86,9 @@ function esperaDoDono(raiz, t, quando) {
     const escalacoes = [...new Set(eventos.filter(e => e.tipo === 'gate_blocked' && e.fase === t.faseAtual &&
             hitl_gates_1.MOTIVOS_DE_ESCALACAO_HUMANA.includes(String(e.motivo)) && (0, hitl_classificacao_1.quemDecide)(String(e.motivo)) === 'dono')
             .map(e => String(e.motivo)))];
-    for (const motivo of ['human.pending', ...escalacoes]) {
+    // RM-037 (fatia 4): o fim de turno sem pergunta e do condutor, nunca "O que precisa de voce".
+    const doCondutor = (0, parado_no_condutor_1.esperaDoCondutor)(t, eventos, quando) !== null;
+    for (const motivo of [...(doCondutor ? [] : ['human.pending']), ...escalacoes]) {
         try {
             const preparado = (0, hitl_gates_1.prepararPedidoGate)(raiz, t.id, motivo, quando);
             const pedido = 'aberto' in preparado ? preparado.aberto : preparado.novo;
@@ -114,6 +123,25 @@ function esperaDoDono(raiz, t, quando) {
 function fatosLocais(raiz, quando, fuso) {
     const hoje = (0, horario_1.dataLocal)(quando, fuso);
     const fatos = [];
+    // RM-037 (fatia 4): o estado das entregas sai uma vez, sob demanda, do git local e do retrato de PRs do pulse.
+    let entregas;
+    const lerEntregas = () => {
+        if (entregas !== undefined)
+            return entregas;
+        try {
+            const retrato = (0, parado_no_condutor_1.lerRetratoDePrs)(raiz);
+            entregas = (0, parado_no_condutor_1.entregasDoProjeto)((0, manifest_1.exigirManifesto)(raiz), { quando, lerPrs: () => (retrato ? { ok: true, retrato } : null) });
+        }
+        catch {
+            entregas = null;
+        }
+        return entregas;
+    };
+    // A leitura que falhou e dita, e nao vira o "sigo" de sempre.
+    const entrega = (id) => {
+        const lidas = lerEntregas();
+        return lidas ? entregaNoStatus(lidas.estados.find(e => e.thread === id)) : { estado: 'estado da entrega não lido' };
+    };
     for (const id of (0, thread_1.listarIds)(raiz)) {
         let t;
         try {
@@ -126,14 +154,75 @@ function fatosLocais(raiz, quando, fuso) {
             id: t.id, roadmap: t.roadmap ?? null, aberta: t.status !== 'fechada', fase: t.faseAtual,
             entregueHoje: () => (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, t.id)).some(e => e.tipo === 'ship_done' && (0, horario_1.dataLocal)(e.ts, fuso) === hoje),
             espera: () => esperaDoDono(raiz, t, quando),
+            entrega: () => (t.status === 'fechada' ? undefined : entrega(t.id)),
         });
     }
     return fatos;
 }
+/** O estado da entrega como o status o diz: so quando ha o que dizer. */
+function entregaNoStatus(e) {
+    if (!e || (!e.resumo && !e.parado))
+        return undefined;
+    return { estado: e.resumo, ...(e.conduzidaAgora ? { conduzida: true } : {}),
+        ...(e.parado ? { parado: { desdeEm: e.parado.desdeEm, proximoPasso: e.parado.proximoPasso,
+                ...(e.parado.prLidoEm ? { prLidoEm: e.parado.prLidoEm } : {}) } } : {}),
+        ...(e.prLidoEm ? { prLidoEm: e.prLidoEm } : {}) };
+}
+/**
+ * RM-037 (fatia 4, D8): as outras maquinas da fabrica sem batida alem do limiar da rede, lidas da copia
+ * local de `ork/fabrica-estado`, sem fetch. Sem fabrica compartilhada, nada; sem copia local, "nao lido".
+ */
+function batidaDaFabrica(carregado, quando) {
+    if (!(0, maquina_1.fabricaCompartilhada)(carregado.manifesto))
+        return undefined;
+    // Sem rede escondida: num clone parcial, o `git show` dos retratos buscaria o objeto no remoto. O git anterior
+    // a 2.45 ignora o GIT_NO_LAZY_FETCH, entao o clone parcial nem e lido aqui (N4 da seguranca, rodada 2).
+    // N4 da seguranca (rodada 3): o git novo registra o clone parcial no `remote.<r>.promisor`, o velho no `extensions`.
+    if ((0, util_1.exec)('git', ['config', '--get-regexp', '^(extensions\\.partialclone|remote\\..+\\.promisor)$'], carregado.raiz).stdout.trim()) {
+        return { lido: false, motivo: `clone parcial: a cópia local de ${fabrica_estado_1.BRANCH_DA_FABRICA} não é lida sem rede`, semBatida: [] };
+    }
+    const antes = process.env.GIT_NO_LAZY_FETCH;
+    process.env.GIT_NO_LAZY_FETCH = '1';
+    let painel;
+    try {
+        painel = (0, fabrica_estado_1.lerFabrica)(carregado.raiz, { remoto: carregado.manifesto.fabrica.remoto, semRemoto: true });
+    }
+    catch {
+        return { lido: false, motivo: `a cópia local de ${fabrica_estado_1.BRANCH_DA_FABRICA} está ilegível`, semBatida: [] };
+    }
+    finally {
+        if (antes === undefined)
+            delete process.env.GIT_NO_LAZY_FETCH;
+        else
+            process.env.GIT_NO_LAZY_FETCH = antes;
+    }
+    if (!painel.ponta)
+        return { lido: false, semBatida: [] };
+    const eu = (0, maquina_1.nomeDaMaquina)(), agora = Date.parse(quando);
+    // A copia so diz quem esta sem batida quando esta maquina publicou nela ha pouco: e o fetch daqui que a atualiza.
+    const { publicadoEm: minha } = painel.maquinas.find(m => m.maquina === eu) ?? { publicadoEm: null };
+    if (!minha || !(agora - Date.parse(minha) <= fabrica_estado_1.LIMIAR_SEM_BATIDA_MS)) {
+        return { lido: true, copiaVelha: { ultimoDestaMaquina: minha }, semBatida: [] };
+    }
+    const semBatida = painel.maquinas.filter(m => m.maquina !== eu).map(m => {
+        const { publicadoEm: publicado } = m;
+        return { maquina: m.maquina, publicadoEm: publicado, idadeMs: agora - Date.parse(publicado) };
+    }).filter(m => Number.isFinite(m.idadeMs) && m.idadeMs > fabrica_estado_1.LIMIAR_SEM_BATIDA_MS)
+        .map(m => ({ maquina: m.maquina, publicadoEm: m.publicadoEm, idadeMin: Math.floor(m.idadeMs / 60000) }));
+    return { lido: true, semBatida };
+}
 /** Monta o relatorio. Leitura pura: nada e escrito, nenhum pedido e aberto. */
 function montarStatusDoRoadmap(raiz, opcoes = {}) {
     const quando = opcoes.quando ?? new Date().toISOString();
-    return montarStatusDeFatos((0, docs_1.carregarDocs)(raiz).docs, fatosLocais(raiz, quando), { quando, projeto: opcoes.projeto, consulta: opcoes.consulta });
+    let fabrica;
+    try {
+        fabrica = batidaDaFabrica((0, manifest_1.exigirManifesto)(raiz), quando);
+    }
+    catch {
+        fabrica = undefined;
+    }
+    return montarStatusDeFatos((0, docs_1.carregarDocs)(raiz).docs, fatosLocais(raiz, quando), { quando, projeto: opcoes.projeto, consulta: opcoes.consulta,
+        ...(fabrica ? { fabrica } : {}) });
 }
 /** O relatorio a partir das paginas do roadmap e dos fatos das threads, de onde quer que venham. */
 function montarStatusDeFatos(docs, fatos, opcoes) {
@@ -157,7 +246,10 @@ function montarStatusDeFatos(docs, fatos, opcoes) {
             if (hitl)
                 break;
         }
-        const conduz = abertas[0];
+        // RM-037 (fatia 4): a thread que diz o estado real vem primeiro: a parada no condutor, depois a entrega em curso.
+        const entregas = new Map(abertas.map(f => [f.id, f.entrega?.()]));
+        const conduz = abertas.find(f => entregas.get(f.id)?.parado) ?? abertas.find(f => entregas.get(f.id)?.estado) ?? abertas[0];
+        const entrega = conduz ? entregas.get(conduz.id) : undefined;
         const emAberto = exports.GRUPO_DO_CICLO[ciclo] === 'disponiveis' ? [
             ...(texto(estado.exposicao) && texto(estado.exposicao) !== 'Geral' ? [`exposição ${texto(estado.exposicao)}`] : []),
             ...(texto(estado.habilitacao) && texto(estado.habilitacao) !== 'Concluída' ? [`habilitação ${texto(estado.habilitacao)}`] : []),
@@ -166,7 +258,8 @@ function montarStatusDeFatos(docs, fatos, opcoes) {
             id: d.id, titulo: nomeCurto(texto(d.dados.titulo) || d.id), ciclo,
             grupo: entregueHoje ? 'hoje' : exports.GRUPO_DO_CICLO[ciclo] ?? 'proposto',
             emAberto, threads: ligadas,
-            ...(conduz ? { conduzindo: { thread: conduz.id, fase: conduz.fase, ...(conduz.maquina ? { maquina: conduz.maquina } : {}) } } : {}),
+            ...(conduz ? { conduzindo: { thread: conduz.id, fase: conduz.fase, ...(conduz.maquina ? { maquina: conduz.maquina } : {}),
+                    ...(entrega ? { entrega } : {}) } } : {}),
             ...(hitl ? { hitl } : {}),
         });
     }
@@ -177,17 +270,57 @@ function montarStatusDeFatos(docs, fatos, opcoes) {
         precisaDeVoce: itens.filter(i => i.hitl).map(i => ({ item: i.id, espera: i.hitl })),
         emSeguida: itens.filter(i => i.conduzindo && !i.hitl).map(i => ({ item: i.id, ...i.conduzindo })),
         ...(opcoes.consulta ? { consulta: opcoes.consulta } : {}),
+        ...(opcoes.fabrica ? { fabrica: opcoes.fabrica } : {}),
     };
 }
 /** "orkastery" vira "Orkastery": o titulo diz o nome do projeto como gente escreve. */
 const capitalizar = (s) => s ? s[0].toUpperCase() + s.slice(1) : s;
 /** A maquina entre parenteses, so quando o fato a traz (visao da rede, D7 da RM-054). */
 const naMaquina = (maquina) => maquina ? ` (${maquina})` : '';
+/**
+ * RM-037 (fatia 4): a linha do que vem a seguir diz o estado real. Parada no condutor sai com o desde e o
+ * proximo passo; entrega em curso, com o estado do PR e a hora em que ele foi lido; sem nada disso, a fase.
+ */
+function linhaDoQueVem(x, agora, fuso) {
+    const e = x.entrega;
+    if (e?.parado) {
+        const { prLidoEm: lido } = e.parado;
+        return `• ${x.item}: ${(0, hitl_resumo_1.linhaDoParadoNoCondutor)({ thread: x.thread, ...e.parado }, { agora, fuso })}${naMaquina(x.maquina)}` +
+            `${lido ? ` (PR lido às ${(0, horario_1.formatarHora)(lido, { agora, fuso })})` : ''}.`;
+    }
+    if (e?.estado) {
+        const { prLidoEm: lido } = e;
+        const daLeitura = lido ? ` (PR lido às ${(0, horario_1.formatarHora)(lido, { agora, fuso })})` : '';
+        return e.conduzida ? `• ${x.item}: sigo ${x.thread} na fase ${x.fase}${naMaquina(x.maquina)}; ${e.estado}${daLeitura}.`
+            : `• ${x.item}: ${x.thread} na fase ${x.fase}${naMaquina(x.maquina)}, ${e.estado}${daLeitura}.`;
+    }
+    return `• ${x.item}: sigo ${x.thread} na fase ${x.fase}${naMaquina(x.maquina)}.`;
+}
+/** RM-037 (fatia 4, D8): uma linha so para a fabrica, e so quando ha o que avisar. */
+function linhaDaFabrica(f, agora, fuso) {
+    if (!f)
+        return [];
+    if (!f.lido)
+        return [`Fábrica: não lido (${f.motivo ?? `esta máquina não tem cópia local de ${fabrica_estado_1.BRANCH_DA_FABRICA}`}).`];
+    if (f.copiaVelha) {
+        const { ultimoDestaMaquina: ultimo } = f.copiaVelha;
+        return [`Fábrica: a cópia local de ${fabrica_estado_1.BRANCH_DA_FABRICA} está velha (${ultimo ? `esta máquina publicou nela por último em ` +
+                `${(0, horario_1.formatarDataHora)(ultimo, { agora, fuso })}` : 'esta máquina não aparece nela'}); não dá para dizer quem está sem batida.`];
+    }
+    if (!f.semBatida.length)
+        return [];
+    return [`Fábrica: ${f.semBatida.map(m => `${m.maquina} sem batida há ${(0, horario_1.duracaoCurta)(m.idadeMin)} ` +
+            `(último retrato ${(0, horario_1.formatarDataHora)(m.publicadoEm, { agora, fuso })})`).join('; ')}, pela cópia local de ${fabrica_estado_1.BRANCH_DA_FABRICA}.`];
+}
 /**
  * O texto do relatorio, igual em todo canal: os icones sao parte do formato aprovado. `fuso`: o do
  * projeto consultado, na visao da rede; sem ele, o do dono deste processo.
+ *
+ * Fatia 2 do ensaio da 0.5.0 (P7): a hora do titulo vem com o fuso dito logo abaixo dele, na linha
+ * 2, sem mudar o titulo aprovado. `legenda: false` e para quem ja diz o fuso na mesma mensagem (o
+ * panorama da rede diz no fim).
  */
-function textoDoStatusDoRoadmap(s, fuso) {
+function textoDoStatusDoRoadmap(s, fuso, opcoes = {}) {
     if (s.contrato !== exports.CONTRATO_STATUS_DO_ROADMAP)
         throw new Error('status do roadmap: contrato inválido');
     const p = (0, horario_1.partesLocais)(s.consultadoEm, fuso);
@@ -199,15 +332,17 @@ function textoDoStatusDoRoadmap(s, fuso) {
     const cortar = (lista, f) => [...lista.slice(0, exports.TETO_DO_FECHO).map(f), ...(lista.length > exports.TETO_DO_FECHO ? [`• e mais ${lista.length - exports.TETO_DO_FECHO}`] : [])];
     return [
         `Roadmap do ${capitalizar(s.projeto)} (${p.dia}/${p.mes}, ${p.hora}:${p.minuto})`,
-        // RM-052: logo abaixo do titulo aprovado, qual projeto foi lido e o que nao foi.
+        ...(opcoes.legenda === false ? [] : [(0, horario_1.legendaDoFuso)(fuso, s.consultadoEm)]),
+        // RM-052: logo abaixo do titulo aprovado (e do fuso), qual projeto foi lido e o que nao foi.
         ...(s.consulta ? (0, projeto_alvo_1.linhasDaConsulta)(s.consulta) : []),
+        ...linhaDaFabrica(s.fabrica, s.consultadoEm, fuso),
         ...s.grupos.filter(g => g.itens.length).flatMap(g => ['', `${g.icone} ${g.titulo}`, ...g.itens.map(linhaDoItem)]),
         '', 'O que precisa de você',
         ...(s.precisaDeVoce.length ? cortar(s.precisaDeVoce, x => `• ${x.item}${naMaquina(x.espera.maquina)}: ${x.espera.pergunta}` +
             (x.espera.codigo ? ` Responda ${x.espera.codigo} ${x.espera.recomendada ?? 'a'} (ou outra letra).` : ' A pergunta chega no próximo resumo.'))
             : ['• Nada agora.']),
         '', 'O que eu faço em seguida',
-        ...(s.emSeguida.length ? cortar(s.emSeguida, x => `• ${x.item}: sigo ${x.thread} na fase ${x.fase}${naMaquina(x.maquina)}.`)
+        ...(s.emSeguida.length ? cortar(s.emSeguida, x => linhaDoQueVem(x, s.consultadoEm, fuso))
             : ['• Nada em andamento; sigo o que você priorizar.']),
     ].join('\n');
 }

package/dist/runtime-context.js

@@ -46,6 +46,7 @@ const thread_1 = require("./thread");
 const hosts_1 = require("./hosts");
 const worktree_1 = require("./worktree");
 const mcp_install_1 = require("./mcp-install");
+const mcp_grafo_1 = require("./mcp-grafo");
 const hitl_public_receipt_1 = require("./hitl-public-receipt");
 /** Correlação interna; nenhuma identidade de despacho concede poder de gate. */
 function novaIdentidadeDeDespacho(threadId, fase) {
@@ -207,9 +208,12 @@ function validarContextoRuntime(contexto, cwd) {
         throw Error('runtime.context.installation: catalogo ou plugin incompleto');
     // Capacidade derivada do bloco atual, nunca aceita como entrada do modelo.
     const permiteEditarProduto = permissoesFilho === 'worktree' && (0, thread_1.blocoDaThread)(thread, thread.faseAtual).fases.includes('GO');
+    // RM-031 KG5 (D2, D7): as tools do grafo seguem a flag do manifesto da raiz, que o servidor do filho tambem le;
+    // o manifesto da worktree da thread e o pedido do modelo nao ligam nada.
+    const grafoMcp = (0, mcp_grafo_1.grafoLigado)((0, manifest_1.exigirManifesto)(raiz).manifesto);
     const publicVerifiers = (0, hitl_public_receipt_1.publicHitlVerifiers)();
     const servidor = { ...(0, mcp_install_1.configuracaoServidorMcp)(raiz, contexto.host, contexto.threadId, transporteShip, permissoesFilho, contexto.identidade?.dispatchId),
         ...(publicVerifiers ? { env: { [hitl_public_receipt_1.ENV_HITL_VERIFIERS]: publicVerifiers } } : {}),
         ...(contexto.host === 'codex' && permissoesFilho === 'worktree' ? (0, mcp_install_1.politicasFilhoCodex)(perfil.politicasCodex ?? {}) : {}) };
-    return { projeto: raiz, instalacao, bootstrap, permissoesFilho, permiteEditarProduto, servidor };
+    return { projeto: raiz, instalacao, bootstrap, permissoesFilho, permiteEditarProduto, grafoMcp, servidor };
 }

package/dist/sessoes-inventario.js

@@ -73,8 +73,14 @@ 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 = [
-        { origem: `claude agents --json${opcoes.todas ? ' --all' : ''}`, ok: claude.ok, detalhe: claude.detalhe },
+        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 = [

package/dist/sessoes.js

@@ -51,7 +51,7 @@ const util_1 = require("./util");
 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.ok ? 'ok' : 'FALHA'})`).join('; ')}`,
+        `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'}.`,
     ];
     if (r.sessoes.length)
@@ -59,6 +59,9 @@ function textoDoInventario(r) {
             s.vinculos.map(v => `${v.thread}/${v.fase}`).join(', ') || '(fora do ork)'])));
     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.
+    for (const f of r.fontes.filter(f => f.ausente))
+        linhas.push(`Ausente: ${f.detalhe}${f.correcao ? `; correção: ${f.correcao}` : ''}`);
     return linhas.join('\n');
 }
 function tabelaDeSessoes(raiz, todas = false) {

package/dist/ship.js

@@ -348,6 +348,8 @@ function ship(carregado, threadId, opcoes) {
             correcao,
             de,
             para,
+            // Fatia 2 do ensaio da 0.5.0 (P2): o gate do ensaio e marcado, e os leitores de estado o ignoram.
+            ...(r.dryRun ? { dryRun: true } : {}),
         });
         (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.shipBloqueado, {
             de,
@@ -373,6 +375,26 @@ function ship(carregado, threadId, opcoes) {
     const branchAtrasDaBase = pontaDe && pontaPara && de !== para
         ? !(0, util_1.exec)('git', ['merge-base', '--is-ancestor', pontaPara, pontaDe], raiz).ok
         : undefined;
+    // Fatia 2 do ensaio da 0.5.0 (P9): sem delta (a branch da thread ja esta contida na base) e com a base
+    // local a frente da ref de rastreio do remoto, o push publicaria a base sem merge de thread. A medida e
+    // local, sem rede; sem remoto, sem ref de rastreio ou com --sem-push, o fato nao vem e nada muda.
+    // CHECK, rodada 1 (B1): o merge que o proprio ship ja fez e nao chegou ao remoto (push recusado,
+    // --sem-push, retomada do MCP) tambem deixa a base a frente sem delta, mas leva a ponta da thread como
+    // pai que nao e o primeiro: e entrega de thread, e o retry empurra como antes. Rodada 2 (S-R2-1): so
+    // quando a linha principal da base, alem do remoto, e toda de merge; commit direto nela segue barrado.
+    const rastreio = pontaDe && pontaPara && de !== para && !opcoes.semPush && remotoConfigurado(raiz, remoto)
+        ? shaDaRef(raiz, `refs/remotes/${remoto}/${para}`) : null;
+    const mergeDaThreadNaBase = (desde) => {
+        const diretos = (0, util_1.exec)('git', ['rev-list', '--first-parent', '--no-merges', `${desde}..${pontaPara}`], raiz);
+        return diretos.ok && diretos.stdout.trim() === '' &&
+            (0, util_1.exec)('git', ['rev-list', '--merges', '--parents', `${desde}..${pontaPara}`], raiz).stdout.split('\n')
+                .some((linha) => linha.trim().split(' ').slice(2).includes(pontaDe));
+    };
+    const semDeltaComBaseAFrente = rastreio
+        ? (0, util_1.exec)('git', ['merge-base', '--is-ancestor', pontaDe, pontaPara], raiz).ok &&
+            !(0, util_1.exec)('git', ['merge-base', '--is-ancestor', pontaPara, rastreio], raiz).ok &&
+            !mergeDaThreadNaBase(rastreio)
+        : undefined;
     const violacoes = (0, policies_1.avaliarPolicies)(manifesto, {
         gate: 'ship',
         de,
@@ -380,6 +402,8 @@ function ship(carregado, threadId, opcoes) {
         baseBranch: manifesto.worktree.base_branch,
         threadId,
         branchAtrasDaBase,
+        semDeltaComBaseAFrente,
+        remoto,
     });
     r.violacoes = violacoes;
     if (!r.dryRun) {
@@ -647,7 +671,7 @@ function textoDoShip(r) {
     linhas.push(`                ${local(r.autorizacao.razao)}`);
     if (r.verificacao) {
         const v = r.verificacao;
-        linhas.push(`  verificacao   ${v.ok ? 'passou' : 'REPROVOU'} no HEAD ${v.commit.slice(0, 8)} ` +
+        linhas.push(`  verificacao   ${v.ok ? 'passou' : 'REPROVOU'} no HEAD ${(0, util_1.shaCurto)(v.commit)} ` +
             `(${v.claims.filter((c) => c.verificado).length}/${v.claims.length} claims, ` +
             `${v.comandos.filter((c) => c.ok).length}/${v.comandos.length} comandos)`);
     }

package/dist/thread.js

@@ -45,6 +45,7 @@ exports.caminhoThread = caminhoThread;
 exports.listarIds = listarIds;
 exports.lerThread = lerThread;
 exports.gravarThread = gravarThread;
+exports.avisoDeThreadSemBase = avisoDeThreadSemBase;
 exports.idDisponivel = idDisponivel;
 exports.criarWorktree = criarWorktree;
 exports.novaThread = novaThread;
@@ -113,9 +114,22 @@ function carimbarBase(raiz) {
     const commit = (0, util_1.exec)('git', ['rev-parse', 'HEAD'], raiz);
     return {
         branch: branch.ok ? branch.stdout.trim() : 'desconhecida',
-        commit: commit.ok ? commit.stdout.trim() : 'desconhecido',
+        commit: commit.ok ? commit.stdout.trim() : util_1.COMMIT_DESCONHECIDO,
     };
 }
+/**
+ * Ensaio da 0.5.0: a thread aberta antes do primeiro commit nascia sem base, e nada avisava; o
+ * ship depois nao tem de onde partir. O aviso vai ao stderr e nao muda a saida do comando.
+ */
+function avisoDeThreadSemBase(thread, gravada) {
+    if (thread.base.commit !== util_1.COMMIT_DESCONHECIDO)
+        return null;
+    return gravada
+        ? `Aviso: o repositório ainda não tem commit, e a thread ${thread.id} nasceu sem base: o ship não tem de onde partir. ` +
+            `Faça o primeiro commit, feche esta com ork thread close ${thread.id} --motivo engano --por <quem> ` +
+            '--justificativa "aberta antes do primeiro commit" e abra outra.'
+        : 'Aviso: o repositório ainda não tem commit, e a thread nasceria sem base: faça o primeiro commit antes de abrir a primeira thread.';
+}
 /** Resolve um id livre a partir do assunto normalizado (`<abbrev>-<assunto>`). */
 function idDisponivel(raiz, abbrev, assunto) {
     let candidato = assunto;
@@ -144,6 +158,9 @@ function criarWorktree(carregado, id, slug, opcoes = {}) {
     const base = opcoes.base ?? manifesto.worktree.base_branch;
     const commitBase = (0, util_1.exec)('git', ['rev-parse', '--verify', base], raiz);
     const ref = commitBase.ok ? commitBase.stdout.trim() : 'HEAD';
+    // Fatia 2 do ensaio da 0.5.0 (P3): a pasta das worktrees que o ork cria agora nasce fora do git.
+    const pastaDasWorktrees = path.dirname(dir);
+    const pastaNova = !fs.existsSync(pastaDasWorktrees);
     // Branch nova (`-b`) no caso comum; branch que ja existe no ciclo `merge-branch`.
     const argumentos = opcoes.branchExistente
         ? ['worktree', 'add', dir, opcoes.branchExistente]
@@ -152,6 +169,8 @@ function criarWorktree(carregado, id, slug, opcoes = {}) {
     if (!r.ok) {
         throw new Error(`git worktree add falhou: ${(r.stderr || r.stdout).trim()}`);
     }
+    if (pastaNova)
+        (0, util_1.ignorarPastaNoGit)(pastaDasWorktrees, raiz);
     const lista = (0, util_1.exec)('git', ['worktree', 'list', '--porcelain'], raiz);
     const criada = lista.ok && lista.stdout.split('\n').some((l) => l.trim() === `worktree ${dir}`);
     if (!criada) {
@@ -362,7 +381,7 @@ function resumoDaThread(thread, conducao) {
     linhas.push(`  ciclo     ${thread.variante ?? 'padrao do modo'}`);
     linhas.push(`  fase      ${thread.faseAtual}`);
     linhas.push(`  status    ${thread.status}`);
-    linhas.push(`  base      ${thread.base.branch} @ ${thread.base.commit.slice(0, 8)}`);
+    linhas.push(`  base      ${thread.base.branch} @ ${(0, util_1.shaCurto)(thread.base.commit)}`);
     linhas.push(`  worktree  ${thread.worktree ?? '(raiz do projeto)'}`);
     // I-36 (T17): quem passa a leitura da conducao ve a linha unica; sem ela o resumo fica como era.
     if (conducao !== undefined)

package/dist/util.js

@@ -34,8 +34,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.GITIGNORE_DA_MAQUINA = exports.COMMIT_DESCONHECIDO = void 0;
 exports.exec = exec;
+exports.shaCurto = shaCurto;
+exports.branchDoHead = branchDoHead;
 exports.noPath = noPath;
+exports.ignorarPastaNoGit = ignorarPastaNoGit;
 exports.subirAte = subirAte;
 exports.gravar = gravar;
 exports.lerJson = lerJson;
@@ -66,10 +70,73 @@ function exec(cmd, args, cwd, timeoutMs = 120000, env = process.env) {
         ...(r.error ? { error: r.error.code ?? r.error.message } : {}),
     };
 }
-/** O binario esta no PATH? */
-function noPath(bin) {
-    const r = exec('which', [bin]);
-    return r.ok ? r.stdout.trim() : null;
+/** O commit quando o repositorio ainda nao tem commit (base da thread, HEAD do verify). */
+exports.COMMIT_DESCONHECIDO = 'desconhecido';
+/**
+ * Sha para exibir: 8 caracteres quando o valor e um sha hexadecimal (SHA-1 ou SHA-256); qualquer
+ * outro valor, como o marcador de repositorio sem commit, sai inteiro (o ensaio da 0.5.0 viu "desconhe").
+ */
+function shaCurto(valor) {
+    return /^[0-9a-f]{7,64}$/i.test(valor) ? valor.slice(0, 8) : valor;
+}
+/** A branch para onde o HEAD aponta, com ou sem commit; `null` com o HEAD destacado. */
+function branchDoHead(dir) {
+    const r = exec('git', ['symbolic-ref', '--quiet', '--short', 'HEAD'], dir);
+    return r.ok && r.stdout.trim() ? r.stdout.trim() : null;
+}
+/**
+ * O binario esta no PATH? A busca e do proprio processo, como o `which` fazia: o primeiro arquivo
+ * regular executavel na ordem do PATH. Registro R3 do ensaio da 0.5.0: sem o binario `which` na
+ * maquina, o doctor dizia que o `git` e o `claude` faltavam. Entrada vazia do PATH e pulada (nao vira
+ * o diretorio atual), e nome com barra e conferido direto.
+ */
+function noPath(bin, env = process.env) {
+    const executavel = (alvo) => {
+        try {
+            if (!fs.statSync(alvo).isFile())
+                return false;
+            fs.accessSync(alvo, fs.constants.X_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    if (bin.includes('/'))
+        return executavel(bin) ? bin : null;
+    for (const dir of (env.PATH ?? '').split(path.delimiter)) {
+        if (dir && executavel(path.join(dir, bin)))
+            return path.join(dir, bin);
+    }
+    return null;
+}
+/** O `.gitignore` que o ork poe na pasta que e da maquina (fatia 2 do ensaio da 0.5.0, P3). */
+exports.GITIGNORE_DA_MAQUINA = '# Criado pelo ork: esta pasta é da máquina, não do repositório.\n*\n';
+/**
+ * Fatia 2 do ensaio da 0.5.0 (P3): a pasta que o ork cria para a maquina (o estado em `.orkastery/`
+ * e a pasta das worktrees) fica fora do git por um `.gitignore` proprio com `*`; o `.gitignore` do
+ * usuario nao e tocado. Nunca sobrescreve um existente, so vale para pasta dentro do repositorio e
+ * nao cria quando o repositorio ja rastreia algo nela: o projeto que versiona o proprio estado segue
+ * versionando. Devolve se criou.
+ */
+function ignorarPastaNoGit(dir, raizDoRepo) {
+    const relativo = path.relative(raizDoRepo, dir);
+    if (!relativo || relativo.startsWith('..') || path.isAbsolute(relativo))
+        return false;
+    const arquivo = path.join(dir, '.gitignore');
+    if (fs.existsSync(arquivo))
+        return false;
+    const rastreados = exec('git', ['ls-files', '-z', '--', relativo], raizDoRepo);
+    if (rastreados.ok && rastreados.stdout.length > 0)
+        return false;
+    fs.mkdirSync(dir, { recursive: true });
+    try {
+        fs.writeFileSync(arquivo, exports.GITIGNORE_DA_MAQUINA, { flag: 'wx' });
+    }
+    catch {
+        return false;
+    }
+    return true;
 }
 /** Sobe a arvore de diretorios procurando um arquivo. Retorna o diretorio que o contem. */
 function subirAte(dirInicial, arquivo) {

package/dist/verify.js

@@ -183,7 +183,7 @@ function cwdDaThread(raiz, thread) {
 /** HEAD real do diretorio de trabalho, carimbado em toda verificacao. */
 function commitReal(cwd) {
     const r = (0, util_1.exec)('git', ['rev-parse', 'HEAD'], cwd);
-    return r.ok ? r.stdout.trim() : 'desconhecido';
+    return r.ok ? r.stdout.trim() : util_1.COMMIT_DESCONHECIDO;
 }
 /** O pedido de conducao de uma verificacao, com o prazo derivado dos comandos que ela vai rodar (D3). */
 function pedidoDoVerify(carregado, threadId, operacao, comandos, conducao) {
@@ -456,7 +456,7 @@ function textoDoVerify(r) {
     linhas.push(`ork verify da thread ${r.thread}`);
     linhas.push(`  HEAD real   ${r.commit}`);
     linhas.push(`  diretorio   ${r.cwd}`);
-    linhas.push(`  baseline    ${r.baseline ? `${r.baseline.commit.slice(0, 8)} de ${(0, horario_1.formatarDataHoraRotulada)(r.baseline.gravadaEm)}` : '(nao gravada: falha nao pode ser chamada de regressao)'}`);
+    linhas.push(`  baseline    ${r.baseline ? `${(0, util_1.shaCurto)(r.baseline.commit)} de ${(0, horario_1.formatarDataHoraRotulada)(r.baseline.gravadaEm)}` : '(nao gravada: falha nao pode ser chamada de regressao)'}`);
     if (r.preparo) {
         const p = r.preparo;
         linhas.push(`  preparo     ${p.resultado.ok ? 'ok' : situacaoDoComando(p.resultado)} em ` +

package/dist/worktree.js

@@ -196,6 +196,11 @@ function garantirWorktree(carregado, id) {
  * commit que o git nao tem mais nao entra. `proprios` conta o que o HEAD tem fora delas e da base
  * atual (`null` sem nenhuma base conhecida); `pontoDePartida` e a base conhecida mais nova que e
  * ancestral do HEAD; `semAncestral` diz que HEAD e base atual nao tem historia em comum.
+ *
+ * RM-037 (fatia 3, defeito 3): `baseReescrita` diz que o ponto de partida nao esta mais na base atual.
+ * A base so anda para a frente; quando o ponto em que a thread saiu dela deixa de ser ancestral, a base
+ * foi reescrita, mesmo com ancestral comum mais antigo (force-push que tirou commits). Nesse caso o
+ * `git rebase <base>` reaplicaria, junto com os commits da thread, os `sairamDaBase` que a reescrita tirou.
  */
 function historiaPropria(raiz, thread, dir, shaBase) {
     const git = (...args) => (0, util_1.exec)('git', args, dir);
@@ -212,11 +217,13 @@ function historiaPropria(raiz, thread, dir, shaBase) {
     const conhecidas = [...new Set([pontoDaCriacao, ...sincronizadas])].filter(valido);
     const semAncestral = git('merge-base', 'HEAD', shaBase).code === 1;
     const pontoDePartida = [...conhecidas].reverse().find(sha => git('merge-base', '--is-ancestor', sha, 'HEAD').ok) ?? null;
+    const baseReescrita = pontoDePartida !== null && !git('merge-base', '--is-ancestor', pontoDePartida, shaBase).ok;
+    const numero = (r) => r.ok && /^\d+$/.test(r.stdout.trim()) ? Number(r.stdout.trim()) : null;
+    const sairamDaBase = baseReescrita ? numero(git('rev-list', '--count', pontoDePartida, '--not', shaBase)) : null;
     if (!conhecidas.length)
-        return { proprios: null, pontoDePartida, semAncestral };
-    const contagem = git('rev-list', '--count', 'HEAD', '--not', ...conhecidas, shaBase);
-    const proprios = contagem.ok && /^\d+$/.test(contagem.stdout.trim()) ? Number(contagem.stdout.trim()) : null;
-    return { proprios, pontoDePartida, semAncestral };
+        return { proprios: null, pontoDePartida, semAncestral, baseReescrita, sairamDaBase };
+    const proprios = numero(git('rev-list', '--count', 'HEAD', '--not', ...conhecidas, shaBase));
+    return { proprios, pontoDePartida, semAncestral, baseReescrita, sairamDaBase };
 }
 /**
  * Sincroniza a branch da thread com a base ATUAL (rebase), quando a base avancou.
@@ -360,9 +367,25 @@ function sincronizarWorktree(carregado, id, opcoes = {}) {
             `${historia.proprios ?? 'um numero desconhecido de'} commit(s) proprio(s): o rebase reaplicaria a historia antiga inteira`;
         if (!opcoes.dryRun)
             (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeSincronizada, { dir, branch, base, shaBase, shaAntes,
-                rebaseFeito: false, motivo: 'tree.blocked', semAncestral: true, detalhe });
+                rebaseFeito: false, motivo: 'tree.blocked', causa: 'base-reescrita', semAncestral: true, detalhe });
+        return { ...vazio, shaBase, shaAntes, shaDepois: shaAntes, ok: false, jaAtualizada: false, rebaseFeito: false,
+            motivo: 'tree.blocked', causa: 'base-reescrita', detalhe, correcao: `reaplique so os commits da thread sobre a base nova: ${onto}` };
+    }
+    // RM-037 (fatia 3, defeito 3): com ancestral comum, o sync caia no `git rebase <base>` abaixo e
+    // reaplicava tambem o que a reescrita tirou da base. O ponto de partida fora da base atual e o sinal.
+    if (historia.baseReescrita) {
+        const ponto = historia.pontoDePartida;
+        passos.push(`git merge-base --is-ancestor ${ponto.slice(0, 8)} ${shaBase.slice(0, 8)}   (falso: a base foi reescrita)`);
+        const detalhe = `a base ${base} foi reescrita: o ponto de partida ${ponto.slice(0, 8)} da branch ${branch} nao esta mais nela, ` +
+            `e o rebase comum reaplicaria ${historia.sairamDaBase ?? 'um numero desconhecido de'} commit(s) que sairam da base junto com ` +
+            `o(s) ${historia.proprios ?? '?'} da thread (git rev-list --count HEAD --not ${ponto.slice(0, 8)} ${shaBase.slice(0, 8)})`;
+        if (!opcoes.dryRun)
+            (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeSincronizada, { dir, branch, base, shaBase, shaAntes,
+                rebaseFeito: false, motivo: 'tree.blocked', causa: 'base-reescrita', baseReescrita: true, pontoDePartida: ponto,
+                sairamDaBase: historia.sairamDaBase, proprios: historia.proprios, detalhe });
         return { ...vazio, shaBase, shaAntes, shaDepois: shaAntes, ok: false, jaAtualizada: false, rebaseFeito: false,
-            motivo: 'tree.blocked', detalhe, correcao: `reaplique so os commits da thread sobre a base nova: ${onto}` };
+            motivo: 'tree.blocked', causa: 'base-reescrita', detalhe,
+            correcao: `reaplique so os commits da thread sobre a base nova: git -C ${dir} rebase --onto ${shaBase} ${ponto}` };
     }
     if (opcoes.dryRun) {
         passos.push(`git rebase ${shaBase}`);

package/eval/casos/onboarding.json

@@ -29,7 +29,7 @@
       "assercoes": [
         {
           "tipo": "contem",
-          "valor": "Valores secretos ficam em",
+          "valor": "Valores secretos ficam no ambiente do",
           "porque": "Âncora operacional fora da tabela, removê-la precisa reprovar o corpus."
         },
         {

package/package.json

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

package/skills/core/onboarding/SKILL.md

@@ -24,8 +24,9 @@ preservando as demais respostas. Exemplo de opt-out:
 `ork onboarding set maestro --conteudo '{"owner":{"experience":false}}' --por equipe`.
 Sem resposta, mantenha a pergunta pendente: defaults efetivos não são autoria humana.
 
-Peça somente referências de variáveis nas etapas sensíveis. Valores secretos ficam em
-`~/.hermes/.env`; não leia esse arquivo nem leve credenciais para conversa, onboarding ou ledger.
+Peça somente referências de variáveis nas etapas sensíveis. Valores secretos ficam no ambiente do
+processo ou no cofre do host (no Hermes, `~/.hermes/.env`); não os leia nem leve credenciais para
+conversa, onboarding ou ledger.
 Se o builder fornecer um segredo, não o repita: oriente a configuração local e registre apenas
 a referência pública aceita pelo núcleo.
 

package/skills/phases/ship-release/SKILL.md

@@ -38,9 +38,12 @@ ork phase list <thread>                     # a prova: mergeSha, shaRemoto, push
 
 ## O que o nucleo verifica por voce
 
-A policy `push_direto_na_base` e bloqueante: origem igual ao destino, ou origem igual a branch base
-do projeto, reprova antes de o `ork` tocar no remoto. Arvore de destino ocupada sai como
-`tree.blocked`; lease tomado por outra thread sai como `lease.busy`.
+A policy `push_direto_na_base` e bloqueante: origem igual ao destino, origem igual a branch base
+do projeto, ou entrega sem delta com a base local a frente do remoto (o push publicaria commit que
+nao passou por merge de thread) reprova antes de o `ork` tocar no remoto. O merge que o proprio
+ship ja fez e nao chegou ao remoto (push recusado, `--sem-push`) nao conta: o ship repetido empurra.
+Arvore de destino ocupada sai como `tree.blocked`; lease tomado por outra thread sai como
+`lease.busy`.
 
 ## Racionalizacoes comuns