@orkastery/cli 0.4.3 → 0.5.1

package/dist/intelligence-graph-repo.js

@@ -0,0 +1,197 @@
+"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.TENANT_PADRAO = void 0;
+exports.identidadeDaLeitura = identidadeDaLeitura;
+exports.revisaoDaArvore = revisaoDaArvore;
+exports.headsDasArvores = headsDasArvores;
+exports.revisoesAncestrais = revisoesAncestrais;
+exports.lerRepositorio = lerRepositorio;
+/**
+ * RM-031 KG2 (D8): leitura do repositorio Git local para o extrator. E a unica borda de E/S do
+ * KG2: lista os arquivos rastreados, le os bytes da arvore de trabalho e fixa a revisao. Nao
+ * executa shell nem texto vindo do repositorio; o Git roda com argumentos fixos. O KG3 usa daqui a
+ * identidade da leitura e a revisao da arvore limpa, sem ler os arquivos.
+ *
+ * Fica fora e declarado: link simbolico, submodulo, arquivo em conflito, arquivo rastreado que
+ * sumiu da arvore, arquivo cujo caminho real sai da raiz e caminho que nao e UTF-8. A revisao so e
+ * o HEAD quando nada rastreado mudou e os bytes lidos sao os blobs do indice (sem filtro do Git).
+ */
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const yaml_1 = require("./yaml");
+exports.TENANT_PADRAO = 'local';
+const ID_DE_REPOSITORIO = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+/** Git com argumentos fixos; o fsmonitor do repositorio nao roda (seria comando externo configurado nele). */
+function git(raiz, args) {
+    const r = (0, node_child_process_1.spawnSync)('git', ['-c', 'core.fsmonitor=false', ...args], {
+        cwd: raiz, maxBuffer: 512 * 1024 * 1024, env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' },
+    });
+    return { ok: r.status === 0, saida: r.stdout ?? Buffer.alloc(0) };
+}
+function obrigatorio(raiz, args) {
+    const r = git(raiz, args);
+    if (!r.ok)
+        throw new Error(`extracao.repositorio.git-falhou em git ${args[0]}`);
+    return r.saida;
+}
+const utf8 = (b) => {
+    try {
+        return new TextDecoder('utf-8', { fatal: true }).decode(b);
+    }
+    catch {
+        return null;
+    }
+};
+/** Nome do projeto no `orkastery.yaml`, quando ha um valido na raiz. */
+function nomeDoProjeto(raiz) {
+    const arquivo = path.join(raiz, 'orkastery.yaml');
+    if (!fs.existsSync(arquivo))
+        return null;
+    try {
+        const dados = (0, yaml_1.lerYaml)(fs.readFileSync(arquivo, 'utf8'));
+        const projeto = dados && typeof dados === 'object' && !Array.isArray(dados) ? dados.project : null;
+        const nome = projeto && typeof projeto === 'object' && !Array.isArray(projeto) ? projeto.name : null;
+        return typeof nome === 'string' && ID_DE_REPOSITORIO.test(nome) ? nome : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Repositorio, tenant e ACL da leitura: os informados, ou os padroes (D8). */
+function identidadeDaLeitura(raiz, opcoes = {}) {
+    const repositorio = opcoes.repository_id ?? nomeDoProjeto(raiz);
+    if (!repositorio || !ID_DE_REPOSITORIO.test(repositorio))
+        throw new Error('extracao.repositorio.sem-id');
+    return { repository_id: repositorio, tenant_id: opcoes.tenant_id ?? exports.TENANT_PADRAO, acl_refs: [...(opcoes.acl_refs ?? [`repo:${repositorio}:leitura`])] };
+}
+/**
+ * RM-031 KG3 (D3): o HEAD e se a arvore esta limpa nos rastreados, sem ler arquivo nenhum. O filtro
+ * do Git (eol, LFS) so aparece lendo os bytes: quem indexa confere a revisao do `lerRepositorio`.
+ */
+function revisaoDaArvore(diretorio) {
+    const raiz = obrigatorio(diretorio, ['rev-parse', '--show-toplevel']).toString('utf8').trim();
+    const head = git(raiz, ['rev-parse', '--verify', '-q', 'HEAD']);
+    if (!head.ok)
+        return { raiz, head: null, motivo: 'sem-commit' };
+    const sujo = obrigatorio(raiz, ['status', '--porcelain=v1', '-z', '--untracked-files=no']).length > 0;
+    return { raiz, head: head.saida.toString('utf8').trim(), motivo: sujo ? 'working-tree-modified' : null };
+}
+/**
+ * RM-031 KG3 (CHECK rodada 1, A6): o HEAD de cada arvore do repositorio (a principal e as worktrees),
+ * pelo `git worktree list --porcelain`. O estado do indice e compartilhado entre elas.
+ */
+function headsDasArvores(diretorio) {
+    const saida = obrigatorio(diretorio, ['worktree', 'list', '--porcelain']).toString('utf8');
+    return [...new Set(saida.split('\n').filter((l) => /^HEAD [0-9a-f]{40,64}$/.test(l)).map((l) => l.slice(5)))].sort();
+}
+/**
+ * RM-031 KG4 (D1): o HEAD e as revisoes ancestrais dele (`git rev-list`), da mais recente para a mais
+ * antiga, ate o limite. Sem commit, ou com o Git falhando, nao ha ancestral.
+ */
+function revisoesAncestrais(diretorio, limite) {
+    const raiz = obrigatorio(diretorio, ['rev-parse', '--show-toplevel']).toString('utf8').trim();
+    const r = git(raiz, ['rev-list', `--max-count=${Math.max(1, Math.floor(limite))}`, 'HEAD']);
+    return r.ok ? r.saida.toString('utf8').split('\n').filter((l) => /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(l)) : [];
+}
+/** Le o repositorio que contem `diretorio` e devolve a entrada do extrator. */
+function lerRepositorio(diretorio, opcoes = {}) {
+    const raiz = obrigatorio(diretorio, ['rev-parse', '--show-toplevel']).toString('utf8').trim();
+    const { repository_id: repositorio, tenant_id, acl_refs } = identidadeDaLeitura(raiz, opcoes);
+    // `-s` traz modo e estagio: 120000 e link simbolico, 160000 e submodulo, estagio > 0 e conflito.
+    const registros = obrigatorio(raiz, ['ls-files', '-z', '-s', '--full-name']);
+    const porCaminho = new Map(), excluidas = [];
+    let inicio = 0;
+    for (let i = 0; i < registros.length; i++) {
+        if (registros[i] !== 0)
+            continue;
+        const registro = registros.subarray(inicio, i);
+        inicio = i + 1;
+        const tab = registro.indexOf(0x09);
+        if (tab < 0)
+            continue;
+        const [modo, objeto, estagio] = registro.subarray(0, tab).toString('latin1').split(' ');
+        const caminho = utf8(registro.subarray(tab + 1));
+        if (caminho === null) {
+            excluidas.push({ path: registro.subarray(tab + 1).toString('latin1'), motivo: 'caminho-nao-utf8' });
+            continue;
+        }
+        const atual = porCaminho.get(caminho);
+        porCaminho.set(caminho, { modo, objeto, estagios: (atual?.estagios ?? 0) + (estagio === '0' ? 0 : 1) });
+    }
+    const fontes = [], raizReal = fs.realpathSync(raiz);
+    let filtrado = false;
+    for (const [caminho, { modo, objeto, estagios }] of porCaminho) {
+        if (estagios > 0)
+            excluidas.push({ path: caminho, motivo: 'conflito-de-merge' });
+        else if (modo === '120000')
+            excluidas.push({ path: caminho, motivo: 'link-simbolico' });
+        else if (modo === '160000')
+            excluidas.push({ path: caminho, motivo: 'submodulo' });
+        else {
+            const absoluto = path.join(raiz, caminho);
+            const st = fs.lstatSync(absoluto, { throwIfNoEntry: false });
+            if (!st)
+                excluidas.push({ path: caminho, motivo: 'ausente-na-arvore' });
+            else if (!st.isFile())
+                excluidas.push({ path: caminho, motivo: 'nao-e-arquivo' });
+            // Pasta do caminho trocada por link simbolico levaria a leitura para fora do repositorio.
+            else if (!fs.realpathSync(absoluto).startsWith(raizReal + path.sep))
+                excluidas.push({ path: caminho, motivo: 'fora-do-repositorio' });
+            else {
+                const bytes = fs.readFileSync(absoluto);
+                if ((0, node_crypto_1.createHash)('sha1').update(`blob ${bytes.length}\0`).update(bytes).digest('hex') !== objeto)
+                    filtrado = true;
+                fontes.push({ path: caminho, bytes });
+            }
+        }
+    }
+    const head = git(raiz, ['rev-parse', '--verify', '-q', 'HEAD']);
+    const sujo = obrigatorio(raiz, ['status', '--porcelain=v1', '-z', '--untracked-files=no']).length > 0;
+    const revisao = head.ok ? head.saida.toString('utf8').trim() : null;
+    // A5: filtro do Git (eol, LFS) deixa o status limpo com bytes que nao sao o blob da revisao.
+    const motivo = !revisao ? 'sem-commit' : sujo ? 'working-tree-modified' : filtrado ? 'filtro-do-git' : null;
+    return {
+        tenant_id,
+        repository_id: repositorio,
+        revision: motivo === null ? revisao : null,
+        revision_unavailable_reason: motivo,
+        acl_refs,
+        fontes,
+        excluidas,
+    };
+}

package/dist/leases.js

@@ -76,6 +76,9 @@ exports.posicaoNaFila = posicaoNaFila;
 exports.proximoDaFila = proximoDaFila;
 exports.adquirirRegiao = adquirirRegiao;
 exports.tabelaDeLeases = tabelaDeLeases;
+exports.soltarDaThread = soltarDaThread;
+exports.soltarThreadFechada = soltarThreadFechada;
+exports.podarRegioesDeThreadsFechadas = podarRegioesDeThreadsFechadas;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const manifest_1 = require("./manifest");
@@ -83,6 +86,8 @@ const estado_thread_1 = require("./estado-thread");
 const util_1 = require("./util");
 const horario_1 = require("./horario");
 const conducao_texto_1 = require("./conducao-texto");
+const ledger_1 = require("./ledger");
+const thread_1 = require("./thread");
 /** Nome do lease que serializa o merge na base (visao, paridade 5). */
 exports.LEASE_MAIN_TREE = 'main-tree';
 /** TTL padrao de 30 minutos: um SHIP que passe disso deixou de existir. */
@@ -433,6 +438,12 @@ function proximoDaFila(raiz, nome) {
 function adquirirRegiao(raiz, nome, opcoes) {
     const tipo = tipoDoLease(nome);
     const base = { nome, tipo, lease: null, ocupadoPor: null, tomadoDeVencido: false };
+    // A poda e limpeza de estado alheio: erro de E/S nela nunca impede a thread viva de pedir a regiao
+    // (achado A1 do CHECK 1); o que nao saiu agora sai no proximo pedido.
+    try {
+        podarThreadsFechadas(raiz, nome, opcoes.thread);
+    }
+    catch { /* a regra de colisao abaixo decide */ }
     const colidentes = leasesColidentes(raiz, nome, opcoes.thread);
     if (colidentes.length > 0) {
         const dono = colidentes[0];
@@ -550,3 +561,92 @@ function tabelaDeLeases(raiz) {
         linhas.push((0, horario_1.legendaDoFuso)());
     return linhas.join('\n');
 }
+// ---------------------------------------------------------------------------
+// RM-037 (rm037noite, defeito 2): thread fechada nao segura regiao nem fila.
+// ---------------------------------------------------------------------------
+/**
+ * Thread fechada nesta maquina? So `status: fechada` conta: thread que nao existe aqui (outro
+ * perfil, estado apagado) segue contando, porque ninguem prova que ela acabou.
+ */
+function threadFechada(raiz, thread) {
+    try {
+        return (0, thread_1.lerThread)(raiz, thread).status === 'fechada';
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Tira da thread os leases de escrita e as entradas dela na fila. O `exec:` fica de fora: a
+ * conducao tem ciclo proprio e ja trata thread fechada como sem conducao.
+ */
+function soltarDaThread(raiz, thread) {
+    const leases = [];
+    for (const lease of listarLeases(raiz)) {
+        if (lease.thread !== thread || tipoDoLease(lease.nome) === 'exec')
+            continue;
+        // Achado A2 do CHECK 1: rele logo antes de apagar. Outra poda pode ter soltado este lease e uma
+        // thread viva pode ter adquirido o mesmo nome no meio; apagar pelo caminho da listagem levaria o
+        // lease dela. So sai o arquivo que ainda e o da thread fechada, com o mesmo carimbo.
+        const atual = lerLease(raiz, lease.nome);
+        if (!atual || atual.thread !== thread || atual.adquiridoEm !== lease.adquiridoEm)
+            continue;
+        try {
+            fs.unlinkSync(caminhoLease(raiz, lease.nome));
+            leases.push(lease.nome);
+        }
+        catch { /* outra limpeza chegou antes */ }
+    }
+    const fila = lerFila(raiz);
+    const dela = fila.filter((p) => p.thread === thread);
+    if (dela.length > 0)
+        gravarFila(raiz, fila.filter((p) => p.thread !== thread));
+    return { leases, fila: dela.map((p) => p.nome) };
+}
+/**
+ * Solta o que a thread fechada deixou e registra no ledger dela: `lease_released` por lease e
+ * `lease_dequeued` por entrada de fila, com a origem (o fechamento ou a poda de quem pediu a regiao).
+ */
+function soltarThreadFechada(raiz, thread, origem, pedidaPor) {
+    const solto = soltarDaThread(raiz, thread);
+    const dir = (0, thread_1.dirThread)(raiz, thread);
+    const quem = pedidaPor ? { pedidaPor } : {};
+    for (const lease of solto.leases) {
+        (0, ledger_1.registrarSeExiste)(dir, thread, ledger_1.TIPOS_DE_EVENTO.leaseLiberado, { lease, ok: true, detalhe: 'thread fechada: lease solto', origem, ...quem });
+    }
+    for (const lease of solto.fila) {
+        (0, ledger_1.registrarSeExiste)(dir, thread, ledger_1.TIPOS_DE_EVENTO.leaseDesenfileirado, { lease, detalhe: 'thread fechada: saiu da fila', origem, ...quem });
+    }
+    return solto;
+}
+/**
+ * Antes de decidir a vez, quem pede a regiao tira da frente o que e de thread ja fechada: o lease
+ * colidente e a espera na fila. E a cura do que ficou preso antes de o fechamento soltar sozinho
+ * (a ork-companybrai3, fechada, na frente da fila de `path:docs/roadmap/README.md`).
+ */
+function podarThreadsFechadas(raiz, nome, quem) {
+    const suspeitas = new Set([
+        ...listarLeases(raiz).filter((l) => leasesColidem(nome, l.nome)).map((l) => l.thread),
+        ...esperandoPor(raiz, nome).map((p) => p.thread),
+    ]);
+    suspeitas.delete(quem);
+    for (const thread of suspeitas) {
+        if (threadFechada(raiz, thread))
+            soltarThreadFechada(raiz, thread, 'poda', quem);
+    }
+}
+/**
+ * RM-037 (fatia 3, defeito 4): a mesma poda, para as conferencias previas do MCP. O `ork_git_commit`
+ * conferia `lerLease` antes do `adquirirRegiao` e recusava com `lease.busy` o lease que a ork-companybrai3
+ * (fechada) deixou, e soltar o lease de outra thread exigia o dono. Lease e fila de thread fechada sao
+ * orfaos: saem aqui, com registro no ledger dela. Lease de thread aberta, vencido ou nao, e o da propria
+ * thread seguem como estao, e a conferencia de quem chama decide. De melhor esforco, como no `adquirirRegiao`.
+ */
+function podarRegioesDeThreadsFechadas(raiz, nomes, quem) {
+    for (const nome of nomes) {
+        try {
+            podarThreadsFechadas(raiz, nome, quem);
+        }
+        catch { /* a conferencia de quem chama decide */ }
+    }
+}

package/dist/ledger.js

@@ -45,6 +45,7 @@ exports.caminhoLedger = caminhoLedger;
 exports.registrar = registrar;
 exports.threadPresente = threadPresente;
 exports.registrarSeExiste = registrarSeExiste;
+exports.ehEnsaio = ehEnsaio;
 exports.lerLedger = lerLedger;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
@@ -99,8 +100,18 @@ exports.TIPOS_DE_EVENTO = {
     worktreeAuditada: 'worktree_audited',
     worktreeLiberada: 'worktree_released',
     leaseEnfileirado: 'lease_queued',
+    // RM-037 (rm037noite, defeito 2): a entrada da fila que saiu porque a thread fechou.
+    leaseDesenfileirado: 'lease_dequeued',
+    // RM-037 (rm037noite, defeito 3): a reserva do roadmap que a thread fechada soltou (ou reapontou),
+    // e a que ficou para depois porque nao deu para soltar agora.
+    reservaLiberada: 'roadmap_reserva_liberada',
+    reservaPendente: 'roadmap_reserva_pendente',
+    // A parte do fechamento que falhou (E/S), com o erro; o fechamento segue valendo.
+    solturaFalhou: 'soltura_ao_fechar_falhou',
     postmortemGravado: 'postmortem_recorded',
     masterConcluido: 'master_done',
+    // RM-048 (item 8): o pedido de nota ao dono, com codigo curto; a nota volta pelo ingresso.
+    notaPedida: 'master_nota_pedida',
     scoreProposto: 'score_proposto',
     masterMigrado: 'master_migrated',
     threadFechadaAdmin: 'thread_closed_admin',
@@ -138,6 +149,8 @@ exports.TIPOS_DE_EVENTO = {
     onboardingRegistrado: 'onboarding_recorded',
     // Correcao do escalonador: vaga devolvida por thread sem procura ativa (`ork board reap`)
     vagaLiberada: 'slot_released',
+    // RM-037 (rm037defeito, defeito 3): o `phase run` recusou o despacho por falta de vaga no projeto.
+    vagaRecusada: 'slot_refused',
     // I-07: estimativa humana no PLAN para comparacao economica posterior.
     estimativaPlano: 'plan_estimate',
     // I-42 (D5): ciclo sem CHECK que nao achou teste nem comando honesto declara a ausencia de
@@ -156,6 +169,8 @@ exports.TIPOS_DE_EVENTO = {
     conducaoLiberada: 'conducao_liberada',
     conducaoOrfaLiberada: 'conducao_orfa_liberada',
     conducaoAssumida: 'conducao_assumida',
+    // RM-037 (rm037defeito, A-1 do CHECK 3): o despacho recusado antes da sessao devolveu o lease que a tomada consumiu.
+    conducaoDevolvida: 'conducao_devolvida',
     conducaoRenovada: 'conducao_renovada',
 };
 /**
@@ -222,6 +237,14 @@ function registrarSeExiste(dirThread, threadId, tipo, dados = {}) {
     }
     return evento;
 }
+/**
+ * Fatia 2 do ensaio da 0.5.0 (P2): o evento que um `--dry-run` grava (`dryRun: true`) e ensaio, nao
+ * estado. O ledger o guarda como rastro; board, escalonador, monitor (o pulse) e maestro o descartam.
+ * O ensaio do ship gravava `gate_blocked human.pending` e a thread aparecia pausada sem ninguem pedir.
+ */
+function ehEnsaio(e) {
+    return e.dryRun === true;
+}
 /** Le o ledger inteiro. Linha corrompida vira evento `ledger_corrupted` em vez de quebrar a leitura. */
 function lerLedger(dirThread) {
     const caminho = caminhoLedger(dirThread);

package/dist/licoes.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PISO_DA_PROPOSTA = exports.JANELA_DA_PROPOSTA_DIAS = void 0;
+exports.PISO_DA_PROPOSTA = exports.JANELA_DA_PROPOSTA_DIAS = exports.DICA_DO_MOTIVO = void 0;
 exports.lerLicoes = lerLicoes;
 exports.resumoDasLicoes = resumoDasLicoes;
 exports.textoDasLicoes = textoDasLicoes;
@@ -59,7 +59,7 @@ const estado_thread_1 = require("./estado-thread");
 const ledger_1 = require("./ledger");
 const policies_1 = require("./policies");
 /** O que evita cada bloqueio, na forma de comando. Sem dica, a licao so conta a recorrencia. */
-const DICA_DO_MOTIVO = {
+exports.DICA_DO_MOTIVO = {
     'claims.failed': 'rode o comando da claim antes de registra-la; claim sem prova local volta como GO-FIX',
     'verify.regression': 'grave a baseline antes do GO (`ork verify <thread> --baseline`) e rode os testes focados antes do CHECK',
     'verify.failed': 'grave a baseline antes do GO, para a falha ter com que ser comparada',
@@ -67,7 +67,8 @@ const DICA_DO_MOTIVO = {
     'runtime.unavailable': 'declare a ordem de fallback do bloco (`ork setup <modo> --bloco N --fallback runtime:modelo`)',
     'runtime.quota-exhausted': 'tenha um segundo perfil da conta (`ork accounts add`) ou fallback no bloco',
     'tree.blocked': 'sincronize a worktree com a base antes do SHIP (`ork worktree sync <thread>`)',
-    'ci.failed': 'rode a suite hermetica (`npm --prefix core run test:ci`) antes do push',
+    // Fatia 2 do ensaio da 0.5.0 (P6): o que o CI do projeto roda, e nao o script do Orkastery.
+    'ci.failed': 'rode antes do push o que o CI do projeto roda (`ci.command` do manifesto ou, sem ele, os comandos de `verify`)',
     'artifact.missing': 'grave o artefato da fase exatamente no caminho que o prompt pede',
 };
 const DICA_DA_CLASSE = {
@@ -116,7 +117,7 @@ function recorrencias(licoes) {
     const classes = new Map();
     for (const l of licoes) {
         for (const m of l.motivos) {
-            const r = motivos.get(m) ?? { chave: `motivo:${m}`, tipo: 'motivo', nome: m, threads: [], vezes: 0, dica: DICA_DO_MOTIVO[m] ?? null };
+            const r = motivos.get(m) ?? { chave: `motivo:${m}`, tipo: 'motivo', nome: m, threads: [], vezes: 0, dica: exports.DICA_DO_MOTIVO[m] ?? null };
             r.threads.push(l.thread);
             motivos.set(m, r);
         }

package/dist/liveness.js

@@ -120,7 +120,8 @@ function detectarFasesOrfas(carregado, opcoes = {}) {
         const t = (0, thread_1.lerThread)(carregado.raiz, id), dir = (0, thread_1.dirThread)(carregado.raiz, id);
         if (t.status !== 'aberta')
             continue;
-        const eventos = (0, ledger_1.lerLedger)(dir), di = eventos.map(e => e.tipo).lastIndexOf('phase_dispatch');
+        // Fatia 2 do ensaio da 0.5.0 (P2; CHECK, rodada 1, A1): o gate do `ship --dry-run` nao e gate em aberto.
+        const eventos = (0, ledger_1.lerLedger)(dir).filter(e => !(0, ledger_1.ehEnsaio)(e)), di = eventos.map(e => e.tipo).lastIndexOf('phase_dispatch');
         if (di < 0)
             continue;
         const d = eventos[di], inicio = Date.parse(d.ts), fase = d.fase;

package/dist/maestro-cli.js

@@ -31,10 +31,19 @@ function readMaestro(context, options) {
             return sources;
         } });
 }
+/** RM-052: de onde veio o projeto do panorama, na lingua do dono. */
+const ORIGEM_DO_PANORAMA = Object.freeze({
+    installation: 'fixado na instalação', cwd: 'pelo diretório atual', worktree: 'pela worktree da thread',
+    selection: 'pedido explicitamente (--projeto ou ORK_PROJETO)',
+});
 function maestroText(snapshot) {
-    return [`${snapshot.project.name} · panorama Maestro`,
+    const p = snapshot.project;
+    return [`${p.name} · panorama Maestro`,
         // I-35: o snapshot guarda ISO; o texto ao dono diz quando consultou, no fuso dele.
         `• Consulta: ${(0, horario_1.formatarDataHoraRotulada)(snapshot.observedAt, { agora: snapshot.observedAt })}`,
+        // RM-052: qual cópia foi lida e o que o panorama não lê, antes de qualquer seção.
+        `• Projeto consultado: ${p.name}${p.root ? ` · ${p.root}` : ''}${p.remote === undefined ? '' : ` · ${p.remote ?? 'sem remoto'}`} · ${ORIGEM_DO_PANORAMA[p.origin]}`,
+        ...(snapshot.notConsulted?.length ? [`• Não lido: ${snapshot.notConsulted.join(' · ')}`] : []),
         ...maestro_contract_1.SECTION_NAMES.map(name => {
             const s = snapshot.sections[name];
             return `• ${name}: ${s.state} · ${s.coverage.returned}/${s.coverage.total ?? '?'}${s.coverage.omitted ? ' · mais itens disponíveis' : ''}`;

package/dist/maestro-contract.js

@@ -31,10 +31,14 @@ exports.maestroSectionSchema = zod_1.z.object({
 }).strict();
 exports.maestroSnapshotSchema = zod_1.z.object({
     schema: zod_1.z.literal(exports.MAESTRO_SCHEMA), observedAt: zod_1.z.string().datetime(), fingerprint,
-    project: zod_1.z.object({ id: identity, name: text, origin: zod_1.z.enum(['installation', 'cwd', 'worktree', 'selection']), fingerprint }).strict(),
+    // RM-052: a raiz exibida (com ~) e o remoto sem credencial dizem QUAL copia foi lida.
+    project: zod_1.z.object({ id: identity, name: text, origin: zod_1.z.enum(['installation', 'cwd', 'worktree', 'selection']), fingerprint,
+        root: text.optional(), remote: text.nullable().optional() }).strict(),
     limits: zod_1.z.object({ items: zod_1.z.literal(50), bytes: zod_1.z.literal(65536), sourceMs: zod_1.z.literal(2000), totalMs: zod_1.z.literal(10000) }).strict(),
     sections: zod_1.z.object(Object.fromEntries(exports.SECTION_NAMES.map(name => [name, exports.maestroSectionSchema]))).strict(),
     gaps: zod_1.z.array(text).max(100), conflicts: zod_1.z.array(text).max(100),
+    // RM-052: o que o panorama NAO le (roadmap, reservas, outras maquinas): lacuna declarada nunca vira "vazio".
+    notConsulted: zod_1.z.array(text).max(20).optional(),
 }).strict();
 function validateMaestroSnapshot(input) {
     const value = exports.maestroSnapshotSchema.parse(input);

package/dist/maestro-discovery.js

@@ -42,6 +42,20 @@ const node_crypto_1 = require("node:crypto");
 const manifest_1 = require("./manifest");
 const estado_thread_1 = require("./estado-thread");
 const thread_1 = require("./thread");
+const projeto_alvo_1 = require("./projeto-alvo");
+/**
+ * RM-052: o panorama le threads, sessoes e filas deste projeto nesta maquina. Roadmap, reservas e
+ * as outras maquinas NAO entram nele; quem le o panorama precisa saber disso para nao concluir
+ * "roadmap vazio" a partir de zero threads, que foi o incidente de 29/09.
+ */
+function consultaDoMaestro(value, countOtherProjects) {
+    const loaded = (0, manifest_1.carregarManifesto)(value.root);
+    const others = countOtherProjects ? (0, projeto_alvo_1.outrosProjetosConhecidos)(value.root) : 0;
+    return { ...value, project: { ...value.project, root: (0, projeto_alvo_1.raizParaExibir)(value.root),
+            remote: (0, projeto_alvo_1.remotoDoProjeto)(value.root, loaded?.manifesto.fabrica?.remoto ?? 'origin') },
+        notConsulted: [projeto_alvo_1.FORA_DA_CONSULTA.roadmap, projeto_alvo_1.FORA_DA_CONSULTA.reservas, projeto_alvo_1.FORA_DA_CONSULTA.outrasMaquinas,
+            ...(others > 0 ? [`outros projetos desta máquina: ${others} (ork projetos)`] : [])] };
+}
 const inside = (root, file) => file === root || file.startsWith(root + path.sep);
 function physical(file) {
     const absolute = path.resolve(file);
@@ -121,9 +135,9 @@ function discoverMaestro(options) {
                 if (fs.lstatSync(file).isSymbolicLink() && fs.realpathSync(file) !== target)
                     throw Error('maestro.project.scope');
             }
-        return context(canonical, 'worktree');
+        return consultaDoMaestro(context(canonical, 'worktree'), options.countOtherProjects !== false);
     }
-    return context(chosen, origin);
+    return consultaDoMaestro(context(chosen, origin), options.countOtherProjects !== false);
 }
 function revalidateMaestroContext(value) {
     const current = context(value.root, value.project.origin);

package/dist/maestro-runtime.js

@@ -47,6 +47,7 @@ const hitl_sessions_1 = require("./hitl-sessions");
 const thread_1 = require("./thread");
 const hitl_gates_1 = require("./hitl-gates");
 const ocupacao_1 = require("./ocupacao");
+const ledger_1 = require("./ledger");
 const horario_1 = require("./horario");
 const conducao_1 = require("./conducao");
 const conducao_texto_1 = require("./conducao-texto");
@@ -95,6 +96,8 @@ function operationalSources(reader, threads, native = [], now = new Date().toISO
             events = raw.split('\n').filter(Boolean).map(line => JSON.parse(line));
             if (events.some(e => typeof e.tipo !== 'string' || e.thread !== t.id))
                 throw Error('invalid');
+            // Fatia 2 do ensaio da 0.5.0 (P2): o ensaio (`dryRun: true`) nao vira bloqueio nem entrega incompleta.
+            events = events.filter(e => !(0, ledger_1.ehEnsaio)(e));
         }
         catch {
             for (const name of names.filter(n => !['leases', 'retries'].includes(n)))

package/dist/maestro-snapshot.js

@@ -51,9 +51,13 @@ function maestroSnapshot(context, options = {}) {
             coverage: { total: unavailable ? null : all.length, offset, returned: items.length, omitted: unavailable ? null : omitted,
                 nextOffset: omitted ? offset + items.length : null, limit: 50 }, items, gaps: publicMessages(src?.gaps ?? ['maestro.source.unavailable'], 4) };
     }
+    // RM-052: raiz e remoto passam pela mesma redacao dos demais campos publicos.
+    const { root, remote } = context.project;
     const result = { schema: maestro_contract_1.MAESTRO_SCHEMA, observedAt, fingerprint: (0, maestro_sources_1.digest)([context.fingerprint, sources.fingerprint]),
-        project: { ...context.project, name: (0, maestro_sources_1.safeText)(context.project.name) }, limits: maestro_contract_1.MAESTRO_LIMITS, sections, gaps: publicMessages(sources.gaps, 12),
-        conflicts: publicMessages([...sources.conflicts, ...(!stable ? ['maestro.snapshot.stale'] : [])], 12) };
+        project: { ...context.project, name: (0, maestro_sources_1.safeText)(context.project.name), ...(root === undefined ? {} : { root: (0, maestro_sources_1.safeText)(root) }),
+            ...(remote === undefined ? {} : { remote: remote === null ? null : (0, maestro_sources_1.safeText)(remote) }) }, limits: maestro_contract_1.MAESTRO_LIMITS, sections, gaps: publicMessages(sources.gaps, 12),
+        conflicts: publicMessages([...sources.conflicts, ...(!stable ? ['maestro.snapshot.stale'] : [])], 12),
+        ...(context.notConsulted ? { notConsulted: publicMessages(context.notConsulted, 19) } : {}) };
     // Orçamento incremental; mantém um item por seção para nextOffset avançar.
     const sizes = new Map(Object.values(sections).map(s => [s, Buffer.byteLength(JSON.stringify(s))]));
     let bytes = Buffer.byteLength(JSON.stringify(result));