@orkastery/cli 0.5.1 → 0.5.3

package/dist/parado-no-condutor.js

@@ -33,11 +33,14 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LIMITE_DE_RECENTES = exports.LIMITE_DE_PRS = exports.VALIDADE_DO_RETRATO_MIN = exports.LIMIAR_PARADO_NO_CONDUTOR_MIN = exports.CONTRATO_PRS = void 0;
+exports.CONTRATO_FORJA_SEM_LEITURA = exports.FORJA_SEM_LEITURA = exports.LIMITE_DE_RECENTES = exports.LIMITE_DE_PRS = exports.VALIDADE_DO_RETRATO_MIN = exports.LIMIAR_PARADO_NO_CONDUTOR_MIN = exports.CONTRATO_PRS = void 0;
 exports.nomeDeCheck = nomeDeCheck;
 exports.repositorioDoRemoto = repositorioDoRemoto;
 exports.lerPrsDaForja = lerPrsDaForja;
 exports.gravarRetratoDePrs = gravarRetratoDePrs;
+exports.avisarForjaSemLeitura = avisarForjaSemLeitura;
+exports.esquecerForjaSemLeitura = esquecerForjaSemLeitura;
+exports.forjaSemLeituraDoRemoto = forjaSemLeituraDoRemoto;
 exports.lerRetratoDePrs = lerRetratoDePrs;
 exports.perguntaAberta = perguntaAberta;
 exports.fimDoTurno = fimDoTurno;
@@ -72,6 +75,7 @@ exports.entregasDoProjeto = entregasDoProjeto;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const node_child_process_1 = require("node:child_process");
+const branch_de_estado_1 = require("./branch-de-estado");
 const conducao_1 = require("./conducao");
 const estado_thread_1 = require("./estado-thread");
 const forja_1 = require("./forja");
@@ -111,6 +115,8 @@ const MINIMO_DA_CONFERENCIA_MS = 5000;
 const FASES_ANTES_DA_ENTREGA = ['GOAL', 'PLAN', 'GO', 'CHECK'];
 /** Os modos em que a #TAG ja autoriza o push (`autorizacaoDePush`, `core/src/ship.ts`). */
 const MODOS_COM_PUSH_AUTORIZADO = ['auto', 'maestro'];
+/** RM-037 (fatia 5, A5): o que as linhas e o resumo dizem quando a forja nao tem leitura de PR. */
+exports.FORJA_SEM_LEITURA = 'forja sem leitura de PR';
 /** O ambiente do `gh`: sem cor, sem prompt e sem host ou repositorio herdados (o host vai no `--repo`). */
 function ambienteDoGh() {
     const env = { ...process.env, GH_PROMPT_DISABLED: '1', NO_COLOR: '1', CLICOLOR: '0', CLICOLOR_FORCE: '0' };
@@ -128,6 +134,8 @@ const git = (raiz, args) => (0, util_1.exec)('git', args, raiz, 60000, { ...proc
 const SHA = /^[0-9a-f]{40}$/;
 const BRANCH = /^[A-Za-z0-9._/-]{1,200}$/;
 const REPOSITORIO = /^[A-Za-z0-9_.-]{1,100}\/[A-Za-z0-9_.-]{1,100}$/;
+/** O host do GitHub Enterprise guardado no retrato: rotulos alfanumericos separados por ponto, como na forja. */
+const HOST = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)+$/;
 /** Texto curto vindo de fora: sem controle, num teto. */
 function curto(v, teto = 120) {
     if (typeof v !== 'string')
@@ -215,30 +223,87 @@ function prDaForja(bruto, base) {
     return { numero: numero, branch: p.headRefName, head, estado, rascunho: p.isDraft, url,
         criadoEm: instante(p.createdAt), mescladoEm: instante(p.mergedAt), checks: [...porChave.values()].map((x) => x.check) };
 }
+/**
+ * RM-037 (fatia 5, A5): o host e o `dono/nome` do remoto quando ele pode ser um GitHub (o github.com ou um host
+ * proprio), so pelo git local, sem rede nem `gh`. O GitLab fica de fora.
+ */
+function githubDoRemoto(raiz, remoto) {
+    // RM-047: o remoto vem do manifesto versionado; so nome de remoto chega ao git, e depois do `--`.
+    if (!(0, branch_de_estado_1.remotoValido)(remoto))
+        return null;
+    const url = git(raiz, ['remote', 'get-url', '--', remoto]);
+    const forja = url.ok ? (0, forja_1.repositorioGithubNoHost)(url.stdout.trim()) : null;
+    // `ssh.github.com` e o SSH do github.com pela porta 443, e nao um GitHub Enterprise (sugestao da rodada 1 do CHECK).
+    return forja && REPOSITORIO.test(forja.repo) ? { host: forja.host === 'ssh.github.com' ? 'github.com' : forja.host, repositorio: forja.repo }
+        : null;
+}
 /** O repositorio `dono/nome` do remoto, so quando ele e do github.com (o host ancorado, nao so citado no caminho). */
 function repositorioDoRemoto(raiz, remoto) {
-    const url = git(raiz, ['remote', 'get-url', remoto]);
-    const forja = url.ok ? (0, forja_1.identidadeDaForja)(url.stdout.trim()) : null;
-    return forja && forja.tipo === 'github' && forja.host === 'github.com' && REPOSITORIO.test(forja.repo) ? forja.repo : null;
+    const github = githubDoRemoto(raiz, remoto);
+    return github && github.host === 'github.com' ? github.repositorio : null;
+}
+/**
+ * RM-037 (fatia 5, A5): de onde o pulse le os PRs do remoto. O github.com, como sempre; o host proprio em que o `gh`
+ * esta autenticado, que e um GitHub Enterprise (`gh auth status --hostname <host>`); ou nenhum: GitLab, caminho local,
+ * ou host em que o `gh` nao tem login. Ficar sem leitura nao e falha desta batida (o "PR nao lido"): e o estado da
+ * forja, que o pulse diz uma vez.
+ */
+function forjaDosPrs(raiz, remoto, executor, prazoMs) {
+    // RM-047: remoto que nao e nome de remoto nao chega ao git; para o pulse, e forja sem leitura.
+    if (!(0, branch_de_estado_1.remotoValido)(remoto)) {
+        return { leitura: false, host: null, motivo: `o remoto ${(0, branch_de_estado_1.remotoRedigido)(remoto)} não é nome de remoto do git`, semLeitura: true };
+    }
+    const url = git(raiz, ['remote', 'get-url', '--', remoto]);
+    if (!url.ok)
+        return { leitura: false, host: null, motivo: `o remoto ${remoto} não está configurado neste checkout`, semLeitura: true };
+    const endereco = (0, forja_1.enderecoDoRemoto)(url.stdout.trim());
+    // Caminho local, ou apelido de SSH sem dominio (`git@github-trabalho:dono/repo.git`): nao ha host para ler.
+    if (!endereco) {
+        return { leitura: false, host: null, motivo: `o remoto ${remoto} não tem host de forja (caminho local ou apelido de SSH)`, semLeitura: true };
+    }
+    if ((0, forja_1.identidadeDaForja)(url.stdout.trim())?.tipo === 'gitlab') {
+        return { leitura: false, host: endereco.host, motivo: `a forja de ${remoto} (${endereco.host}) é um GitLab, e o ork só lê PR do GitHub`,
+            semLeitura: true };
+    }
+    const github = githubDoRemoto(raiz, remoto);
+    if (!github) {
+        return { leitura: false, host: endereco.host, motivo: `o remoto ${remoto} (${endereco.host}) não aponta um repositório dono/nome`,
+            semLeitura: true };
+    }
+    if (github.host === 'github.com')
+        return { leitura: true, ...github };
+    const auth = executor(['auth', 'status', '--hostname', github.host], prazoMs);
+    if (auth.status === 0)
+        return { leitura: true, ...github };
+    // So a resposta de login ausente (o `gh` 2.46 diz "You are not logged into any accounts on <host>") e o estado da
+    // forja; prazo estourado, `gh` ausente ou host fora do ar sao falha desta batida.
+    const semLogin = auth.status === 1 && /\bnot logged in/i.test(`${auth.stdout}\n${auth.stderr}`);
+    return { leitura: false, host: github.host, semLeitura: semLogin, motivo: semLogin
+            ? `o gh não está autenticado em ${github.host}, a forja de ${remoto}`
+            : `gh auth status --hostname ${github.host} falhou (${auth.status === null ? 'sem código de saída' : `código ${auth.status}`}): ` +
+                (curto((0, hitl_1.redigirSegredos)(auth.stderr || auth.stdout || ''), 120) ?? 'sem detalhe') };
 }
 /**
  * Le os PRs da base do repositorio do remoto em duas chamadas: os abertos (ate `LIMITE_DE_PRS`; e so a
  * lista deles que pode dizer "sem PR") e os recentes de qualquer estado (para achar o mesclado e o fechado).
- * O `gh` usa a autenticacao dele; nenhum token passa por aqui. Remoto que nao e do github.com nao chama nada.
+ * O `gh` usa a autenticacao dele; nenhum token passa por aqui. RM-037 (fatia 5, A5): no GitHub Enterprise, o host
+ * vai no `--repo`; forja sem leitura de PR nao chama o `gh pr list`.
  */
 function lerPrsDaForja(carregado, opcoes = {}) {
     const lidoEm = opcoes.quando ?? new Date().toISOString();
     const remoto = opcoes.remoto ?? carregado.manifesto.fabrica.remoto;
     const base = carregado.manifesto.worktree.base_branch;
-    const repositorio = repositorioDoRemoto(carregado.raiz, remoto);
-    if (!repositorio)
-        return { ok: false, lidoEm, erro: `o remoto ${remoto} não é um repositório do github.com` };
     const orcamento = opcoes.orcamentoMs ?? ORCAMENTO_DA_LEITURA_MS, fimDaLeitura = Date.now() + orcamento;
     const resta = () => fimDaLeitura - Date.now();
+    const executor = opcoes.executor ?? ghPadrao;
+    const forja = forjaDosPrs(carregado.raiz, remoto, executor, Math.min(PRAZO_DO_GH_MS, Math.max(1, resta())));
+    if (!forja.leitura)
+        return { ok: false, lidoEm, erro: forja.motivo, ...(forja.semLeitura ? { semLeitura: { remoto, host: forja.host } } : {}) };
+    const { host, repositorio } = forja;
     const pedir = (args) => {
         if (resta() <= 0)
             return `gh pr list: orçamento de ${Math.round(orcamento / 1000)} s da leitura esgotado`;
-        const r = (opcoes.executor ?? ghPadrao)(['pr', 'list', `--repo=github.com/${repositorio}`, `--base=${base}`, ...args], Math.min(PRAZO_DO_GH_MS, resta()));
+        const r = executor(['pr', 'list', `--repo=${host}/${repositorio}`, `--base=${base}`, ...args], Math.min(PRAZO_DO_GH_MS, resta()));
         if (r.status !== 0) {
             const detalhe = curto((0, hitl_1.redigirSegredos)(r.stderr || r.stdout || ''), 160) ?? 'sem detalhe';
             return `gh pr list falhou (${r.status === null ? 'sem código de saída' : `código ${r.status}`}): ${detalhe}`;
@@ -296,8 +361,8 @@ function lerPrsDaForja(carregado, opcoes = {}) {
                 semConferir.push(branch);
             }
         }
-        return { ok: true, retrato: { contrato: exports.CONTRATO_PRS, lidoEm, repositorio, base, parcial: abertos.length >= exports.LIMITE_DE_PRS,
-                ...(semConferir.length ? { semConferir } : {}), prs: [...porNumero.values()] } };
+        return { ok: true, retrato: { contrato: exports.CONTRATO_PRS, lidoEm, repositorio, ...(host !== 'github.com' ? { host } : {}), base,
+                parcial: abertos.length >= exports.LIMITE_DE_PRS, ...(semConferir.length ? { semConferir } : {}), prs: [...porNumero.values()] } };
     }
     catch (e) {
         return { ok: false, lidoEm, erro: `resposta do gh pr list fora do formato: ${curto((0, hitl_1.redigirSegredos)(e.message), 120) ?? 'sem detalhe'}` };
@@ -321,6 +386,64 @@ function gravarRetratoDePrs(raiz, retrato) {
         throw e;
     }
 }
+const ARQUIVO_DA_FORJA_SEM_LEITURA = 'forja-sem-leitura.json';
+exports.CONTRATO_FORJA_SEM_LEITURA = 'ork.forja-sem-leitura/v1';
+function lerAvisoDeForjaSemLeitura(raiz) {
+    try {
+        const a = JSON.parse(fs.readFileSync(path.join(dirDoMonitor(raiz), ARQUIVO_DA_FORJA_SEM_LEITURA), 'utf8'));
+        const ditoEm = instante(a.ditoEm), motivo = curto(a.motivo, 200);
+        if (a.contrato !== exports.CONTRATO_FORJA_SEM_LEITURA || typeof a.remoto !== 'string' || !/^[A-Za-z0-9._-]{1,100}$/.test(a.remoto) ||
+            !(a.host === null || (typeof a.host === 'string' && HOST.test(a.host))) || !ditoEm || !motivo)
+            return null;
+        return { contrato: exports.CONTRATO_FORJA_SEM_LEITURA, remoto: a.remoto, host: a.host, motivo, ditoEm };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * RM-037 (fatia 5, A5): a forja sem leitura de PR e dita uma vez por remoto e host. Com o remoto fora do github.com,
+ * o pulse dizia "PR nao lido" a cada batida, para um estado que nao muda de uma batida para a outra. A marca em
+ * `.orkastery/monitor/` guarda o que ja foi dito; devolve true quando e novidade (e grava a marca).
+ */
+function avisarForjaSemLeitura(raiz, semLeitura, motivo, quando) {
+    const atual = lerAvisoDeForjaSemLeitura(raiz);
+    if (atual && atual.remoto === semLeitura.remoto && atual.host === semLeitura.host)
+        return false;
+    const dir = dirDoMonitor(raiz);
+    fs.mkdirSync(dir, { recursive: true });
+    const arquivo = path.join(dir, ARQUIVO_DA_FORJA_SEM_LEITURA), tmp = `${arquivo}.${process.pid}.${Date.now()}.tmp`;
+    const aviso = { contrato: exports.CONTRATO_FORJA_SEM_LEITURA, ...semLeitura, motivo: curto(motivo, 200) ?? exports.FORJA_SEM_LEITURA,
+        ditoEm: quando };
+    try {
+        fs.writeFileSync(tmp, JSON.stringify(aviso, null, 2) + '\n', { mode: 0o600, flag: 'wx' });
+        fs.renameSync(tmp, arquivo);
+    }
+    catch (e) {
+        try {
+            fs.unlinkSync(tmp);
+        }
+        catch { /* ja saiu */ }
+        throw e;
+    }
+    return true;
+}
+/** A leitura voltou: a marca sai, e a forja que perder a leitura de novo volta a ser dita. */
+function esquecerForjaSemLeitura(raiz) {
+    fs.rmSync(path.join(dirDoMonitor(raiz), ARQUIVO_DA_FORJA_SEM_LEITURA), { force: true });
+}
+/**
+ * A forja sem leitura que o pulse ja disse, so quando ela e a do remoto de agora (mesmo nome e mesmo host): o status
+ * do roadmap a le sem rede e sem `gh`.
+ */
+function forjaSemLeituraDoRemoto(raiz, remoto) {
+    const aviso = lerAvisoDeForjaSemLeitura(raiz);
+    if (!aviso || aviso.remoto !== remoto || !(0, branch_de_estado_1.remotoValido)(remoto))
+        return null;
+    const url = git(raiz, ['remote', 'get-url', '--', remoto]);
+    const host = url.ok ? (0, forja_1.enderecoDoRemoto)(url.stdout.trim())?.host ?? null : null;
+    return host === aviso.host ? aviso : null;
+}
 /** O ultimo retrato gravado pelo pulse, conferido campo a campo e com os nomes de check limpos de novo. */
 function lerRetratoDePrs(raiz) {
     try {
@@ -328,6 +451,7 @@ function lerRetratoDePrs(raiz) {
         const lidoEm = instante(r.lidoEm);
         if (r.contrato !== exports.CONTRATO_PRS || !lidoEm || typeof r.repositorio !== 'string' || !REPOSITORIO.test(r.repositorio) ||
             typeof r.base !== 'string' || typeof r.parcial !== 'boolean' || !Array.isArray(r.prs) ||
+            (r.host !== undefined && !(typeof r.host === 'string' && HOST.test(r.host))) ||
             (r.semConferir !== undefined && !(Array.isArray(r.semConferir) && r.semConferir.every((b) => typeof b === 'string' && BRANCH.test(b)))))
             return null;
         const opcional = (v) => (v === null || v === undefined ? null : instante(v) ?? undefined);
@@ -351,8 +475,8 @@ function lerRetratoDePrs(raiz) {
             prs.push({ numero: p.numero, branch: p.branch, head: p.head, estado, rascunho: p.rascunho,
                 url: typeof p.url === 'string' && /^https:\/\/[^\s]+$/.test(p.url) ? curto(p.url, 300) : null, criadoEm, mescladoEm, checks });
         }
-        return { contrato: exports.CONTRATO_PRS, lidoEm, repositorio: r.repositorio, base: r.base, parcial: r.parcial,
-            ...(Array.isArray(r.semConferir) && r.semConferir.length ? { semConferir: r.semConferir } : {}), prs };
+        return { contrato: exports.CONTRATO_PRS, lidoEm, repositorio: r.repositorio, ...(typeof r.host === 'string' ? { host: r.host } : {}),
+            base: r.base, parcial: r.parcial, ...(Array.isArray(r.semConferir) && r.semConferir.length ? { semConferir: r.semConferir } : {}), prs };
     }
     catch {
         return null;
@@ -411,13 +535,25 @@ const doRadar = (e) => e.tipo === 'sessao_bloqueada' && e.fonte === 'ork session
  * intervalo do despacho. A prova do ork no SHIP e so o `ship_done` (`provaDoOrk`): o que falta e mergear o PR
  * ou registrar a entrega, e isso e do condutor, como o fim de turno em `blocked`. Dos 4 `human.pending` do SHIP
  * nos ledgers de 30/09, 2 tem este formato (ork-rm037noite e ork-pacotedeexpe). O CHECK em `done` sem o veredito
- * e outra coisa, e continua com o dono (A3 da rodada 5, pendente).
+ * e outra coisa: `checkSemVeredito`.
  */
 function shipSemRegistro(e) {
     const { ok: provou } = (e.provaOrk ?? {});
     return e.motivo === 'human.pending' && e.origem === 'sessions.watch' && e.fase === 'SHIP' && e.estadoNativo === 'done' &&
         !!e.stop && provou === false;
 }
+/**
+ * RM-037 (fatia 5, A3): o CHECK que o observador viu terminar em `done`, com o Stop, sem exatamente um veredito
+ * legivel no `docs/check.md` (`provaDoOrk`). No #Auto, com o bloco sem pausa ao fim, ninguem perguntou nada ao dono:
+ * o passo e do condutor, que redespacha o CHECK. Nos dois casos reais (ork-i35horariodo em 20/09 e ork-pacotedeexpe
+ * em 30/09, as duas #Auto) o condutor seguiu sozinho minutos depois, sem pergunta ao dono. Fora do #Auto, segue com
+ * o dono, como antes.
+ */
+function checkSemVeredito(e) {
+    const { ok: provou } = (e.provaOrk ?? {});
+    return e.motivo === 'human.pending' && e.origem === 'sessions.watch' && e.fase === 'CHECK' && e.estadoNativo === 'done' &&
+        !!e.stop && provou === false;
+}
 /**
  * O bloqueio que pede o dono: o prompt de permissao do hook e o que o radar leu com pergunta na tela. O
  * carimbo do radar no fim de turno (`blocked` lido sem menu nem pergunta) nao e prompt nenhum.
@@ -473,7 +609,8 @@ function atividadeDaSessao(e) {
         return !(e.sensor === 'notification' && e.notificationType === 'idle_prompt');
     return e.tipo === 'commit' || e.tipo === 'runtime_stop' || (e.tipo === 'sessao_bloqueada' && !doRadar(e));
 }
-function fimDoTurno(eventos, despacho) {
+/** `modo`: o da thread. Sem ele, o CHECK sem o veredito fica com o dono, como fora do #Auto. */
+function fimDoTurno(eventos, despacho, modo) {
     const i = eventos.lastIndexOf(despacho);
     const depois = eventos.slice(i + 1);
     const sid = texto(despacho.sessionId);
@@ -497,12 +634,13 @@ function fimDoTurno(eventos, despacho) {
             // S-a do CHECK (rodada 3): no bloco com pausa ao fim, todo `human.pending` do resultado e a fase entregue ao dono.
             return { em: resultado.ts, tipo: 'pausa-do-bloco', sessionId: sid, fase, comProva: true };
         }
-        else if (resultado.motivo === 'human.pending' && resultado.stop && (resultado.estadoNativo === 'blocked' || shipSemRegistro(resultado))) {
+        else if (resultado.motivo === 'human.pending' && resultado.stop && (resultado.estadoNativo === 'blocked' || shipSemRegistro(resultado) ||
+            (modo === 'auto' && checkSemVeredito(resultado)))) {
             if (!retomou) {
                 const { ts: doStop } = resultado.stop;
                 const { ok: provou } = (resultado.provaOrk ?? {});
-                return { em: instante(doStop) ?? resultado.ts, tipo: 'espera-do-observador', sessionId: sid, fase,
-                    comProva: typeof provou === 'boolean' ? provou : null };
+                return { em: instante(doStop) ?? resultado.ts, tipo: checkSemVeredito(resultado) ? 'check-sem-veredito' : 'espera-do-observador',
+                    sessionId: sid, fase, comProva: typeof provou === 'boolean' ? provou : null };
             }
         }
         else
@@ -544,17 +682,17 @@ function pendenciaDoDono(t, eventos, quando) {
         return 'prompt de permissão pendente';
     // Aviso da rodada 6 do CHECK: o gate do observador so muda de dono com o fim de turno provado. A sessao que voltou a
     // trabalhar depois do resultado, sem Stop novo, segue do dono, e a thread nao sai tambem como linha do condutor.
-    const fim = fimDoTurno(eventos, despacho);
+    const fim = fimDoTurno(eventos, despacho, t.modo);
     const turnoEncerrado = !!fim && fim.tipo !== 'outro';
     for (let k = 0; k < depois.length; k++) {
         const e = depois[k];
         if (e.tipo !== 'gate_blocked')
             continue;
         const motivo = String(e.motivo ?? '');
-        // O fim de turno que o observador viu em `blocked`, e o SHIP em `done` sem o `ship_done` (B1 da rodada 5), nao sao
-        // escalacao: sao justamente o que muda de dono.
+        // O fim de turno que o observador viu em `blocked`, o SHIP em `done` sem o `ship_done` (B1 da rodada 5) e, no #Auto,
+        // o CHECK em `done` sem o veredito (A3, fatia 5) nao sao escalacao: sao justamente o que muda de dono.
         if (turnoEncerrado && motivo === 'human.pending' && e.origem === 'sessions.watch' &&
-            (e.estadoNativo === 'blocked' || shipSemRegistro(e)))
+            (e.estadoNativo === 'blocked' || shipSemRegistro(e) || (t.modo === 'auto' && checkSemVeredito(e))))
             continue;
         const doDono = motivo === 'human.pending' ||
             (hitl_gates_1.MOTIVOS_DE_ESCALACAO_HUMANA.includes(motivo) && (0, hitl_classificacao_1.quemDecide)(motivo) === 'dono');
@@ -570,7 +708,7 @@ function esperaDoCondutor(t, eventos, quando) {
     const despacho = ultimoDespacho(eventos);
     if (!despacho || despacho.pausaAoFim !== false)
         return null;
-    const fim = fimDoTurno(eventos, despacho);
+    const fim = fimDoTurno(eventos, despacho, t.modo);
     if (!fim || fim.tipo === 'outro' || fim.tipo === 'pausa-do-bloco' || pendenciaDoDono(t, eventos, quando))
         return null;
     return { thread: t.id, fase: fim.fase, sessionId: fim.sessionId, fimDoTurnoEm: fim.em, tipo: fim.tipo, comProva: fim.comProva };
@@ -699,9 +837,13 @@ function entregasDoProjeto(carregado, opcoes) {
         // R4-4 do CHECK (rodada 4): o `ship_done` cobre a entrega do mesmo head (`shaDe`) ou do mesmo merge; a entrega
         // nova depois dele ainda nao foi registrada. O legado sem o sha cobre tudo, como antes.
         const cobre = (campo, sha) => ships.some((e) => typeof e[campo] !== 'string' || !SHA.test(e[campo]) || e[campo] === sha);
+        // RM-037 (fatia 5, A1): ate esta fatia, o `ork ship` com a branch ja incorporada gravava a ponta da base no
+        // `mergeSha`. Esse `ship_done` registra o merge `ship(<thread>)` que a ponta gravada contem.
+        const contemOMerge = (sha) => ships.some((e) => typeof e.mergeSha === 'string' && SHA.test(e.mergeSha) &&
+            e.mergeSha !== sha && git(raiz, ['merge-base', '--is-ancestor', sha, e.mergeSha]).code === 0);
         return { t, eventos, branch: cabeca ? branch : null, cabeca, comProduto, publicada, temRemota: !!remota,
             shipNoLedger: ships.length > 0, entregueNaPonta: cabeca ? cobre('shaDe', cabeca) : ships.length > 0,
-            mergeRegistrado: !!merge && cobre('mergeSha', merge.sha), merge };
+            mergeRegistrado: !!merge && (cobre('mergeSha', merge.sha) || contemOMerge(merge.sha)), merge };
     });
     // D2: a forja so e lida quando alguma thread tem o que mostrar la: produto numa branch que ja foi ao remoto
     // (inteira, ou com commit novo ainda sem push, que pode ter PR aberto).
@@ -710,11 +852,15 @@ function entregasDoProjeto(carregado, opcoes) {
     if (opcoes.lerPrs && candidatas.length)
         prs = opcoes.lerPrs(candidatas);
     // O retrato so vale do repositorio e da base de agora, e lido ha menos de `VALIDADE_DO_RETRATO_MIN`.
-    let retrato = null, semRetrato = prs && !prs.ok ? prs.erro : 'sem leitura dos PRs';
+    // RM-037 (fatia 5, A5): a forja sem leitura de PR e o estado dela, dito uma vez pelo pulse; a linha nunca diz "PR nao lido".
+    const semLeituraDaForja = !!prs && !prs.ok && !!prs.semLeitura;
+    let retrato = null, semRetrato = prs && !prs.ok ? (semLeituraDaForja ? exports.FORJA_SEM_LEITURA : prs.erro) : 'sem leitura dos PRs';
     if (prs?.ok) {
-        const r = prs.retrato;
-        if (r.base !== baseBranch || r.repositorio !== repositorioDoRemoto(raiz, remoto))
+        const r = prs.retrato, atual = githubDoRemoto(raiz, remoto);
+        // O retrato vale do mesmo host: o do GitHub Enterprise (`host`) ou, sem ele, o github.com.
+        if (r.base !== baseBranch || !atual || r.repositorio !== atual.repositorio || (r.host ?? 'github.com') !== atual.host) {
             semRetrato = 'retrato de PRs de outro repositório ou base';
+        }
         else if (minutosDesde(r.lidoEm, quando) > exports.VALIDADE_DO_RETRATO_MIN)
             semRetrato = 'retrato de PRs velho';
         else if (Date.parse(r.lidoEm) - Date.parse(quando) > FOLGA_DO_RELOGIO_MIN * 60000)
@@ -727,7 +873,7 @@ function entregasDoProjeto(carregado, opcoes) {
     for (const f of fatos) {
         const { t, eventos } = f;
         const despacho = ultimoDespacho(eventos);
-        const fim = despacho ? fimDoTurno(eventos, despacho) : null;
+        const fim = despacho ? fimDoTurno(eventos, despacho, t.modo) : null;
         const terminou = !!fim && fim.tipo !== 'outro';
         const fimEm = terminou ? fim.em : null;
         // A1 do CHECK (rodada 3): o fim de turno vem do ledger (Stop sem atividade depois); a tela da sessao depois
@@ -771,7 +917,15 @@ function entregasDoProjeto(carregado, opcoes) {
         let caso = null, desde = null, passo = '', peloGit = false;
         const evidencia = [];
         if (!conduzidaAgora && !doDono) {
-            if (f.comProduto && publicada === false && terminou) {
+            if (espera?.tipo === 'check-sem-veredito') {
+                // RM-037 (fatia 5, A3): antes de qualquer caso de entrega. Publicar ou mergear sem o veredito do CHECK pularia
+                // a revisao; e o `ork retry run` nao redespacha `human.pending` (`escalar-humano`), entao o passo e o despacho.
+                caso = 'check-sem-veredito';
+                desde = espera.fimDoTurnoEm;
+                passo = `redespachar o CHECK (ork phase run ${t.id} CHECK --prompt "<pedido da fase>")`;
+                evidencia.push('ledger: CHECK em done com o Stop, sem exatamente um veredito no docs/check.md');
+            }
+            else if (f.comProduto && publicada === false && terminou) {
                 desde = fimOuVeredito;
                 if (antesDaEntrega && !aberto) {
                     caso = 'fase-seguinte';
@@ -782,7 +936,8 @@ function entregasDoProjeto(carregado, opcoes) {
                     // N2 da seguranca (rodada 2): branch que ja foi ao remoto pode ter PR; sem a leitura, nunca "abrir o PR". A4 da
                     // rodada 5: publicar e abrir o PR pedem a mesma autorizacao de push que o merge.
                     passo = (aberto ? `publicar os commits novos da branch ${f.branch} no PR #${aberto.numero}`
-                        : f.temRemota && !prSabido ? `publicar os commits novos da branch ${f.branch} (PR não lido)`
+                        // RM-037 (fatia 5, A5): a forja sem leitura de PR ja foi dita uma vez; a linha so diz o passo.
+                        : f.temRemota && !prSabido ? `publicar os commits novos da branch ${f.branch}${semLeituraDaForja ? '' : ' (PR não lido)'}`
                             : `publicar a branch ${f.branch} e abrir o PR`) + autorizacao;
                 }
                 evidencia.push(`refs/heads/${f.branch} tem commit fora de refs/remotes/${remoto}/${f.branch}`);
@@ -850,7 +1005,8 @@ function entregasDoProjeto(carregado, opcoes) {
                     caso = 'sessao-sem-pergunta';
                     passo = f.shipNoLedger && !f.comProduto ? `fechar o MASTER da thread (ork master ${t.id})`
                         : aberto ? `acompanhar os checks do PR #${aberto.numero}, que seguem em andamento`
-                            : precisaDePr && !usouPr ? `conferir o PR da branch ${f.branch} (PR não lido) e seguir`
+                            : precisaDePr && !usouPr ? (semLeituraDaForja ? `conferir na forja o PR da branch ${f.branch} e seguir`
+                                : `conferir o PR da branch ${f.branch} (PR não lido) e seguir`)
                                 : `ler o fim da sessão ${id} (ork sessions logs ${id}) e seguir a thread`;
                 }
             }
@@ -880,7 +1036,7 @@ function entregasDoProjeto(carregado, opcoes) {
                 : daBranch.mesclado && !f.entregueNaPonta ? (f.merge && !f.mergeRegistrado ? `PR #${daBranch.mesclado.numero} mesclado, falta registrar a entrega (${registrar})`
                     : `PR #${daBranch.mesclado.numero} mesclado sem o assunto ship(${t.id}), falta registrar a entrega`)
                     : !f.comProduto && f.merge && !f.mergeRegistrado ? `merge ${f.merge.sha.slice(0, 7)} na base, falta registrar a entrega (${registrar})`
-                        : precisaDePr ? (!usouPr ? 'branch publicada, PR não lido'
+                        : precisaDePr ? (!usouPr ? (semLeituraDaForja ? `branch publicada, ${exports.FORJA_SEM_LEITURA}` : 'branch publicada, PR não lido')
                             : daBranch.fechado ? `branch publicada, PR #${daBranch.fechado.numero} fechado sem merge` : 'branch publicada sem PR')
                             : null;
         estados.push({ thread: t.id, branch: f.branch, comProduto: f.comProduto, publicada, pr: prDaEntrega,

package/dist/phase.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.REGRAS_DE_EVIDENCIA = exports.CONTRATO_DAS_FASES = void 0;
 exports.escolherPerfil = escolherPerfil;
+exports.perfilPedido = perfilPedido;
 exports.perfilParaDespacho = perfilParaDespacho;
 exports.runtimeCruzadoParaDespacho = runtimeCruzadoParaDespacho;
 exports.estadoParaDespacho = estadoParaDespacho;
@@ -71,12 +72,15 @@ const board_1 = require("./board");
 const verify_1 = require("./verify");
 const session_watcher_1 = require("./session-watcher");
 const session_watcher_claude_1 = require("./session-watcher-claude");
+const manifest_1 = require("./manifest");
+const mcp_grafo_1 = require("./mcp-grafo");
 const runtimes_1 = require("./runtimes");
 const setup_1 = require("./setup");
 const modos_1 = require("./modos");
 const gates_1 = require("./gates");
 const policies_1 = require("./policies");
 const ratelimit_1 = require("./ratelimit");
+const impedimento_1 = require("./impedimento");
 const claude_bg_1 = require("./adapters/claude-bg");
 const codex_1 = require("./adapters/codex");
 const memoria_1 = require("./memoria");
@@ -89,6 +93,7 @@ const ledger_1 = require("./ledger");
 const estado_thread_1 = require("./estado-thread");
 const horario_1 = require("./horario");
 const runtime_profiles_1 = require("./runtime-profiles");
+const sessoes_contas_1 = require("./sessoes-contas");
 const maquina_1 = require("./maquina");
 const fabrica_publicar_1 = require("./fabrica-publicar");
 const conducao_1 = require("./conducao");
@@ -102,18 +107,14 @@ function escolherPerfil(raiz, runtime, opcoes = {}) {
     // I-49: o despacho enxerga o estado que as outras fabricas viram na mesma conta.
     const store = (0, runtime_profiles_1.lerPerfisComContas)(raiz, opcoes.agoraMs);
     const doRuntime = (0, runtime_profiles_1.perfisDoRuntime)(store, runtime);
-    if (opcoes.perfil !== undefined) {
-        const pedido = doRuntime.find(p => p.id === opcoes.perfil);
-        if (!pedido)
-            return { perfil: null, configurados: doRuntime.length, erro: `perfil "${opcoes.perfil}" nao existe para o runtime ${runtime}` };
-        if (!(0, runtime_profiles_1.perfilDisponivel)(pedido, opcoes.agoraMs))
-            return { perfil: null, configurados: doRuntime.length,
-                erro: `perfil "${pedido.id}" esta ${pedido.estado}${pedido.esgotadoAte ? ` ate ${pedido.esgotadoAte}` : ''}` };
-        return { perfil: (0, runtime_profiles_1.perfilDeDespacho)(pedido), configurados: doRuntime.length };
-    }
+    if (opcoes.perfil !== undefined)
+        return perfilPedido(store, runtime, opcoes.perfil, opcoes.agoraMs);
     if (doRuntime.length === 0)
         return { perfil: null, configurados: 0 };
-    const proximo = (0, runtime_profiles_1.proximoPerfilDisponivel)(store, runtime, opcoes.politica ?? runtime_profiles_1.POLITICA_PADRAO, opcoes);
+    const politica = opcoes.politica ?? runtime_profiles_1.POLITICA_PADRAO;
+    const proximo = politica.distribuir === 'carga' && opcoes.carga
+        ? (0, runtime_profiles_1.proximoPerfilPorCarga)(store, runtime, politica, opcoes.carga, opcoes)
+        : (0, runtime_profiles_1.proximoPerfilDisponivel)(store, runtime, politica, opcoes);
     if (proximo)
         return { perfil: (0, runtime_profiles_1.perfilDeDespacho)(proximo), configurados: doRuntime.length };
     const agoraMs = opcoes.agoraMs ?? Date.now();
@@ -125,6 +126,41 @@ function escolherPerfil(raiz, runtime, opcoes = {}) {
     return { perfil: null, configurados: doRuntime.length, motivo,
         erro: `nenhum perfil disponivel do runtime ${runtime} (${doRuntime.map(p => `${p.id}: ${p.estado}`).join(', ')})` };
 }
+/**
+ * RM-056 (D1): o perfil PEDIDO (`--perfil`), validado contra o store. Recusa com motivo tipado e nunca
+ * troca de perfil: inexistente ou de outro runtime e `runtime.profile-invalid`; esgotado, a cota; sem
+ * login (ou de provider pago), o motivo do estado. Funcao propria, para o despacho da RM-055 rebasar limpo.
+ */
+function perfilPedido(store, runtime, id, agoraMs = Date.now()) {
+    const doRuntime = (0, runtime_profiles_1.perfisDoRuntime)(store, runtime);
+    const pedido = doRuntime.find(p => p.id === id);
+    if (!pedido) {
+        const outro = store.perfis.find(p => p.id === id);
+        return { perfil: null, configurados: doRuntime.length, motivo: 'runtime.profile-invalid',
+            erro: outro ? `perfil "${id}" e do runtime ${outro.runtime}, nao do ${runtime}`
+                : `perfil "${id}" nao existe no store (${doRuntime.length ? `perfis do ${runtime}: ${doRuntime.map(p => p.id).join(', ')}` : `nenhum perfil do ${runtime}`})` };
+    }
+    if ((0, runtime_profiles_1.perfilDisponivel)(pedido, agoraMs))
+        return { perfil: (0, runtime_profiles_1.perfilDeDespacho)(pedido), configurados: doRuntime.length };
+    const motivo = pedido.estado === 'esgotado' ? 'runtime.quota-exhausted' : pedido.estado === 'sem-auth'
+        ? 'runtime.auth-missing' : pedido.estado === 'provider-pago' ? 'cost.violation' : 'runtime.profile-invalid';
+    return { perfil: null, configurados: doRuntime.length, motivo,
+        erro: `perfil "${pedido.id}" esta ${pedido.estado}${pedido.esgotadoAte ? ` ate ${pedido.esgotadoAte}` : ''}` };
+}
+/**
+ * RM-056 (D3): a carga dos perfis do runtime, so quando o manifesto pede `distribuir: carga` e o
+ * dono nao pediu um perfil. Consulta falha vale carga desconhecida (zero): decide o desempate.
+ */
+function cargaDoDespacho(carregado, runtime, politica, pedido) {
+    if (politica.distribuir !== 'carga' || pedido !== undefined || !(0, runtime_profiles_1.runtimeComPerfil)(runtime))
+        return undefined;
+    try {
+        return (0, sessoes_contas_1.sessoesVivasPorPerfil)(carregado.raiz, runtime, carregado.manifesto.concurrency.stale_after_min);
+    }
+    catch {
+        return new Map();
+    }
+}
 /**
  * I-33 (D7, D13): preflight de auth antes do despacho. O perfil escolhido tem o login conferido
  * pelo proprio CLI com o env dele; reprovado, vira `sem-auth` no store (ou `provider-pago`, quando
@@ -136,8 +172,9 @@ function perfilParaDespacho(carregado, thread, fase, runtime, opcoes) {
     const { raiz } = carregado;
     const excluir = [...(opcoes.excluir ?? [])];
     const politica = (0, runtime_profiles_1.politicaDeRotacao)(carregado.manifesto);
+    const carga = cargaDoDespacho(carregado, runtime, politica, opcoes.perfil);
     for (;;) {
-        const escolha = escolherPerfil(raiz, runtime, { perfil: opcoes.perfil, excluir, politica });
+        const escolha = escolherPerfil(raiz, runtime, { perfil: opcoes.perfil, excluir, politica, carga });
         if (escolha.erro || !escolha.perfil || opcoes.dryRun)
             return escolha;
         const auth = runtime === 'claude-bg' ? (0, claude_bg_1.conferirAuth)(escolha.perfil) : runtime === 'codex' ? (0, codex_1.conferirAuth)(escolha.perfil)
@@ -164,7 +201,7 @@ function perfilParaDespacho(carregado, thread, fase, runtime, opcoes) {
             razao = 'o preflight de auth reprovou o perfil antes do despacho (D7): perfil sem login nunca recebe despacho';
         }
         excluir.push(escolha.perfil.id);
-        const proximo = opcoes.perfil === undefined ? escolherPerfil(raiz, runtime, { excluir, politica }).perfil : null;
+        const proximo = opcoes.perfil === undefined ? escolherPerfil(raiz, runtime, { excluir, politica, carga }).perfil : null;
         (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, thread.id), thread.id, ledger_1.TIPOS_DE_EVENTO.perfilRotacionado, {
             fase, motivo, origem: `${opcoes.origem}.preflight`,
             de: { runtime, perfil: escolha.perfil.id }, para: proximo ? { runtime, perfil: proximo.id } : null,
@@ -314,8 +351,10 @@ function montarPrompt(thread, fase, pedido, raiz, memoriaInjetada = '') {
  */
 function montarPromptComMemoria(carregado, thread, fase, pedido, memoria) {
     const injecao = (0, memoria_1.injecaoDaFase)(carregado, memoria, thread, fase);
+    // Mesma raiz usada pelo MCP e runtime-context; o manifesto da WT nao habilita a dica.
+    const ligado = (0, mcp_grafo_1.grafoLigado)((0, manifest_1.exigirManifesto)((0, estado_thread_1.raizDoEstado)(carregado.raiz)).manifesto);
     return {
-        prompt: montarPrompt(thread, fase, pedido, carregado.raiz, injecao.texto),
+        prompt: montarPrompt(thread, fase, (0, prompts_1.pedidoComDicaDoGrafo)(pedido, thread.id, ligado), carregado.raiz, injecao.texto),
         injecao,
     };
 }
@@ -1039,6 +1078,15 @@ tomadaPrevia) {
                     erro,
                 };
             }
+            // RM-055: o que so o dono resolve no terminal vira a pausa dele, com o comando exato e o que o ork
+            // faz depois. O prompt ja esta gravado com o sha256 acima, e e ele que o retry re-despacha.
+            const impedimento = (0, impedimento_1.registrarImpedimentoDoDono)(dir, thread, { fase, slug, runtime, cwd, origem: 'phase.run',
+                promptPath, promptSha256: sha, perfil, saida: `${resultado.stderr}\n${erro}` });
+            if (impedimento) {
+                return { thread, slug, promptPath, promptSha256: sha, comando: resultado.comando, controlador: resultado.controlador,
+                    sessionId: null, verificada: false, pausaAoFim, dryRun: false, runtime, model, effort, bloqueado: false,
+                    motivo: impedimento.motivo, violacoes, naFila: null, erro: `${impedimento.motivo}: ${impedimento.trecho}` };
+            }
             return {
                 thread,
                 slug,
@@ -1130,8 +1178,13 @@ function tabelaDoLedger(raiz, threadId) {
             detalhe.push(`acao ${String(e.acao)}`);
         if (e.playbook)
             detalhe.push(`playbook ${String(e.playbook)}`);
-        if (e.pedido)
-            detalhe.push(`pedido ${String(e.pedido)}`);
+        // Ensaio de 03/10/2026 (RM-049): na decisao autonoma o pedido e o objeto `ork.hitl/v2`, e a tabela
+        // mostrava "pedido [object Object]"; do objeto sai o id curto.
+        if (typeof e.pedido === 'string' && e.pedido !== '')
+            detalhe.push(`pedido ${e.pedido}`);
+        else if (e.pedido && typeof e.pedido === 'object' && typeof e.pedido.id === 'string') {
+            detalhe.push(`pedido ${e.pedido.id.slice(0, 8)}`);
+        }
         if (e.rodada !== undefined)
             detalhe.push(`rodada ${String(e.rodada)}`);
         if (e.cobertura)