@orkastery/cli 0.5.0 → 0.5.3

package/dist/retry.js

@@ -97,6 +97,7 @@ const modos_1 = require("./modos");
 const thread_1 = require("./thread");
 const tokens_1 = require("./tokens");
 const util_1 = require("./util");
+const impedimento_1 = require("./impedimento");
 const worktree_1 = require("./worktree");
 const delegation_1 = require("./delegation");
 const gates_2 = require("./gates");
@@ -163,6 +164,14 @@ exports.POLITICA_DE_RETRY = {
         porque: 'repetir o despacho no MESMO runtime daria o mesmo resultado: o que falta nao e tentativa, e um validador que nao seja quem executou. Escolher o outro runtime e decisao de conducao, nao retry',
         correcao: 'despache o CHECK em outro runtime (`ork phase run <thread> CHECK --runtime <outro>`), ou tire a exigencia de validacao cruzada da thread se ela nao se justifica',
     },
+    // RM-056 (D1): o perfil pedido nao existe ou e de outro runtime. Quem corrige e quem pediu.
+    'runtime.profile-invalid': {
+        motivo: 'runtime.profile-invalid',
+        acao: 'escalar-humano',
+        automatica: false,
+        porque: 'o perfil foi pedido pelo dono (--perfil) e nao existe no store ou e de outro runtime: repetir o pedido daria a mesma recusa, e trocar de perfil sozinho desobedeceria o pedido',
+        correcao: 'ork accounts list mostra os perfis de cada runtime; repita o despacho com um perfil do runtime certo ou sem --perfil',
+    },
     'cost.violation': {
         motivo: 'cost.violation',
         acao: 'sem-retry',
@@ -251,6 +260,22 @@ exports.POLITICA_DE_RETRY = {
         porque: 'o modelo pedido nao existe ou a conta nao tem acesso a ele: o MESMO prompt, com o mesmo sha256, segue no proximo perfil do mesmo runtime com o mesmo modelo e depois no fallback do bloco, nunca de novo no par que ja recusou',
         correcao: 'ork retry run <thread> troca o destino; sem destino, ork setup <modo> --bloco N --model <modelo acessivel> ou --fallback runtime:modelo',
     },
+    // RM-055: so o dono destrava, no terminal. O retry nao repete o despacho as cegas: confere antes se o
+    // impedimento saiu (a confianca do diretorio tem prova local) e, sem prova, deixa o runtime decidir.
+    'runtime.workspace-untrusted': {
+        motivo: 'runtime.workspace-untrusted',
+        acao: 'reexecutar',
+        automatica: true,
+        porque: 'o runtime recusou o diretorio da worktree antes de rodar qualquer coisa: depois que o dono aceita a confianca no terminal, o MESMO prompt, com o mesmo sha256, volta a mesma fase; enquanto a confianca nao aparece no .claude.json da conta, nada e despachado',
+        correcao: 'o dono roda o comando da pausa (cd <worktree> && claude, aceita a confianca); ork retry run <thread> re-despacha o prompt ja gravado',
+    },
+    'runtime.consent-pending': {
+        motivo: 'runtime.consent-pending',
+        acao: 'reexecutar',
+        automatica: true,
+        porque: 'o runtime espera o dono aceitar termos novos antes de rodar qualquer coisa: depois do aceite, o MESMO prompt, com o mesmo sha256, volta a mesma fase; se o runtime recusar de novo, a mesma pausa do dono volta',
+        correcao: 'o dono abre o CLI do runtime e aceita os termos; ork retry run <thread> re-despacha o prompt ja gravado',
+    },
     'tree.blocked': {
         motivo: 'tree.blocked',
         acao: 'sincronizar-worktree',
@@ -258,6 +283,13 @@ exports.POLITICA_DE_RETRY = {
         porque: 'a arvore de destino andou por baixo da thread: rebasar a worktree contra a base e o passo que desbloqueia, e reexecutar antes disso so repete o conflito',
         correcao: 'ork worktree sync <thread> e so entao repetir o passo',
     },
+    'lease.resume-unavailable': {
+        motivo: 'lease.resume-unavailable',
+        acao: 'escalar-humano',
+        automatica: false,
+        porque: 'sem inode seguro, a remocao forcada exige avaliar a posse antes de retomar',
+        correcao: 'ork lease release <nome> --forcar; depois repita a aquisicao',
+    },
     'lease.busy': {
         motivo: 'lease.busy',
         acao: 'reexecutar',
@@ -677,8 +709,19 @@ tomadaPrevia) {
         if (!resultado.ok || !resultado.sessionId) {
             (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, thread.id), thread.id, 'phase_dispatch_failed', { fase, runtime, slug, cwd,
                 promptPath: absoluto, promptSha256: sha, controlador: resultado.controlador, model, effort,
-                erro: resultado.erro ?? 'runtime.unavailable: sem sessionId', origem: 'retry', ...(perfil ? { perfil } : {}) });
+                erro: resultado.erro ?? 'runtime.unavailable: sem sessionId', stderr: (resultado.stderr ?? '').slice(0, 500),
+                origem: 'retry', ...(perfil ? { perfil } : {}) });
             const sinal = resultado.rateLimit ?? null;
+            // RM-055: o redespacho recusado pelo que so o dono resolve reabre a pausa dele, com o mesmo comando.
+            const impedimento = !resultado.falhaDeConta && !sinal
+                ? (0, impedimento_1.registrarImpedimentoDoDono)((0, thread_1.dirThread)(raiz, thread.id), thread, { fase, slug, runtime, cwd, origem: 'retry',
+                    promptPath: absoluto, promptSha256: sha, perfil, saida: `${resultado.stderr ?? ''}\n${resultado.erro ?? ''}` })
+                : null;
+            if (impedimento) {
+                return { ok: false, slug, sessionId: null, verificada: false, motivo: impedimento.motivo,
+                    detalhe: `${impedimento.motivo}: ${impedimento.trecho}`, sinal: null, falhaDeConta: null, perfil: perfil ?? null,
+                    comando: resultado.comando, controlador: resultado.controlador, dryRun: false };
+            }
             // I-33 (D5): a conta recusou o redespacho; o perfil sai do rodizio aqui, onde a evidencia esta.
             if (resultado.falhaDeConta) {
                 try {
@@ -1121,6 +1164,17 @@ function jaMarcado(raiz, perfil, falha, agoraMs = Date.now()) {
         ? atual.estado === 'esgotado' && atual.esgotadoAte !== null && Date.parse(atual.esgotadoAte) > agoraMs
         : atual.estado === 'sem-auth';
 }
+/**
+ * RM-037 (fatia 5, aviso da rodada 1 do CHECK): a cota que o observador viu ao vivo (`runtime_quota_detected`, da mesma
+ * sessao e do mesmo despacho, com o mesmo prazo dito) ja tirou o perfil do rodizio ate a hora da mensagem. Marcar de
+ * novo aqui, depois dessa hora, pela janela padrao (A10), tiraria do rodizio uma conta que ja voltou.
+ */
+function cotaJaVistaAoVivo(eventos, gate, falha) {
+    if (falha.motivo !== 'runtime.quota-exhausted' || typeof gate?.sessionId !== 'string')
+        return false;
+    return eventos.some((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.cotaVistaNaTranscricao && e.sessionId === gate.sessionId &&
+        e.despachoEm === gate.despachoEm && (e.resetEm ?? null) === falha.resetEm);
+}
 function sinalDoGate(gate, motivo) {
     const f = gate?.falhaDeConta;
     return { motivo: motivo === 'runtime.auth-missing' ? 'runtime.auth-missing' : 'runtime.quota-exhausted',
@@ -1282,6 +1336,18 @@ function executarRetry(carregado, threadId, opcoes = {}) {
         registrarTentativa(false, detalhe);
         return { ...vazio, detalhe };
     }
+    // RM-055: o impedimento do dono com prova local (confianca do diretorio) so volta ao runtime depois de
+    // resolvido. Sem a prova, nada e despachado e a tentativa nao conta: a pausa do dono continua aberta.
+    if (plano.motivo && (0, impedimento_1.ehImpedimentoDoDono)(plano.motivo) && typeof falho.cwd === 'string') {
+        const perfilFalho = perfilDoEvento(falho);
+        const resolvido = (0, impedimento_1.impedimentoResolvido)(plano.motivo, { cwd: falho.cwd,
+            runtime: typeof falho.runtime === 'string' ? falho.runtime : '', configDir: perfilFalho?.configDir ?? null });
+        if (resolvido === false) {
+            const detalhe = `${plano.motivo}: o runtime ainda nao confia em ${falho.cwd}; nada foi despachado. ` +
+                `Rode \`cd ${falho.cwd} && claude\`, aceite a confianca e repita \`ork retry run ${threadId}\``;
+            return { ...vazio, detalhe };
+        }
+    }
     const redespacho = redespachar(carregado, thread, plano.fase, falho.promptPath, falho.promptSha256, {
         effort: plano.effort,
         runtime: typeof falho.runtime === 'string' ? falho.runtime : null,
@@ -1349,7 +1415,8 @@ function rotacionarConta(carregado, thread, plano, opcoes, vazio, registrarTenta
     const politica = (0, runtime_profiles_1.politicaDeRotacao)(manifesto);
     const falha = sinalDoGate(gate, motivo);
     // I-33 (D12): o observador ja marca o perfil no caminho terminal; remarcar empurraria o prazo a cada retry.
-    if (!opcoes.dryRun && perfil && !jaMarcado(raiz, perfil, falha)) {
+    // RM-037 (fatia 5, aviso da rodada 1 do CHECK): a cota que ele viu ao vivo ja marcou ate a hora da mensagem.
+    if (!opcoes.dryRun && perfil && !jaMarcado(raiz, perfil, falha) && !cotaJaVistaAoVivo(eventos, gate, falha)) {
         try {
             (0, ratelimit_1.marcarContaDaFalha)(carregado, perfil, falha);
         }

package/dist/roadmap-status.js

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

package/dist/runtime-context.js

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

package/dist/runtime-profiles.js

@@ -67,6 +67,7 @@ exports.perfisDoRuntime = perfisDoRuntime;
 exports.perfilDisponivel = perfilDisponivel;
 exports.politicaDeRotacao = politicaDeRotacao;
 exports.proximoPerfilDisponivel = proximoPerfilDisponivel;
+exports.proximoPerfilPorCarga = proximoPerfilPorCarga;
 exports.prazoDoRuntime = prazoDoRuntime;
 exports.prazoDaFila = prazoDaFila;
 exports.menorEsgotadoAte = menorEsgotadoAte;
@@ -794,7 +795,8 @@ exports.POLITICA_PADRAO = { mesmoRuntimePorCota: true, mesmoRuntimePorAuth: true
 function politicaDeRotacao(manifesto) {
     const r = manifesto.runtime_profiles;
     return { mesmoRuntimePorCota: r?.rotate_same_runtime_on_quota !== false,
-        mesmoRuntimePorAuth: r?.rotate_same_runtime_on_auth !== false };
+        mesmoRuntimePorAuth: r?.rotate_same_runtime_on_auth !== false,
+        ...(r?.distribuir === 'carga' ? { distribuir: 'carga' } : {}) };
 }
 /**
  * D14: o perfil da vez do runtime, na ordem do store. `desativado` e `provider-pago` nunca foram
@@ -819,6 +821,25 @@ function proximoPerfilDisponivel(store, runtime, politica, opcoes = {}) {
     }
     return null;
 }
+/**
+ * RM-056 (D3): a escolha por carga. Respeita a politica da D14 (sem perfil da vez pela ordem, sem
+ * perfil nenhum: a mesma retencao do runtime), e entre os perfis disponiveis vence o de menor
+ * carga (sessoes vivas da conta nesta maquina); empate pelo `ultimoUso` mais antigo (nunca usado
+ * primeiro), depois a ordem do store. O `ultimoUso` e gravado no despacho, entao dois despachos
+ * seguidos com carga igual vao a perfis diferentes mesmo antes de o runtime listar a sessao.
+ */
+function proximoPerfilPorCarga(store, runtime, politica, carga, opcoes = {}) {
+    const daVez = proximoPerfilDisponivel(store, runtime, politica, opcoes);
+    if (!daVez)
+        return null;
+    const agoraMs = opcoes.agoraMs ?? Date.now();
+    const candidatos = perfisDoRuntime(store, runtime)
+        .map((p, i) => ({ p, i }))
+        .filter(({ p }) => !(opcoes.excluir ?? []).includes(p.id) && perfilDisponivel(p, agoraMs));
+    const uso = (p) => p.ultimoUso === null ? -Infinity : Date.parse(p.ultimoUso);
+    candidatos.sort((x, y) => (carga.get(x.p.id) ?? 0) - (carga.get(y.p.id) ?? 0) || uso(x.p) - uso(y.p) || x.i - y.i);
+    return candidatos[0]?.p ?? daVez;
+}
 /**
  * D14: quando o runtime volta a ter perfil da vez, pela mesma regra da escolha. Com a troca por
  * cota desligada, e o prazo do perfil que segura o runtime; ligada, o menor prazo entre os

package/dist/saida-segura.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * RM-053 (fatia 2): o saneador de saida comum ao nucleo.
+ *
+ * Texto que vem de fora (o retrato de outra maquina, a branch `ork/fabrica-estado` do remoto de um
+ * projeto, onde outras pessoas escrevem) chega a tela do dono. A rede ja limpava o que imprime desde
+ * a revisao 4; o `ork fabrica` imprimia o `por` e o `projeto` legados crus. Este modulo e a regra
+ * unica: quem imprime valor alheio passa por aqui.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emUmaLinha = exports.INVISIVEL = exports.CF_VISIVEL = void 0;
+exports.valoresEmUmaLinha = valoresEmUmaLinha;
+exports.jsonSemInvisivel = jsonSemInvisivel;
+/**
+ * Y4 do CHECK 7: as marcas de `Cf` que se veem, lista fechada (todo `Prepended_Concatenation_Mark=Yes`
+ * do Unicode 17: os sinais numericos arabes U+0600 a U+0605, o fim de aya U+06DD, a abreviacao siriaca
+ * U+070F, as marcas de libra e piastra U+0890 e U+0891, o sanah U+08E2 e as marcas de numero kaithi
+ * U+110BD e U+110CD). Elas tem glifo e nao movem o texto, ao contrario das bidi, de largura zero e das
+ * tags, que seguem invisiveis. O regex do JS nao aceita `\p{Prepended_Concatenation_Mark}`; por isso a
+ * lista literal, presa ao `INVISIVEL` e conferida ponto a ponto no teste.
+ */
+exports.CF_VISIVEL = Object.freeze([
+    0x0600, 0x0601, 0x0602, 0x0603, 0x0604, 0x0605, 0x06dd, 0x070f, 0x0890, 0x0891, 0x08e2, 0x110bd, 0x110cd,
+]);
+/**
+ * V2 da revisao 4, W11 da revisao 5 e X3 da revisao 6: caractere que o terminal executa ou que
+ * ninguem ve, pelas classes do Unicode: controles (`Cc`: ESC, BEL, CSI, quebra de linha), formato
+ * (`Cf`: bidi, largura zero, tags), separadores de linha e todo `Default_Ignorable_Code_Point`
+ * (preenchimentos Hangul, seletores de variacao, os de musica e de estenografia), mais o braile
+ * vazio. Ficam de fora o ZWJ (U+200D) e os seletores U+FE0E e U+FE0F: eles montam emoji comuns, e as
+ * marcas visiveis de `Cf` (`CF_VISIVEL`, Y4 do CHECK 7).
+ */
+exports.INVISIVEL = /(?![\u200d\ufe0e\ufe0f\u0600-\u0605\u06dd\u070f\u0890\u0891\u08e2\u{110bd}\u{110cd}])[\p{Cc}\p{Cf}\p{Zl}\p{Zp}\p{Default_Ignorable_Code_Point}\u2800]/u;
+const INVISIVEIS = new RegExp(exports.INVISIVEL.source, 'gu');
+/**
+ * W4 da revisao 5: o valor numa linha so, sem nada invisivel. A quebra de linha (e a tabulacao) vira
+ * espaco: um valor que vem de fora nunca abre uma linha propria na saida, como se fosse do `ork`.
+ */
+const emUmaLinha = (texto) => texto.replace(INVISIVEIS, (c) => (/[\t\n\v\f\r\u0085\u2028\u2029]/.test(c) ? ' ' : ''));
+exports.emUmaLinha = emUmaLinha;
+/**
+ * Cada texto de uma estrutura (objeto, lista, aninhados) em uma linha, sem invisivel; numero,
+ * booleano e `null` ficam como estao (X5 da revisao 6: a ida e volta em JSON trocava `NaN` por `null`).
+ */
+function valoresEmUmaLinha(valor) {
+    const limpar = (v) => typeof v === 'string' ? (0, exports.emUmaLinha)(v)
+        : Array.isArray(v) ? v.map(limpar)
+            : v && typeof v === 'object' ? Object.fromEntries(Object.entries(v).map(([k, x]) => [k, limpar(x)])) : v;
+    return limpar(valor);
+}
+/**
+ * O JSON para a tela: o mesmo valor, com os caracteres invisiveis escritos como `\uXXXX` (quem le o
+ * JSON recebe o mesmo texto; so o terminal deixa de executa-lo). A quebra de linha da indentacao fica.
+ */
+function jsonSemInvisivel(valor) {
+    return JSON.stringify(valor, null, 2).replace(INVISIVEIS, (c) => c === '\n' ? c
+        : Array.from({ length: c.length }, (_, i) => `\\u${c.charCodeAt(i).toString(16).padStart(4, '0')}`).join(''));
+}