@orkastery/cli 0.4.3 → 0.5.1

package/dist/roadmap-status.js

@@ -0,0 +1,348 @@
+"use strict";
+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;
+/**
+ * RM-048 (item 7, D7): o status report UNICO do roadmap, no formato aprovado pelo dono.
+ *
+ * Ate aqui cada canal escrevia o proprio relatorio de roadmap, e o dono lia uma coisa no Telegram
+ * e outra no terminal. O formato que ele aprovou (27/09 e 28/09):
+ *
+ *   titulo "Roadmap do <Projeto> (DD/MM, HH:MM)", no fuso do dono;
+ *   grupos com icones, nesta ordem: Concluidos, Disponiveis com algo em aberto, Entregue hoje,
+ *   Piloto, Em desenvolvimento, Refinamento, Proposto, Descontinuado;
+ *   um item por linha, com #HITL no que depende do dono;
+ *   fecho com "O que precisa de voce" e "O que eu faco em seguida".
+ *
+ * Tudo sai de FATO: o frontmatter do item (`ork docs`), o ledger das threads ligadas a ele e o gate
+ * que o nucleo confere sem escrever (`prepararPedidoGate`). E leitura pura: nao abre pedido, nao
+ * grava ledger, nao toca a rede. Os canais chamam `ork roadmap status` e transportam o texto.
+ *
+ * RM-054: o montador recebe FATOS de thread (`FatoDeThread`), nao so as threads deste disco. O
+ * relatorio local continua com os fatos locais; o panorama da rede soma os retratos das outras
+ * maquinas, e so ai o fecho diz entre parenteses em que maquina a thread anda.
+ */
+const docs_1 = require("./docs");
+const ledger_1 = require("./ledger");
+const thread_1 = require("./thread");
+const hitl_contract_1 = require("./hitl-contract");
+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([
+    { id: 'concluidos', icone: '✅', titulo: 'Concluídos' },
+    { id: 'disponiveis', icone: '🟢', titulo: 'Disponíveis com algo em aberto' },
+    { id: 'hoje', icone: '🚀', titulo: 'Entregue hoje' },
+    { id: 'piloto', icone: '🧪', titulo: 'Piloto' },
+    { id: 'desenvolvimento', icone: '🔨', titulo: 'Em desenvolvimento' },
+    { id: 'refinamento', icone: '🔍', titulo: 'Refinamento' },
+    { id: 'proposto', icone: '🆕', titulo: 'Proposto' },
+    { id: 'descontinuado', icone: '⛔', titulo: 'Descontinuado' },
+]);
+/**
+ * D7: o grupo de cada ciclo do padrao de roadmap (`docs/padroes/roadmap-de-produto.md`). Mapa
+ * TOTAL sobre os doze ciclos; ciclo fora dele cai em "Proposto" e o texto o mostra como e.
+ */
+exports.GRUPO_DO_CICLO = Object.freeze({
+    'Concluído': 'concluidos',
+    'Disponível': 'disponiveis',
+    'Piloto': 'piloto',
+    'Em desenvolvimento': 'desenvolvimento', 'Em validação': 'desenvolvimento', 'Bloqueado': 'desenvolvimento',
+    'Refinamento': 'refinamento', 'Pronto para desenvolvimento': 'refinamento',
+    'Discovery': 'proposto', 'Backlog': 'proposto',
+    'Cancelado': 'descontinuado', 'Descontinuado': 'descontinuado',
+});
+/** Quantas linhas cada parte do fecho mostra antes de contar o resto. */
+exports.TETO_DO_FECHO = 5;
+/** A letra recomendada de uma pergunta v2, para o fecho dizer exatamente o que digitar. */
+const recomendadaDe = (p) => (0, hitl_contract_1.ehV2)(p) && p.classe === 'pergunta' ? p.alternativas.find(a => a.recomendada)?.letra : undefined;
+const mapa = (v) => (!!v && typeof v === 'object' && !Array.isArray(v) ? v : {});
+const texto = (v) => (v === undefined || v === null ? '' : String(v));
+/** O nome curto do item: o titulo ate o primeiro ":" ou 60 caracteres. */
+function nomeCurto(titulo) {
+    const antes = titulo.split(/:\s/)[0].trim();
+    return antes.length > 60 ? `${antes.slice(0, 57)}...` : antes;
+}
+/**
+ * O que espera o dono nesta thread, lido sem escrever: um gate que ainda espera (pausa do modo ou
+ * escalacao tipada do dono) ou uma pergunta de sessao aberta. Impedimento tecnico nao conta (D6).
+ */
+function esperaDoDono(raiz, t, quando) {
+    const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, t.id));
+    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)))];
+    // 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;
+            const codigo = 'aberto' in preparado ? pedido.codigo : undefined;
+            const recomendada = recomendadaDe(pedido);
+            return { thread: t.id, pergunta: (0, hitl_contract_1.textoDoPedido)(pedido), ...(typeof codigo === 'string' ? { codigo } : {}),
+                ...(recomendada ? { recomendada } : {}) };
+        }
+        catch { /* este motivo nao espera o dono agora */ }
+    }
+    const contexto = (0, hitl_gates_1.contextoHitlDosEventos)(t, eventos);
+    const respondidos = new Set(eventos.filter(e => ['human_gate', 'session_answered'].includes(e.tipo)).map(e => String(e.pedidoId)));
+    for (const e of [...eventos].reverse()) {
+        if (e.tipo !== 'hitl_requested' || e.contexto !== contexto)
+            continue;
+        const pedido = e.pedido;
+        try {
+            if ((0, hitl_contract_1.alvoDoPedido)(pedido)?.tipo !== 'session' || respondidos.has(pedido.id) || (0, hitl_contract_1.estadoDoPedido)(pedido, quando) !== 'aberto')
+                continue;
+            const codigo = (0, hitl_contract_1.ehV2)(pedido) && pedido.classe === 'pergunta' ? pedido.codigo : undefined;
+            const recomendada = recomendadaDe(pedido);
+            return { thread: t.id, pergunta: (0, hitl_contract_1.textoDoPedido)(pedido), ...(codigo ? { codigo } : {}), ...(recomendada ? { recomendada } : {}) };
+        }
+        catch { /* pedido invalido nao e espera */ }
+    }
+    return undefined;
+}
+/**
+ * Os fatos das threads deste disco: `ship_done` do dia e espera do dono lidos do ledger local.
+ * `fuso`: o do projeto consultado, na visao da rede; sem ele, o do dono deste processo.
+ */
+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 {
+            t = (0, thread_1.lerThread)(raiz, id);
+        }
+        catch {
+            continue; /* thread ilegivel fica de fora */
+        }
+        fatos.push({
+            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();
+    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) {
+    const quando = opcoes.quando;
+    const porId = new Map(fatos.map(f => [f.id, f]));
+    const porItem = new Map();
+    for (const f of fatos)
+        if (f.roadmap)
+            porItem.set(f.roadmap, new Set([...(porItem.get(f.roadmap) ?? []), f.id]));
+    const itens = [];
+    for (const d of docs.filter(x => x.tipo === 'roadmap')) {
+        const estado = mapa(d.dados.estado), sdlc = mapa(d.dados.sdlc);
+        const ciclo = texto(estado.ciclo);
+        const ligadas = [...new Set([...(porItem.get(d.id) ?? []), ...(texto(sdlc.thread) ? [texto(sdlc.thread)] : [])])]
+            .filter(id => porId.has(id)).sort();
+        const entregueHoje = ligadas.some(id => porId.get(id).entregueHoje());
+        const abertas = ligadas.map(id => porId.get(id)).filter(f => f.aberta);
+        let hitl;
+        for (const f of abertas) {
+            hitl = f.espera();
+            if (hitl)
+                break;
+        }
+        // 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)}`] : []),
+        ] : [];
+        itens.push({
+            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 } : {}),
+                    ...(entrega ? { entrega } : {}) } } : {}),
+            ...(hitl ? { hitl } : {}),
+        });
+    }
+    const grupos = exports.GRUPOS_DO_ROADMAP.map(g => ({ ...g, itens: itens.filter(i => i.grupo === g.id) }));
+    return {
+        contrato: exports.CONTRATO_STATUS_DO_ROADMAP, consultadoEm: quando,
+        projeto: opcoes.projeto ?? 'projeto', grupos,
+        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, 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);
+    const linhaDoItem = (i) => {
+        const detalhe = i.emAberto.length ? `: ${i.emAberto.join(', ')}` : i.conduzindo && i.grupo !== 'concluidos' && i.grupo !== 'hoje'
+            ? ` (${i.conduzindo.fase}${i.conduzindo.maquina ? `, ${i.conduzindo.maquina}` : ''})` : '';
+        return `• ${i.id} ${i.titulo}${detalhe}${i.hitl ? ' #HITL' : ''}`;
+    };
+    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})`,
+        ...(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 => 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-close.js

@@ -47,6 +47,7 @@ const ledger_1 = require("./ledger");
 const estado_thread_1 = require("./estado-thread");
 const util_1 = require("./util");
 const fabrica_publicar_1 = require("./fabrica-publicar");
+const fechamento_1 = require("./fechamento");
 function validarArtefato(raiz, arquivo, sha256) {
     if (!/^[a-f0-9]{64}$/.test(sha256))
         throw new Error('sha256 inválido');
@@ -111,5 +112,7 @@ function fecharAdministrativamente(raiz, id, opcoes) {
     t.status = 'fechada';
     (0, thread_1.gravarThread)(raiz, t);
     (0, fabrica_publicar_1.publicarEmSegundoPlano)(raiz);
+    // RM-037 (rm037noite): a thread fechada solta o que segurava, com registro no ledger dela.
+    (0, fechamento_1.liberarAoFechar)(raiz, id);
     return t;
 }

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) {