@orkastery/cli 0.4.3 → 0.5.0

package/dist/network-roadmap.js

@@ -0,0 +1,907 @@
+"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.ErroDoPedidoDeProjeto = exports.SAIDA_DO_PEDIDO = exports.LIMIAR_SEM_BATIDA_MS = exports.CONTRATO_REGISTRO_DE_PROJETOS = exports.CONTRATO_PANORAMA_DA_REDE = void 0;
+exports.projetosConhecidos = projetosConhecidos;
+exports.resolverProjeto = resolverProjeto;
+exports.montarPanoramaDaRede = montarPanoramaDaRede;
+exports.textoDoPanoramaDaRede = textoDoPanoramaDaRede;
+/**
+ * RM-054 (fatia 1): o roadmap da rede, de qualquer diretorio.
+ *
+ * Em 29/09/2026 o dono pediu pelo Telegram o status do roadmap do orkastery e recebeu o panorama
+ * do cwd do gateway (projeto `workspace`, 0 threads), lido como "roadmap vazio". O roadmap real
+ * tinha 13 itens reservados e 10 threads na `vps`. Este modulo junta, para cada projeto pedido:
+ *
+ *  - o status report do RM-048 (`ork.roadmap-status/v1`), com as threads de TODAS as maquinas;
+ *  - as reservas (`ork/roadmap-reservas`);
+ *  - as threads de cada maquina (`ork/fabrica-estado`), com a idade da ultima batida;
+ *  - a fonte e o horario de cada parte, e o que ficou sem ler como lacuna tipada.
+ *
+ * Com clone nesta maquina, o roadmap vem de `docs/roadmap` da BASE REMOTA (D1 do PLAN): toda
+ * maquina ve o mesmo roadmap, qualquer que seja a branch do checkout. As branches de estado vem
+ * pelo fetch de sempre, e esta maquina entra pelo estado local fresco, no lugar do retrato
+ * publicado dela (D6). Sem clone, tudo vem da forja, so com consulta (`forja.ts`).
+ *
+ * As lacunas usam o vocabulario da rede (RM-053) e nunca viram "vazio": o que nao foi lido e dito
+ * com o tipo e o que fazer. `naoConsultado` diz o que esta leitura nao olhou. Leitura pura: nada e
+ * gravado no estado do `ork` nem na forja; o unico efeito e o `git fetch` de sempre nas refs
+ * remotas do clone, e `semRemoto` o desliga.
+ *
+ * Na fatia 2, os hosts chegam aqui por dois modos: `host` (gateway sem cwd de projeto, a regra da
+ * RM-052 no `--projeto` proprio do `network`) e `fixado` (o servidor MCP, que le so o projeto dele).
+ */
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const branch_de_estado_1 = require("./branch-de-estado");
+const docs_1 = require("./docs");
+const fabrica_estado_1 = require("./fabrica-estado");
+const forja_1 = require("./forja");
+const horario_1 = require("./horario");
+const estado_thread_1 = require("./estado-thread");
+const manifest_1 = require("./manifest");
+const maquina_1 = require("./maquina");
+const modos_1 = require("./modos");
+const projeto_alvo_1 = require("./projeto-alvo");
+const roadmap_reservas_1 = require("./roadmap-reservas");
+const roadmap_status_1 = require("./roadmap-status");
+const thread_1 = require("./thread");
+const versao_1 = require("./versao");
+const yaml_1 = require("./yaml");
+exports.CONTRATO_PANORAMA_DA_REDE = 'ork.network-roadmap/v1';
+/** O registro de projetos da RM-052, lido como ela o grava. */
+exports.CONTRATO_REGISTRO_DE_PROJETOS = 'ork.projetos/v1';
+/** Maquina sem retrato novo ha mais disto esta sem batida: o mesmo limiar da rede (RM-053, `SEM_BATIDA_MS`). */
+exports.LIMIAR_SEM_BATIDA_MS = 3 * 60 * 60 * 1000;
+/** A recusa de projeto sai com o mesmo codigo da RM-052. */
+exports.SAIDA_DO_PEDIDO = 4;
+/** A recusa do `--projeto`, com os mesmos codigos da RM-052: o nucleo nunca chuta. */
+class ErroDoPedidoDeProjeto extends Error {
+    codigo;
+    detalhe;
+    candidatos;
+    correcao;
+    constructor(codigo, detalhe, candidatos, correcao) {
+        super(`${codigo}: ${detalhe}`);
+        this.codigo = codigo;
+        this.detalhe = detalhe;
+        this.candidatos = candidatos;
+        this.correcao = correcao;
+        this.name = 'ErroDoPedidoDeProjeto';
+    }
+    get recusa() {
+        return { erro: this.codigo, detalhe: this.detalhe, candidatos: this.candidatos, correcao: this.correcao };
+    }
+    get texto() {
+        return [`${this.codigo}: ${this.detalhe}`, ...(this.candidatos.length ? ['Candidatos:', ...this.candidatos.map((c) => `  • ${c}`)] : []),
+            this.correcao].join('\n');
+    }
+}
+exports.ErroDoPedidoDeProjeto = ErroDoPedidoDeProjeto;
+const lacuna = (tipo, parte, alvo, detalhe, correcao) => ({ tipo, parte, ...(alvo ? { alvo } : {}), detalhe, correcao });
+// ---------------------------------------------------------------------------
+// Os projetos: o do cwd, o do registro da RM-052 e o do pedido.
+// ---------------------------------------------------------------------------
+/**
+ * Nome de remoto do git, como `origin`. O valor vem do manifesto versionado (`fabrica.remoto`), e um
+ * valor que comece com `-` viraria opcao do `git fetch` (`--upload-pack=...`): so este formato chega
+ * ao git (achado 4 do CHECK).
+ */
+const REMOTO = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+/**
+ * Nome de branch base, como `main`. Tambem vem do manifesto (`worktree.base_branch`), e o `git log`
+ * da base o recebia cru: `--output=<arquivo>` gravava um arquivo (rodada 2 do CHECK).
+ */
+const baseValida = (base) => typeof base === 'string' && /^[A-Za-z0-9][A-Za-z0-9._/-]{0,99}$/.test(base) && !base.includes('..');
+function projetoDoClone(c, origem) {
+    const remoto = c.manifesto.fabrica.remoto;
+    const url = REMOTO.test(remoto) ? (0, branch_de_estado_1.git)(c.raiz, ['remote', 'get-url', remoto]) : null;
+    return { nome: c.manifesto.project.name, forja: url?.ok ? (0, forja_1.identidadeDaForja)(url.stdout.trim()) : null, raiz: c.raiz,
+        base: c.manifesto.worktree.base_branch, remoto, origem };
+}
+function mesmoProjeto(a, b) {
+    if ((0, forja_1.mesmaForja)(a.forja, b.forja))
+        return true;
+    if (!a.raiz || !b.raiz)
+        return false;
+    try {
+        return (0, estado_thread_1.raizDoEstado)(a.raiz) === (0, estado_thread_1.raizDoEstado)(b.raiz);
+    }
+    catch {
+        return false;
+    }
+}
+const obj = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+/**
+ * O registro da RM-052 (`~/.orkastery/projetos.json`, `ork.projetos/v1`): `projetos` como lista ou
+ * mapa por nome; de cada um, `nome`, `raiz` ou `caminho`, e `remoto`. Entrada que nao se le vira
+ * lacuna; arquivo ausente vai para o nao consultado.
+ */
+function projetosDoRegistro(arquivo) {
+    const lacunas = [];
+    const invalido = (detalhe) => lacuna('registro.invalido', 'registro', arquivo, detalhe, 'confira o registro com `ork projetos` (RM-052) ou peça o projeto com --projeto');
+    let bruto;
+    try {
+        bruto = JSON.parse(fs.readFileSync(arquivo, 'utf8'));
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return { projetos: [], lacunas, lido: false };
+        return { projetos: [], lacunas: [invalido('o registro de projetos não é um JSON legível')], lido: true };
+    }
+    if (!obj(bruto) || (bruto.contrato !== undefined && bruto.contrato !== exports.CONTRATO_REGISTRO_DE_PROJETOS)) {
+        return { projetos: [], lacunas: [invalido(`o registro não está no contrato ${exports.CONTRATO_REGISTRO_DE_PROJETOS}`)], lido: true };
+    }
+    const lista = Array.isArray(bruto.projetos) ? bruto.projetos
+        : obj(bruto.projetos) ? Object.entries(bruto.projetos).map(([nome, v]) => (obj(v) ? { nome, ...v } : v)) : null;
+    if (!lista)
+        return { projetos: [], lacunas: [invalido('o registro não traz a lista de projetos')], lido: true };
+    const projetos = [];
+    for (const e of lista) {
+        const nome = obj(e) && typeof e.nome === 'string' ? e.nome.trim() : '';
+        const raiz = obj(e) ? [e.raiz, e.caminho].find((v) => typeof v === 'string' && path.isAbsolute(v)) : undefined;
+        const remoto = obj(e) && typeof e.remoto === 'string' ? e.remoto : null;
+        let c = null;
+        try {
+            c = raiz && fs.existsSync(raiz) ? (0, manifest_1.carregarManifesto)(raiz) : null;
+        }
+        catch {
+            c = null;
+        }
+        const forja = remoto ? (0, forja_1.identidadeDaForja)(remoto) : null;
+        if (c)
+            projetos.push(projetoDoClone(c, 'registro'));
+        else if (nome && forja)
+            projetos.push({ nome, forja, raiz: null, base: null, remoto: 'origin', origem: 'registro' });
+        else
+            lacunas.push(invalido(`entrada ${nome || '(sem nome)'} sem clone nesta máquina e sem remoto de forja reconhecido`));
+    }
+    return { projetos, lacunas, lido: true };
+}
+/**
+ * Os projetos que esta maquina conhece, sem repetir: o do cwd primeiro, depois o registro. Com
+ * `host` (D-G6 da fatia 2), o cwd do gateway nao e projeto de ninguem: o projeto dele so entra pelo
+ * registro, e fora dele vai ao "nao consultado" dizendo por que. Foi ele que respondeu em 29/09.
+ */
+function projetosConhecidos(opcoes = {}) {
+    const cwd = opcoes.cwd ?? process.cwd();
+    const candidatos = [];
+    const doCwd = (0, manifest_1.carregarManifesto)(cwd);
+    const arquivo = opcoes.registro ?? path.join((0, maquina_1.pastaDoUsuario)(), 'projetos.json');
+    const registro = projetosDoRegistro(arquivo);
+    const naoConsultado = registro.lido ? [] : [`registro de projetos desta máquina (RM-052): ${arquivo} ausente`];
+    if (doCwd && !opcoes.host)
+        candidatos.push(projetoDoClone(doCwd, 'cwd'));
+    else if (doCwd) {
+        const doGateway = projetoDoClone(doCwd, 'cwd');
+        if (!registro.projetos.some((p) => mesmoProjeto(p, doGateway))) {
+            naoConsultado.push(`diretório do host (${raizParaExibir(doCwd.raiz)}): o projeto ${doGateway.nome} está fora do registro desta ` +
+                'máquina, e o ork não lê projeto pelo diretório do gateway (RM-052); para entrar, `ork projetos registrar <caminho>`');
+        }
+    }
+    candidatos.push(...registro.projetos);
+    const projetos = [];
+    for (const p of candidatos) {
+        const i = projetos.findIndex((q) => mesmoProjeto(q, p));
+        if (i < 0)
+            projetos.push(p);
+        else if (!projetos[i].raiz && p.raiz)
+            projetos[i] = p;
+    }
+    return { projetos, lacunas: registro.lacunas, naoConsultado };
+}
+const rotuloDoProjeto = (p) => [p.nome, p.forja ? (0, forja_1.rotuloDaForja)(p.forja) : null, p.raiz ? raizParaExibir(p.raiz) : null].filter(Boolean).join(' · ');
+function raizParaExibir(raiz) {
+    try {
+        return (0, estado_thread_1.raizDoEstado)(raiz);
+    }
+    catch {
+        return raiz;
+    }
+}
+/** Caminho explicito: absoluto, `./`, `../` ou `~/`. Nome sozinho e sempre nome (achado 2 do CHECK). */
+const ehCaminho = (t) => path.isAbsolute(t) || /^(?:\.{1,2}|~)(?:\/|$)/.test(t);
+/** As forjas publicas que o host pode pedir sem registro, cada uma com o tipo dela. */
+const FORJAS_PUBLICAS = Object.freeze({ 'github.com': 'github', 'gitlab.com': 'gitlab' });
+/**
+ * D-G4 (fatia 2): no host, o `--projeto` do `network` e o nome de um projeto (RM-052) ou a forja
+ * (`github:dono/repo`, `gitlab:grupo/repo`). Caminho apontaria o nucleo para qualquer pasta (D4 da
+ * RM-052) e URL pode levar credencial: nenhum dos dois entra, e o texto pedido nao volta na recusa.
+ * A forja tambem so vale num host conhecido (GO-FIX 1 do CHECK): `github.com`, `gitlab.com` ou o
+ * host de um projeto do registro. Com host livre, o texto do modelo levaria o `gh`/`glab` a qualquer
+ * servidor (`gitlab:169.254.169.254/a/b`), e um `GITLAB_TOKEN` do ambiente iria junto.
+ */
+function exigirPedidoDoHost(pedido, conhecidos) {
+    const t = pedido.trim();
+    if (projeto_alvo_1.PADRAO_DO_NOME_DE_PROJETO.test(t))
+        return;
+    const candidatos = conhecidos.map(rotuloDoProjeto);
+    const forja = /^(?:github|gitlab):/i.test(t) ? (0, forja_1.forjaDoArgumento)(t) : null;
+    if (!forja) {
+        throw new ErroDoPedidoDeProjeto('projeto.desconhecido', 'no host, --projeto é o nome de um projeto registrado ou a forja (github:dono/repo, gitlab:grupo/repo); caminho e URL não são aceitos', candidatos, 'peça pelo nome de `ork projetos` (ex.: orkastery) ou por github:dono/repo');
+    }
+    const publica = FORJAS_PUBLICAS[forja.host] === forja.tipo;
+    if (publica || conhecidos.some((p) => p.forja && p.forja.host === forja.host && p.forja.tipo === forja.tipo))
+        return;
+    throw new ErroDoPedidoDeProjeto('projeto.desconhecido', 'no host, a forja pedida precisa ser github.com, gitlab.com ou a de um projeto registrado nesta máquina', candidatos, 'peça por github:dono/repo ou gitlab:grupo/repo; grupo com ponto no GitLab vai com o host: gitlab:gitlab.com/grupo/repo');
+}
+/**
+ * D9: o `--projeto`. `github:`/`gitlab:`/URL, caminho explicito com manifesto, ou o nome (ou
+ * `dono/repo`) de um projeto conhecido. Uma pasta do cwd com o mesmo nome nao toma o pedido: o nome
+ * so vira caminho escrito como caminho. Ambiguo ou desconhecido recusa com os candidatos.
+ */
+function resolverProjeto(pedido, conhecidos, cwd = process.cwd()) {
+    const candidatos = conhecidos.map(rotuloDoProjeto);
+    const forja = (0, forja_1.forjaDoArgumento)(pedido);
+    if (forja) {
+        const conhecido = conhecidos.find((p) => (0, forja_1.mesmaForja)(p.forja, forja));
+        return conhecido ? { ...conhecido, origem: 'argumento' }
+            : { nome: forja.repo.split('/').pop(), forja, raiz: null, base: null, remoto: 'origin', origem: 'argumento' };
+    }
+    const texto = pedido.trim();
+    if (ehCaminho(texto)) {
+        const caminho = path.resolve(cwd, texto.replace(/^~(?=$|\/)/, os.homedir()));
+        if (!fs.existsSync(caminho) || !fs.statSync(caminho).isDirectory()) {
+            throw new ErroDoPedidoDeProjeto('projeto.desconhecido', `${caminho} não existe nesta máquina`, candidatos, 'confira o caminho do clone, ou peça pela forja: --projeto github:dono/repo');
+        }
+        const c = (0, manifest_1.carregarManifesto)(caminho);
+        if (!c) {
+            throw new ErroDoPedidoDeProjeto('projeto.sem-manifesto', `${caminho} não tem ${manifest_1.NOME_MANIFESTO}`, candidatos, 'rode `ork init` nesse clone, ou peça pela forja: --projeto github:dono/repo');
+        }
+        // O caminho pedido e a raiz do projeto, nunca uma pasta dentro de outro (rodada 2 do CHECK).
+        const real = (x) => { try {
+            return fs.realpathSync(x);
+        }
+        catch {
+            return path.resolve(x);
+        } };
+        if (real(c.raiz) !== real(caminho)) {
+            throw new ErroDoPedidoDeProjeto('projeto.sem-manifesto', `${caminho} não é a raiz de um projeto: o manifesto mais próximo está em ${c.raiz}`, candidatos, `se é esse o projeto, peça --projeto ${c.raiz}`);
+        }
+        return projetoDoClone(c, 'argumento');
+    }
+    const alvo = texto.toLowerCase();
+    const achados = conhecidos.filter((p) => p.nome.toLowerCase() === alvo ||
+        (p.forja && (p.forja.repo.toLowerCase() === alvo || p.forja.repo.split('/').pop().toLowerCase() === alvo)));
+    if (achados.length === 1)
+        return { ...achados[0], origem: 'argumento' };
+    if (achados.length > 1) {
+        throw new ErroDoPedidoDeProjeto('projeto.ambiguo', `"${pedido}" casa ${achados.length} projetos conhecidos`, achados.map(rotuloDoProjeto), 'peça pelo caminho do clone ou por github:dono/repo');
+    }
+    throw new ErroDoPedidoDeProjeto('projeto.desconhecido', `"${pedido}" não é um projeto conhecido nesta máquina`, candidatos, 'peça por github:dono/repo, por gitlab:grupo/repo ou pelo caminho do clone escrito como caminho (./pasta ou absoluto)');
+}
+// ---------------------------------------------------------------------------
+// Leitura: fatos comuns ao clone e a forja.
+// ---------------------------------------------------------------------------
+/** O inicio do dia do dono, com uma hora de folga para a virada do horario de verao. */
+function inicioDoDia(quando, fuso) {
+    const p = (0, horario_1.partesLocais)(quando, fuso);
+    const decorrido = ((Number(p.hora) * 60 + Number(p.minuto)) * 60 + Number(p.segundo)) * 1000;
+    return new Date(Date.parse(quando) - decorrido - 60 * 60 * 1000).toISOString();
+}
+/** D8: as threads entregues hoje, pelo merge `ship(<thread>)` na base com a data de hoje no fuso do dono. */
+function entreguesHoje(commits, quando, fuso) {
+    const hoje = (0, horario_1.dataLocal)(quando, fuso), ids = new Set();
+    for (const c of commits) {
+        const m = /^ship\(([A-Za-z0-9._-]+)\)/.exec(c.assunto);
+        if (m && Number.isFinite(Date.parse(c.data)) && (0, horario_1.dataLocal)(c.data, fuso) === hoje)
+            ids.add(m[1]);
+    }
+    return ids;
+}
+function docsDosArquivos(arquivos, lacunas) {
+    const docs = [];
+    for (const a of arquivos) {
+        if (!(0, docs_1.ehPaginaDeDocs)(path.posix.basename(a.caminho)))
+            continue;
+        if (a.texto === null) {
+            lacunas.push(lacuna('roadmap.pagina-invalida', 'roadmap', a.caminho, 'página binária ou grande demais para ler: ficou de fora', 'confira o arquivo na base do projeto'));
+            continue;
+        }
+        const lido = (0, docs_1.documentoDeTexto)(a.caminho, a.texto);
+        if ('doc' in lido)
+            docs.push(lido.doc);
+        else
+            lacunas.push(lacuna('roadmap.pagina-invalida', 'roadmap', a.caminho, `${lido.achado.mensagem}: ficou de fora`, 'rode `ork docs verificar` no projeto'));
+    }
+    return docs;
+}
+function jsonsDosArquivos(arquivos, valido, invalido, lacunas) {
+    const saida = [];
+    for (const a of arquivos) {
+        if (!a.caminho.endsWith('.json'))
+            continue;
+        let v;
+        try {
+            v = a.texto === null ? undefined : JSON.parse(a.texto);
+        }
+        catch {
+            v = undefined;
+        }
+        if (valido(v))
+            saida.push(v);
+        else
+            lacunas.push(invalido(a.caminho));
+    }
+    return saida;
+}
+const reservasDosArquivos = (arquivos, lacunas) => jsonsDosArquivos(arquivos, roadmap_reservas_1.reservaValida, (c) => lacuna('reserva.invalida', 'reservas', c, 'reserva ilegível ou de outro contrato: ficou de fora', 'confira a branch ork/roadmap-reservas'), lacunas)
+    .sort((a, b) => a.item.localeCompare(b.item));
+const retratosDosArquivos = (arquivos, lacunas) => jsonsDosArquivos(arquivos, retratoLegivel, (c) => lacuna('retrato.invalido', 'fabrica', c, 'retrato ilegível ou de outro contrato: a máquina ficou de fora', 'a máquina republica com `ork fabrica publicar --forcar`'), lacunas)
+    .sort((a, b) => a.maquina.localeCompare(b.maquina));
+/** Um campo de texto do manifesto lido da base pela forja (`secao.chave`), ou null. */
+function campoDoManifesto(texto, secao, chave) {
+    if (!texto)
+        return null;
+    try {
+        const dados = (0, yaml_1.lerYaml)(texto);
+        const mapa = dados && typeof dados === 'object' && !Array.isArray(dados) ? dados[secao] : undefined;
+        const valor = mapa && typeof mapa === 'object' && !Array.isArray(mapa) ? mapa[chave] : undefined;
+        return typeof valor === 'string' && valor.trim() ? valor.trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** O nome do projeto no manifesto lido, para o titulo dizer o nome certo. */
+const nomeDoManifesto = (texto) => campoDoManifesto(texto, 'project', 'name');
+/** A branch base do manifesto lido (achado 7 do CHECK), so com formato de nome de branch. */
+function baseDoManifesto(texto) {
+    const base = campoDoManifesto(texto, 'worktree', 'base_branch');
+    return baseValida(base) ? base : null;
+}
+const pontuar = (texto) => {
+    const limpo = String(texto).trim();
+    return /[.?!]$/.test(limpo) ? limpo : `${limpo}.`;
+};
+/**
+ * O retrato lido de fora so vale inteiro: alem do contrato, os tipos que o panorama usa e uma batida
+ * legivel. Pergunta que nao e texto derrubava o comando, e `publicadoEm` ilegivel nunca virava
+ * "sem batida" (achado 6 do CHECK).
+ */
+function retratoLegivel(v) {
+    if (!(0, fabrica_estado_1.estadoValido)(v))
+        return false;
+    const textoOuNulo = (x) => x === null || x === undefined || typeof x === 'string';
+    return typeof v.por === 'string' && Number.isFinite(Date.parse(v.publicadoEm)) && v.threads.every((t) => typeof t.status === 'string' && typeof t.modo === 'string' && typeof t.esperaVoce === 'boolean' &&
+        textoOuNulo(t.roadmap) && textoOuNulo(t.pergunta) && textoOuNulo(t.entregue) && textoOuNulo(t.paradaDesde) &&
+        textoOuNulo(t.runtime) && textoOuNulo(t.modelo) && textoOuNulo(t.esforco));
+}
+function fatosDoRetrato(m, entregues, itemDaReserva) {
+    return m.threads.map((t) => ({
+        id: t.id, roadmap: t.roadmap ?? itemDaReserva.get(t.id) ?? null, aberta: t.status !== 'fechada', fase: t.fase,
+        entregueHoje: () => entregues.has(t.id),
+        espera: () => t.esperaVoce ? { thread: t.id, pergunta: pontuar(t.pergunta ?? 'o veredito da pausa'), maquina: m.maquina } : undefined,
+        maquina: m.maquina,
+    }));
+}
+function fatosDaMaquinaLocal(raiz, quando, fuso, maquina, entregues, itemDaReserva) {
+    return (0, roadmap_status_1.fatosLocais)(raiz, quando, fuso).map((f) => ({
+        ...f, roadmap: f.roadmap ?? itemDaReserva.get(f.id) ?? null, maquina,
+        entregueHoje: () => entregues.has(f.id) || f.entregueHoje(),
+        espera: () => { const e = f.espera(); return e ? { ...e, maquina } : undefined; },
+    }));
+}
+function maquinasDoPanorama(retratos, local, ctx, lacunas) {
+    const agora = Date.parse(ctx.quando);
+    const saida = [];
+    for (const m of retratos) {
+        if (local && m.maquina === local.maquina)
+            continue;
+        const idadeMs = Math.max(0, agora - Date.parse(m.publicadoEm));
+        const semBatida = idadeMs > exports.LIMIAR_SEM_BATIDA_MS;
+        if (semBatida) {
+            lacunas.push(lacuna('maquina.sem-batida', 'fabrica', m.maquina, `${m.maquina} sem retrato novo há ${(0, horario_1.duracaoCurta)(Math.floor(idadeMs / 60000))} (último em ${(0, horario_1.formatarDataHora)(m.publicadoEm, { fuso: ctx.fuso })}): ` +
+                'as threads dela podem ter andado', `confira a ${m.maquina}: ela publica ao criar thread, despachar fase, entregar e a cada batida do pulse`));
+        }
+        saida.push({ maquina: m.maquina, por: m.por, publicadoEm: m.publicadoEm, idadeMin: Math.floor(idadeMs / 60000), semBatida,
+            estaMaquina: m.maquina === ctx.maquina, origem: 'retrato', versaoOrk: m.versaoOrk ?? null,
+            ativas: m.threads.filter((t) => !t.entregue), entreguesSemMaster: m.threads.filter((t) => t.entregue).length });
+    }
+    if (local) {
+        saida.push({ maquina: local.maquina, por: local.por, publicadoEm: local.publicadoEm, idadeMin: 0, semBatida: false, estaMaquina: true,
+            origem: 'estado-local', versaoOrk: local.versaoOrk, ativas: local.threads.filter((t) => !t.entregue),
+            entreguesSemMaster: local.threads.filter((t) => t.entregue).length });
+    }
+    return saida.sort((a, b) => a.maquina.localeCompare(b.maquina));
+}
+function montarProjeto(p, d, ctx, fontes, lacunas) {
+    const itemDaReserva = new Map((d.reservas ?? []).filter((r) => r.thread).map((r) => [r.thread, r.item]));
+    const entregues = entreguesHoje(d.commits, ctx.quando, ctx.fuso);
+    const fatos = [], ids = new Set();
+    const somar = (f) => { if (!ids.has(f.id)) {
+        ids.add(f.id);
+        fatos.push(f);
+    } };
+    if (d.local)
+        fatosDaMaquinaLocal(d.local.raiz, ctx.quando, ctx.fuso, d.local.retrato.maquina, entregues, itemDaReserva).forEach(somar);
+    for (const m of d.retratos ?? [])
+        if (!d.local || m.maquina !== d.local.retrato.maquina)
+            fatosDoRetrato(m, entregues, itemDaReserva).forEach(somar);
+    // Entregue hoje e ja fechada: nao esta em retrato nenhum, mas o merge na base e o fato do dia.
+    for (const id of entregues)
+        somar({ id, roadmap: itemDaReserva.get(id) ?? null, aberta: false, fase: 'SHIP', entregueHoje: () => true,
+            espera: () => undefined });
+    const maquinas = d.retratos || d.local ? maquinasDoPanorama(d.retratos ?? [], d.local?.retrato ?? null, ctx, lacunas) : null;
+    return {
+        projeto: { nome: d.nome, forja: p.forja ? (0, forja_1.rotuloDaForja)(p.forja) : null, clone: p.raiz ? raizParaExibir(p.raiz) : null,
+            base: p.base, origem: p.origem, fuso: ctx.fuso },
+        roadmap: d.docs ? (0, roadmap_status_1.montarStatusDeFatos)(d.docs, fatos, { quando: ctx.quando, projeto: d.nome }) : null,
+        reservas: d.reservas, maquinas, fontes, lacunas,
+    };
+}
+// ---------------------------------------------------------------------------
+// Leitura pelo clone.
+// ---------------------------------------------------------------------------
+/**
+ * Os blobs de um diretorio da ponta, lidos de uma vez: `ls-tree -z` (o caminho vem cru, e nome
+ * nao-ASCII nao ganha aspas, achado 3 do CHECK) e um `cat-file --batch` para todos (achado 9).
+ * null: o diretorio nao existe na ponta.
+ */
+function arquivosDaPonta(raiz, ponta, dir) {
+    const ls = (0, node_child_process_1.spawnSync)('git', ['ls-tree', '-z', ponta, '--', `${dir}/`], { cwd: raiz, encoding: 'utf8', timeout: 60000,
+        maxBuffer: 16 * 1024 * 1024 });
+    if (ls.status !== 0 || !ls.stdout)
+        return null;
+    const blobs = ls.stdout.split('\0').map((l) => /^\d+ blob ([0-9a-f]+)\t([\s\S]+)$/.exec(l))
+        .filter((m) => !!m).map((m) => ({ sha: m[1], caminho: m[2] }));
+    if (!blobs.length)
+        return [];
+    const cat = (0, node_child_process_1.spawnSync)('git', ['cat-file', '--batch'], { cwd: raiz, input: blobs.map((b) => b.sha).join('\n') + '\n', timeout: 60000,
+        maxBuffer: 64 * 1024 * 1024 });
+    const textos = new Map();
+    if (cat.status === 0 && Buffer.isBuffer(cat.stdout)) {
+        const saida = cat.stdout;
+        for (let pos = 0; pos < saida.length;) {
+            const fim = saida.indexOf(0x0a, pos);
+            if (fim < 0)
+                break;
+            const cabeca = /^([0-9a-f]+) blob (\d+)$/.exec(saida.subarray(pos, fim).toString('utf8'));
+            if (!cabeca) {
+                pos = fim + 1;
+                continue;
+            }
+            const tamanho = Number(cabeca[2]);
+            textos.set(cabeca[1], saida.subarray(fim + 1, fim + 1 + tamanho).toString('utf8'));
+            pos = fim + 1 + tamanho + 1;
+        }
+    }
+    return blobs.map((b) => ({ caminho: b.caminho, texto: textos.get(b.sha) ?? null }));
+}
+function commitsDoClone(raiz, ponta, desde) {
+    const r = (0, branch_de_estado_1.git)(raiz, ['log', ponta, `--since=${desde}`, '--format=%H%x09%cI%x09%s']);
+    if (!r.ok)
+        return [];
+    return r.stdout.split('\n').filter(Boolean).map((l) => {
+        const [commit, data, ...assunto] = l.split('\t');
+        return { commit, data, assunto: assunto.join('\t') };
+    });
+}
+/**
+ * O retrato desta maquina quando o completo nao se monta: um thread.json que nao abre derrubava o
+ * `retratoDaMaquina` inteiro, e todas as threads dela sumiam da rede. Aqui entram as legiveis, com a
+ * espera do dono do RM-048, e a conta das que ficaram de fora (achado 1 da rodada 2 do CHECK).
+ */
+function retratoTolerante(c, ctx, remoto) {
+    const raiz = c.raiz;
+    const entregas = (0, fabrica_estado_1.entregasNaBase)(raiz, c.manifesto.worktree.base_branch, remoto);
+    const threads = [];
+    let ilegiveis = 0;
+    for (const id of (0, thread_1.listarIds)(raiz)) {
+        try {
+            const t = (0, thread_1.lerThread)(raiz, id);
+            if (t.status === 'fechada')
+                continue;
+            const entregue = entregas.get(t.id) ?? null;
+            let espera;
+            try {
+                espera = entregue ? undefined : (0, roadmap_status_1.esperaDoDono)(raiz, t, ctx.quando);
+            }
+            catch {
+                espera = undefined;
+            }
+            threads.push({ id: t.id, nome: t.nome, modo: (0, modos_1.tagDoModo)(t.modo), fase: t.faseAtual, status: t.status, roadmap: t.roadmap ?? null,
+                branch: t.base?.branch ?? null, atualizadaEm: t.atualizadaEm ?? null, entregue, esperaVoce: !!espera,
+                pergunta: espera?.pergunta ?? null, paradaDesde: null, ...(0, fabrica_estado_1.despachoDaThread)((0, thread_1.dirThread)(raiz, t.id)) });
+        }
+        catch {
+            ilegiveis++;
+        }
+    }
+    const eu = (0, roadmap_reservas_1.quemSouEu)(raiz, { maquina: ctx.maquina });
+    return { ilegiveis, retrato: { contrato: fabrica_estado_1.CONTRATO_MAQUINA, maquina: eu.maquina, por: eu.por, projeto: c.manifesto.project.name,
+            versaoOrk: versao_1.VERSAO_DO_ORK, publicadoEm: ctx.quando, threads: threads.sort((a, b) => a.id.localeCompare(b.id)) } };
+}
+/**
+ * A espera do dono das threads desta maquina pela mesma definicao do roadmap (RM-048), no retrato
+ * completo e no tolerante: o monitor do retrato publicado usa outra regra, e a secao de maquinas
+ * contradizia o "O que precisa de voce" do mesmo panorama (rodada 3 do CHECK).
+ */
+function comEsperaDoRoadmap(r, raiz, ctx) {
+    const fatos = new Map((0, roadmap_status_1.fatosLocais)(raiz, ctx.quando, ctx.fuso).map((f) => [f.id, f]));
+    return { ...r, threads: r.threads.map((t) => {
+            if (t.entregue)
+                return t;
+            let e;
+            try {
+                e = fatos.get(t.id)?.espera();
+            }
+            catch {
+                return t;
+            }
+            return { ...t, esperaVoce: !!e, pergunta: e ? e.pergunta : null, paradaDesde: e ? t.paradaDesde : null };
+        }) };
+}
+function lerProjetoDoClone(p, geral) {
+    const raiz = p.raiz, remoto = p.remoto, base = p.base ?? 'main';
+    const fontes = [], lacunas = [];
+    const carregado = (0, manifest_1.carregarManifesto)(raiz);
+    // O fuso do dono deste projeto vale para o dia e os horarios dele (achado 5 do CHECK).
+    const ctx = { ...geral, fuso: carregado?.manifesto.owner?.timezone ?? geral.fuso };
+    if (!REMOTO.test(remoto)) {
+        lacunas.push(lacuna('projeto.remoto-invalido', 'projeto', raizParaExibir(raiz), `fabrica.remoto do manifesto (${JSON.stringify(remoto).slice(0, 60)}) não é nome de remoto do git: nada foi lido pelo git`, 'corrija fabrica.remoto no orkastery.yaml (padrão: origin)'));
+        return montarProjeto(p, { nome: p.nome, docs: null, reservas: null, retratos: null, local: null, commits: [] }, ctx, fontes, lacunas);
+    }
+    if (!baseValida(p.base ?? 'main') || (carregado && !baseValida(carregado.manifesto.worktree.base_branch))) {
+        lacunas.push(lacuna('projeto.base-invalida', 'projeto', raizParaExibir(raiz), `worktree.base_branch do manifesto (${JSON.stringify(carregado?.manifesto.worktree.base_branch ?? p.base).slice(0, 60)}) ` +
+            'não é nome de branch: nada foi lido pelo git', 'corrija worktree.base_branch no orkastery.yaml (padrão: main)'));
+        return montarProjeto(p, { nome: p.nome, docs: null, reservas: null, retratos: null, local: null, commits: [] }, ctx, fontes, lacunas);
+    }
+    // Uma tentativa de rede por projeto: remoto que nao respondeu nao segura as outras partes (achado 9 do CHECK).
+    let semRede = ctx.semRemoto ? 'opcao' : null;
+    const ler = (nome, prefixo, prazo) => {
+        if (semRede)
+            return { ponta: (0, branch_de_estado_1.pontaLocal)(raiz, remoto, nome), atualizado: false, tentou: false };
+        const r = (0, branch_de_estado_1.buscarBranch)(raiz, remoto, nome, prefixo, prazo);
+        if (!r.atualizado)
+            semRede = 'falhou';
+        return { ...r, tentou: true };
+    };
+    const porque = (tentou) => semRede === 'opcao' ? ' (--sem-remoto)'
+        : tentou ? `: a leitura de ${remoto} falhou` : `: a leitura de ${remoto} falhou antes, e não houve nova tentativa`;
+    const correcao = () => semRede === 'opcao' ? 'rode sem --sem-remoto para ler o remoto' : `confira a rede e o acesso a ${remoto} (git fetch)`;
+    const dataDe = (sha) => (0, branch_de_estado_1.git)(raiz, ['show', '-s', '--format=%cI', sha]).stdout.trim() || null;
+    /** Uma branch lida do clone: a fonte citada, e a lacuna quando a leitura nao e nova ou nao houve. */
+    const branch = (parte, nome, prefixo, prazo) => {
+        const r = ler(nome, prefixo, prazo), onde = `${remoto}/${nome}`;
+        if (r.ponta) {
+            const dataDoCommit = dataDe(r.ponta);
+            fontes.push({ parte, origem: 'clone', onde, ref: nome, commit: r.ponta, dataDoCommit, lidoEm: ctx.quando, atualizado: r.atualizado, existe: true });
+            if (!r.atualizado) {
+                lacunas.push(lacuna(`${parte}.sem-leitura`, parte, onde, `sem leitura nova de ${onde}${porque(r.tentou)}; ` +
+                    `vale a última cópia desta máquina, commit ${r.ponta.slice(0, 7)} de ${(0, horario_1.formatarDataHora)(dataDoCommit, { fuso: ctx.fuso })}`, correcao()));
+            }
+            return r.ponta;
+        }
+        if (r.atualizado) {
+            fontes.push({ parte, origem: 'clone', onde, ref: nome, commit: null, dataDoCommit: null, lidoEm: ctx.quando, atualizado: true, existe: false });
+            if (parte === 'roadmap') {
+                lacunas.push(lacuna('roadmap.sem-base', 'roadmap', onde, `a branch base ${nome} não existe em ${remoto}`, 'confira worktree.base_branch no orkastery.yaml'));
+            }
+            else if (parte === 'reservas') {
+                lacunas.push(lacuna('reservas.sem-branch', 'reservas', onde, `nenhuma reserva feita ainda: a branch ${nome} não existe em ${remoto}`, 'a primeira reserva a cria: `ork roadmap pegar RM-NNN`'));
+            }
+            else {
+                lacunas.push(lacuna('fabrica.sem-branch', 'fabrica', onde, `nenhuma máquina publicou ainda: a branch ${nome} não existe em ${remoto}`, 'cada máquina entra com `ork fabrica entrar`'));
+            }
+            return null;
+        }
+        lacunas.push(lacuna(`${parte}.sem-leitura`, parte, onde, `sem leitura de ${onde}${porque(r.tentou)}; esta máquina não tem cópia dela`, correcao()));
+        return null;
+    };
+    let docs = null, commits = [];
+    const pontaBase = branch('roadmap', base, 'rede', 30000);
+    if (pontaBase) {
+        docs = docsDosArquivos(arquivosDaPonta(raiz, pontaBase, docs_1.DIR_ROADMAP) ?? [], lacunas);
+        if (!docs.some((d) => d.tipo === 'roadmap')) {
+            lacunas.push(lacuna('roadmap.sem-itens', 'roadmap', `${remoto}/${base}`, `nenhuma página de item em ${docs_1.DIR_ROADMAP} na base ${base}`, 'o projeto ainda não tem roadmap como código: `ork docs init` e o modelo docs/roadmap/_modelo-item.md'));
+        }
+        commits = commitsDoClone(raiz, pontaBase, inicioDoDia(ctx.quando, ctx.fuso));
+    }
+    const pontaReservas = branch('reservas', roadmap_reservas_1.BRANCH_DE_RESERVAS, 'roadmap', 15000);
+    const reservas = pontaReservas ? reservasDosArquivos(arquivosDaPonta(raiz, pontaReservas, roadmap_reservas_1.DIR_DE_RESERVAS) ?? [], lacunas)
+        : fontes.some((f) => f.parte === 'reservas' && !f.existe) ? [] : null;
+    const pontaFabrica = branch('fabrica', fabrica_estado_1.BRANCH_DA_FABRICA, 'fabrica', 15000);
+    const retratos = pontaFabrica ? retratosDosArquivos(arquivosDaPonta(raiz, pontaFabrica, fabrica_estado_1.DIR_DA_FABRICA) ?? [], lacunas)
+        : fontes.some((f) => f.parte === 'fabrica' && !f.existe) ? [] : null;
+    // D6: esta maquina pelo estado local, lido agora. Estado que nao se le (thread.json corrompido) vira
+    // lacuna, e vale o retrato publicado dela, quando ha (achado 1 do CHECK).
+    let local = null;
+    if (carregado) {
+        try {
+            local = { raiz, retrato: (0, fabrica_estado_1.retratoDaMaquina)(carregado, { agora: ctx.quando, maquina: ctx.maquina, remoto }) };
+            fontes.push({ parte: 'estado-local', origem: 'estado-local', onde: path.join(raizParaExibir(raiz), '.orkastery'), ref: null, commit: null,
+                dataDoCommit: null, lidoEm: ctx.quando, atualizado: true, existe: true });
+        }
+        catch (e) {
+            const motivo = (0, forja_1.detalheSeguro)(e?.message ?? String(e)), onde = path.join(raizParaExibir(raiz), '.orkastery');
+            const correcao = 'confira as threads desta máquina com `ork thread list` e o thread.json que não abre';
+            try {
+                const t = retratoTolerante(carregado, ctx, remoto);
+                local = { raiz, retrato: t.retrato };
+                fontes.push({ parte: 'estado-local', origem: 'estado-local', onde, ref: null, commit: null, dataDoCommit: null, lidoEm: ctx.quando,
+                    atualizado: true, existe: true });
+                lacunas.push(lacuna('estado-local.sem-leitura', 'estado-local', onde, `o retrato local completo não se montou (${motivo}): ` +
+                    `${ctx.maquina} entra com as threads legíveis, e ${t.ilegiveis} ilegível(is) ficou(aram) de fora`, correcao));
+            }
+            catch {
+                lacunas.push(lacuna('estado-local.sem-leitura', 'estado-local', onde, `o estado local de ${ctx.maquina} não se leu (${motivo}): vale o retrato publicado dela, quando há`, correcao));
+            }
+        }
+    }
+    if (local)
+        local = { raiz, retrato: comEsperaDoRoadmap(local.retrato, raiz, ctx) };
+    return montarProjeto(p, { nome: p.nome, docs, reservas, retratos, local, commits }, ctx, fontes, lacunas);
+}
+// ---------------------------------------------------------------------------
+// Leitura pela forja, sem clone.
+// ---------------------------------------------------------------------------
+const CORRECAO_DA_FORJA = {
+    'forja.ausente': (cli) => `instale ${cli} e faça login (${cli} auth login); gateway e cron têm PATH curto`,
+    'forja.sem-login': (cli) => `rode ${cli} auth login nesta máquina; o ork nunca lê nem copia token`,
+    'forja.nao-encontrado': () => 'confira o nome (github:dono/repo) e se o login da forja enxerga o repositório',
+    'forja.tempo-esgotado': () => 'tente de novo: a forja não respondeu a tempo',
+    'forja.inacessivel': () => 'confira a rede e o status da forja',
+    'forja.resposta-invalida': () => 'a forja respondeu fora do formato esperado: registre o caso no RM-054',
+};
+function lerProjetoDaForja(p, geral) {
+    const forja = p.forja, rotulo = (0, forja_1.rotuloDaForja)(forja), cli = forja.tipo === 'github' ? 'gh' : 'glab';
+    const fontes = [];
+    const lacunas = [lacuna('projeto.sem-clone', 'projeto', rotulo, `sem clone de ${p.nome} nesta máquina: lido da forja, só consulta`, 'para somar as threads desta máquina, trabalhe num clone do projeto')];
+    const semLeitura = (d = {}) => montarProjeto(p, { nome: p.nome, docs: null, reservas: null, retratos: null,
+        local: null, commits: [], ...d }, geral, fontes, lacunas);
+    if (geral.semRemoto) {
+        lacunas.push(lacuna('forja.nao-consultada', 'forja', rotulo, '--sem-remoto: a forja não foi consultada e não há clone nesta máquina', 'rode sem --sem-remoto'));
+        return semLeitura();
+    }
+    const desde = inicioDoDia(geral.quando, geral.fuso);
+    const ler = (base) => (0, forja_1.lerDaForja)(forja, { base, desde, dirRoadmap: docs_1.DIR_ROADMAP, manifesto: manifest_1.NOME_MANIFESTO,
+        reservas: { branch: roadmap_reservas_1.BRANCH_DE_RESERVAS, dir: roadmap_reservas_1.DIR_DE_RESERVAS }, fabrica: { branch: fabrica_estado_1.BRANCH_DA_FABRICA, dir: fabrica_estado_1.DIR_DA_FABRICA },
+        lidoEm: geral.quando }, geral.executor);
+    let baseUsada = p.base;
+    let r = ler(p.base);
+    // Sem clone, a base e a do manifesto lido: se ele aponta outra branch, a leitura e refeita por ela.
+    const baseDoProjeto = r.ok && !p.base ? baseDoManifesto(r.leitura.base?.manifesto) : null;
+    if (r.ok && baseDoProjeto && r.leitura.base && baseDoProjeto !== r.leitura.base.ref) {
+        baseUsada = baseDoProjeto;
+        r = ler(baseDoProjeto);
+    }
+    if (!r.ok) {
+        lacunas.push(lacuna(r.erro.codigo, 'forja', rotulo, r.erro.detalhe, CORRECAO_DA_FORJA[r.erro.codigo](cli)));
+        return semLeitura();
+    }
+    const l = r.leitura;
+    const nome = nomeDoManifesto(l.base?.manifesto) ?? p.nome;
+    // A base que valeu vai para o projeto e para o texto, inclusive quando ela nao existe na forja.
+    const projeto = { ...p, base: baseUsada ?? l.base?.ref ?? null };
+    // O fuso do dono deste projeto vale para o dia e os horarios dele (achado 5 do CHECK). Ele so se
+    // conhece depois de ler o manifesto: se o dia dele comecou antes da janela pedida, os commits sao
+    // relidos desde o comeco do dia dele (achado 5 da rodada 2).
+    const ctx = { ...geral, fuso: (0, horario_1.normalizarFuso)(campoDoManifesto(l.base?.manifesto, 'owner', 'timezone')) ?? geral.fuso };
+    let commits = l.base?.commits ?? [], commitsParciais = l.base?.commitsParciais ?? false;
+    const inicioNoProjeto = inicioDoDia(ctx.quando, ctx.fuso);
+    if (l.base && Date.parse(inicioNoProjeto) < Date.parse(desde)) {
+        const h = (0, forja_1.lerCommitsDaForja)(forja, { commit: l.base.commit, desde: inicioNoProjeto }, geral.executor);
+        if (h.ok) {
+            commits = h.commits;
+            commitsParciais = h.parciais;
+        }
+        else {
+            lacunas.push(lacuna('roadmap.entregas-parciais', 'roadmap', `${rotulo}@${l.base.ref}`, `os commits desde o começo do dia no fuso do projeto (${ctx.fuso}) não vieram (${r.leitura.forja.host}: ${h.erro.codigo}): ` +
+                '"Entregue hoje" pode ter ficado incompleto', 'confira as entregas do dia no clone'));
+        }
+    }
+    for (const [parte, ponta] of [['roadmap', l.base], ['reservas', l.reservas], ['fabrica', l.fabrica]]) {
+        if (ponta?.parcial) {
+            lacunas.push(lacuna('forja.leitura-parcial', parte, `${rotulo}@${ponta.ref}`, 'a forja cortou a listagem em 100 arquivos: o resto não foi lido', 'leia pelo clone do projeto, que não tem esse corte'));
+        }
+    }
+    const fonte = (parte, ponta, ref) => {
+        fontes.push({ parte, origem: 'forja', onde: `${rotulo}@${ponta?.ref ?? ref}`, ref: ponta?.ref ?? ref, commit: ponta?.commit ?? null,
+            dataDoCommit: ponta?.dataDoCommit ?? null, lidoEm: l.lidoEm, atualizado: true, existe: !!ponta });
+    };
+    let docs = null;
+    fonte('roadmap', l.base, baseUsada ?? 'branch padrão');
+    if (l.base) {
+        docs = docsDosArquivos(l.base.arquivos ?? [], lacunas);
+        if (!docs.some((d) => d.tipo === 'roadmap')) {
+            lacunas.push(lacuna('roadmap.sem-itens', 'roadmap', `${rotulo}@${l.base.ref}`, `nenhuma página de item em ${docs_1.DIR_ROADMAP} na base ${l.base.ref}`, 'o projeto ainda não tem roadmap como código: `ork docs init` e o modelo docs/roadmap/_modelo-item.md'));
+        }
+        if (commitsParciais) {
+            lacunas.push(lacuna('roadmap.entregas-parciais', 'roadmap', `${rotulo}@${l.base.ref}`, 'a base teve mais de 100 commits hoje: "Entregue hoje" pode ter ficado incompleto', 'confira as entregas do dia no clone'));
+        }
+    }
+    else {
+        lacunas.push(lacuna('roadmap.sem-base', 'roadmap', rotulo, `${rotulo} não tem a branch ${baseUsada ?? 'padrão'}`, 'confira worktree.base_branch no orkastery.yaml do projeto'));
+    }
+    fonte('reservas', l.reservas, roadmap_reservas_1.BRANCH_DE_RESERVAS);
+    if (!l.reservas) {
+        lacunas.push(lacuna('reservas.sem-branch', 'reservas', `${rotulo}@${roadmap_reservas_1.BRANCH_DE_RESERVAS}`, `nenhuma reserva feita ainda: a branch ${roadmap_reservas_1.BRANCH_DE_RESERVAS} não existe em ${rotulo}`, 'a primeira reserva a cria: `ork roadmap pegar RM-NNN`'));
+    }
+    fonte('fabrica', l.fabrica, fabrica_estado_1.BRANCH_DA_FABRICA);
+    if (!l.fabrica) {
+        lacunas.push(lacuna('fabrica.sem-branch', 'fabrica', `${rotulo}@${fabrica_estado_1.BRANCH_DA_FABRICA}`, `nenhuma máquina publicou ainda: a branch ${fabrica_estado_1.BRANCH_DA_FABRICA} não existe em ${rotulo}`, 'cada máquina entra com `ork fabrica entrar`'));
+    }
+    return montarProjeto(projeto, { nome, docs,
+        reservas: l.reservas ? reservasDosArquivos(l.reservas.arquivos ?? [], lacunas) : [],
+        retratos: l.fabrica ? retratosDosArquivos(l.fabrica.arquivos ?? [], lacunas) : [],
+        local: null, commits }, ctx, fontes, lacunas);
+}
+// ---------------------------------------------------------------------------
+// O panorama.
+// ---------------------------------------------------------------------------
+/**
+ * Um projeto, isolado dos outros: o que o derruba vira lacuna dele, e os outros seguem (achado 1 do
+ * CHECK). O detalhe passa pela mesma redacao do erro da forja.
+ */
+function lerProjeto(p, ctx) {
+    const vazio = (l) => ({
+        projeto: { nome: p.nome, forja: p.forja ? (0, forja_1.rotuloDaForja)(p.forja) : null, clone: p.raiz ? raizParaExibir(p.raiz) : null, base: p.base,
+            origem: p.origem, fuso: ctx.fuso },
+        roadmap: null, reservas: null, maquinas: null, fontes: [], lacunas: [l]
+    });
+    try {
+        if (p.raiz)
+            return lerProjetoDoClone(p, ctx);
+        if (p.forja)
+            return lerProjetoDaForja(p, ctx);
+        return vazio(lacuna('projeto.sem-fonte', 'projeto', p.nome, 'sem clone nesta máquina e sem remoto de forja reconhecido', 'peça por github:dono/repo'));
+    }
+    catch (e) {
+        return vazio(lacuna('projeto.sem-leitura', 'projeto', p.raiz ? raizParaExibir(p.raiz) : p.nome, `a leitura de ${p.nome} parou: ${(0, forja_1.detalheSeguro)(e?.message ?? String(e))}`, 'confira o clone e o estado dele no próprio projeto; os outros projetos seguiram'));
+    }
+}
+/**
+ * `ork network roadmap`: os projetos pedidos (ou todos os conhecidos), cada um com roadmap, reservas,
+ * threads por maquina, fontes e lacunas. Recusa o `--projeto` ambiguo ou desconhecido.
+ */
+function montarPanoramaDaRede(opcoes = {}) {
+    const quando = opcoes.quando ?? new Date().toISOString();
+    const cwd = opcoes.cwd ?? process.cwd();
+    const ctx = { quando, maquina: (0, maquina_1.nomeDaMaquina)(opcoes.maquina), semRemoto: opcoes.semRemoto === true, executor: opcoes.executor,
+        fuso: (0, horario_1.fusoDoDono)().fuso };
+    const naoConsultado = [
+        'rede por pessoa (RM-053, ork.rede-status/v1): não lida nesta versão; as máquinas vêm da branch ork/fabrica-estado de cada projeto',
+    ];
+    const lacunas = [];
+    let alvos;
+    if (opcoes.fixado !== undefined) {
+        // D-G5 (fatia 2): o servidor MCP le so o projeto dele, em todas as maquinas; o registro nao e lido.
+        const c = (0, manifest_1.carregarManifesto)(opcoes.fixado);
+        if (!c) {
+            throw new ErroDoPedidoDeProjeto('projeto.sem-manifesto', `a raiz fixada não tem ${manifest_1.NOME_MANIFESTO}`, [], 'confira a raiz fixada na instalação do servidor MCP (ork mcp install --project <raiz>)');
+        }
+        alvos = [projetoDoClone(c, 'instalacao')];
+        naoConsultado.push('outros projetos desta máquina: este servidor MCP lê só o projeto fixado na instalação; ' +
+            'os outros vêm do CLI `ork network roadmap`');
+    }
+    else {
+        const conhecidos = projetosConhecidos({ cwd, registro: opcoes.registro, host: opcoes.host });
+        naoConsultado.push(...conhecidos.naoConsultado);
+        lacunas.push(...conhecidos.lacunas);
+        if (opcoes.pedido !== undefined) {
+            if (opcoes.host)
+                exigirPedidoDoHost(opcoes.pedido, conhecidos.projetos);
+            const alvo = resolverProjeto(opcoes.pedido, conhecidos.projetos, cwd);
+            alvos = [alvo];
+            for (const p of conhecidos.projetos)
+                if (!mesmoProjeto(p, alvo))
+                    naoConsultado.push(`projeto ${p.nome}: fora do pedido (--projeto)`);
+        }
+        else {
+            alvos = conhecidos.projetos;
+        }
+    }
+    if (alvos.length === 0) {
+        lacunas.push(lacuna('rede.sem-projeto', 'rede', undefined, opcoes.host
+            ? 'nenhum projeto conhecido nesta máquina: o registro está vazio, e o diretório do host não conta como projeto'
+            : 'nenhum projeto conhecido nesta máquina: sem manifesto no diretório atual e sem registro', opcoes.host ? 'peça o projeto pela forja (--projeto github:dono/repo) ou registre o clone com `ork projetos registrar <caminho>`'
+            : 'peça o projeto: --projeto <caminho do clone> ou --projeto github:dono/repo'));
+    }
+    const projetos = alvos.map((p) => lerProjeto(p, ctx));
+    return { contrato: exports.CONTRATO_PANORAMA_DA_REDE, consultadoEm: quando, maquina: ctx.maquina, pedido: opcoes.pedido ?? null,
+        limiarSemBatidaMin: exports.LIMIAR_SEM_BATIDA_MS / 60000, fuso: projetos[0]?.projeto.fuso ?? ctx.fuso, projetos, naoConsultado, lacunas };
+}
+// ---------------------------------------------------------------------------
+// O texto.
+// ---------------------------------------------------------------------------
+function descreverProjeto(x) {
+    return `${x.nome} (${[x.forja, x.clone ? `clone em ${x.clone}` : 'sem clone nesta máquina'].filter(Boolean).join(', ')})`;
+}
+function linhaDaFonte(f, quando, fuso) {
+    const parte = { roadmap: 'roadmap', reservas: 'reservas', fabrica: 'fábrica', 'estado-local': 'esta máquina' }[f.parte];
+    const lido = f.lidoEm === quando ? 'lido agora' : `lido ${(0, horario_1.formatarDataHora)(f.lidoEm, { fuso })}`;
+    if (f.origem === 'estado-local')
+        return `• ${parte}: estado local em ${f.onde}, ${lido}`;
+    if (!f.existe)
+        return `• ${parte}: ${f.onde} não existe, ${lido}`;
+    const alvo = f.parte === 'roadmap' ? `${docs_1.DIR_ROADMAP} em ${f.onde}` : f.onde;
+    return `• ${parte}: ${alvo} @ ${(f.commit ?? '').slice(0, 7)} (commit de ${(0, horario_1.formatarDataHora)(f.dataDoCommit, { fuso })}), ` +
+        (f.atualizado ? lido : 'última cópia desta máquina, sem leitura nova');
+}
+function linhasDasMaquinas(x, fuso) {
+    if (x.maquinas === null)
+        return ['• não lidas: veja as lacunas'];
+    if (x.maquinas.length === 0)
+        return ['• nenhuma máquina publicou em ork/fabrica-estado'];
+    return x.maquinas.flatMap((m) => {
+        const quem = `${m.maquina}${m.estaMaquina ? ' (esta máquina)' : ''}`;
+        const batida = m.origem === 'estado-local' ? 'estado local lido agora'
+            : `retrato de ${(0, horario_1.formatarDataHora)(m.publicadoEm, { fuso })} (há ${(0, horario_1.duracaoCurta)(m.idadeMin)})${m.semBatida ? ', SEM BATIDA' : ''}`;
+        const cabeca = `• ${quem}: ${m.ativas.length} ativa(s)${m.entreguesSemMaster ? `, ${m.entreguesSemMaster} entregue(s) sem MASTER` : ''}, ${batida}`;
+        // RM-037 (rm037noite, defeito 4): o runtime e o modelo de cada thread, quando o retrato os traz.
+        return [cabeca, ...m.ativas.map((t) => `  ${t.id} · ${t.modo} · ${t.fase} · ${t.roadmap ?? 'sem item'}` +
+                (t.runtime || t.modelo ? ` · ${(0, fabrica_estado_1.runtimeDaThread)(t)}` : '') +
+                (t.esperaVoce ? ` · espera você: ${t.pergunta ?? 'veredito'}` : ''))];
+    });
+}
+function linhasDasReservas(x, fuso) {
+    if (x.reservas === null)
+        return ['• não lidas: veja as lacunas'];
+    if (x.reservas.length === 0)
+        return ['• nenhuma reserva em ork/roadmap-reservas'];
+    return x.reservas.map((r) => `  ${r.item} · ${r.maquina} · ${r.thread ?? 'sem thread'} · desde ${(0, horario_1.formatarDataHora)(r.desdeEm, { fuso })}`);
+}
+const linhaDaLacuna = (l) => `• ${l.tipo}${l.alvo ? ` (${l.alvo})` : ''}: ${l.detalhe}. O que fazer: ${l.correcao}.`;
+/** O texto de `ork network roadmap`: o consultado e o nao consultado no alto, e cada parte com a fonte e a hora. */
+function textoDoPanoramaDaRede(p) {
+    if (p.contrato !== exports.CONTRATO_PANORAMA_DA_REDE)
+        throw new Error('panorama da rede: contrato inválido');
+    const h = (0, horario_1.partesLocais)(p.consultadoEm, p.fuso);
+    const linhas = [
+        `Panorama da rede lido de ${p.maquina} (${h.dia}/${h.mes}, ${h.hora}:${h.minuto})`,
+        p.projetos.length ? `Consultado: ${p.projetos.map((x) => descreverProjeto(x.projeto)).join('; ')}` : 'Consultado: nenhum projeto.',
+        'Não consultado:', ...(p.naoConsultado.length ? p.naoConsultado.map((n) => `• ${n}`) : ['• nada fora do pedido']),
+    ];
+    if (p.lacunas.length)
+        linhas.push('', 'Lacunas da consulta', ...p.lacunas.map(linhaDaLacuna));
+    for (const x of p.projetos) {
+        // Cada projeto no fuso do dono dele (achado 5 da rodada 2): a legenda do bloco diz quando difere.
+        const fuso = x.projeto.fuso;
+        linhas.push('', '────────', '');
+        linhas.push(x.roadmap ? (0, roadmap_status_1.textoDoStatusDoRoadmap)(x.roadmap, fuso)
+            : `Roadmap do ${x.projeto.nome}: não lido (${x.lacunas.map((l) => l.tipo).filter((t) => t !== 'projeto.sem-clone').join(', ') || 'sem fonte'}).`);
+        linhas.push('', 'Threads por máquina', ...linhasDasMaquinas(x, fuso));
+        linhas.push('', 'Reservas', ...linhasDasReservas(x, fuso));
+        linhas.push('', 'Fontes', ...(x.fontes.length ? x.fontes.map((f) => linhaDaFonte(f, p.consultadoEm, fuso)) : ['• nenhuma fonte lida']));
+        linhas.push('', 'Lacunas', ...(x.lacunas.length ? x.lacunas.map(linhaDaLacuna) : ['• nenhuma: todas as fontes foram lidas agora']));
+        if (fuso !== p.fuso)
+            linhas.push('', `Neste projeto: ${(0, horario_1.legendaDoFuso)(fuso)}`);
+    }
+    linhas.push('', (0, horario_1.legendaDoFuso)(p.fuso));
+    return linhas.join('\n');
+}