@orkastery/cli 0.4.3 → 0.5.0

package/dist/forja.js

@@ -0,0 +1,435 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mesmaForja = exports.rotuloDaForja = exports.executorPadrao = void 0;
+exports.identidadeDaForja = identidadeDaForja;
+exports.forjaDoArgumento = forjaDoArgumento;
+exports.detalheSeguro = detalheSeguro;
+exports.classificarFalha = classificarFalha;
+exports.lerCommitsDaForja = lerCommitsDaForja;
+exports.lerDaForja = lerDaForja;
+/**
+ * RM-054 (fatia 1): a forja do projeto, lida sem clone e so com consulta.
+ *
+ * `ork/fabrica-estado` e `ork/roadmap-reservas` vivem no remoto de UM repositorio, e um host fora
+ * de um clone (o gateway do OpenClaw, um cron) nao enxergava nenhuma das duas. Aqui a leitura vai
+ * direto a forja, pela CLI dela ja autenticada (`gh`, `glab`): nenhum token e lido, copiado ou
+ * passado em argumento, e so consulta sai daqui (GraphQL sem mutation e GET no REST). O corpo da
+ * consulta vai pelo stdin, com os nomes em variaveis: nada do pedido e interpolado no texto.
+ *
+ * GitHub responde tudo em UMA consulta: a base com `docs/roadmap`, o manifesto e os commits desde
+ * `desde`, e as duas branches de estado, cada parte no commit que a propria consulta devolve.
+ * GitLab devolve a mesma leitura por consultas GraphQL e pelo REST de commits; sem `glab` na
+ * maquina que construiu, o esquema dele esta provado so com resposta simulada (D4 do PLAN).
+ *
+ * Resposta fora do formato vira erro tipado, nunca lista vazia: quem le nao confunde "nao li" com
+ * "nao tem".
+ */
+const node_child_process_1 = require("node:child_process");
+const hitl_1 = require("./hitl");
+const policies_1 = require("./policies");
+const PRAZO_MS = 30000;
+const SHA = /^[0-9a-f]{40}$/;
+const SEGMENTO = /^[A-Za-z0-9_.-]+$/;
+/** Hostname de verdade: rotulos alfanumericos separados por ponto (`..` ou `a..b` nao passam). */
+const HOST = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)+$/;
+/** Sem shell, sem token: a CLI usa a autenticacao que ja tem; prompt e aviso de versao desligados. */
+const executorPadrao = (cmd, args, entrada, timeoutMs) => {
+    const r = (0, node_child_process_1.spawnSync)(cmd, [...args], {
+        input: entrada, encoding: 'utf8', timeout: timeoutMs, maxBuffer: 32 * 1024 * 1024,
+        env: { ...process.env, GH_PROMPT_DISABLED: '1', GH_NO_UPDATE_NOTIFIER: '1', GLAB_CHECK_UPDATE: 'false', NO_COLOR: '1' },
+    });
+    return { status: r.status, stdout: (r.stdout ?? '').toString(), stderr: (r.stderr ?? '').toString(), sinal: r.signal ?? null,
+        ...(r.error ? { erro: r.error.code ?? r.error.message } : {}) };
+};
+exports.executorPadrao = executorPadrao;
+// ---------------------------------------------------------------------------
+// Identidade
+// ---------------------------------------------------------------------------
+function tipoDoHost(host) {
+    if (host === 'github.com' || /(^|[.-])github([.-]|$)/.test(host))
+        return 'github';
+    if (host === 'gitlab.com' || /(^|[.-])gitlab([.-]|$)/.test(host))
+        return 'gitlab';
+    return null;
+}
+function montar(tipo, host, caminho) {
+    if (!HOST.test(host))
+        return null;
+    const partes = caminho.replace(/\/+$/, '').replace(/\.git$/, '').split('/');
+    if (partes.some((p) => !SEGMENTO.test(p) || p === '.' || p === '..'))
+        return null;
+    if (tipo === 'github' ? partes.length !== 2 : partes.length < 2)
+        return null;
+    return { tipo, host, repo: partes.join('/') };
+}
+/**
+ * A forja de uma URL de remoto (https, ssh ou scp). Credencial na URL nunca entra na identidade;
+ * caminho local e forja desconhecida voltam null.
+ */
+function identidadeDaForja(url) {
+    const t = url.trim();
+    const esquema = /^(?:https?|ssh|git|git\+ssh|ssh\+git):\/\/(?:[^@/]*@)?([^/:?#@]+)(?::\d+)?\/([^?#\s]+)$/i.exec(t);
+    const scp = esquema ? null : /^(?:[^@\s/:]+@)?([^:\s/@]+):(?!\/\/)([^\s]+)$/.exec(t);
+    const achado = esquema ?? scp;
+    if (!achado)
+        return null;
+    const host = achado[1].toLowerCase();
+    const tipo = tipoDoHost(host);
+    return tipo ? montar(tipo, host, achado[2].replace(/^\/+/, '')) : null;
+}
+/** `github:dono/repo`, `gitlab:grupo/sub/repo` (com host proprio: `gitlab:host.tld/grupo/repo`) ou uma URL. */
+function forjaDoArgumento(texto) {
+    const t = texto.trim();
+    const m = /^(github|gitlab):(?:\/\/)?(.+)$/i.exec(t);
+    if (m) {
+        const tipo = m[1].toLowerCase();
+        const partes = m[2].replace(/^\/+/, '').split('/');
+        const comHost = partes.length > 2 && partes[0].includes('.');
+        const host = comHost ? partes[0].toLowerCase() : tipo === 'github' ? 'github.com' : 'gitlab.com';
+        return montar(tipo, host, (comHost ? partes.slice(1) : partes).join('/'));
+    }
+    return /^[a-z+]+:\/\//i.test(t) || /^[^@\s/:]+@[^:\s/]+:/.test(t) ? identidadeDaForja(t) : null;
+}
+/** Como a forja aparece para gente: `github.com/orkastery/orkastery`. */
+const rotuloDaForja = (f) => `${f.host}/${f.repo}`;
+exports.rotuloDaForja = rotuloDaForja;
+const mesmaForja = (a, b) => !!a && !!b && a.tipo === b.tipo && a.host === b.host && a.repo.toLowerCase() === b.repo.toLowerCase();
+exports.mesmaForja = mesmaForja;
+// ---------------------------------------------------------------------------
+// Erros
+// ---------------------------------------------------------------------------
+/** O fim da saida de erro, sem segredo: redigido, e descartado inteiro se ainda casar um padrao. */
+function detalheSeguro(texto) {
+    const redigido = (0, hitl_1.redigirSegredos)(texto)
+        .replace(/\b(?:glpat|gldt|glrt|glptt|glcbt)-[A-Za-z0-9_-]{16,}\b/g, '[redigido]')
+        .replace(/\bgithub_pat_[A-Za-z0-9_]{20,}\b/g, '[redigido]');
+    const linha = redigido.split('\n').map((l) => l.trim()).filter(Boolean).slice(-2).join(' ').slice(0, 240);
+    return (0, policies_1.procurarSegredos)(linha).length ? '[detalhe omitido: um padrão de segredo casou]' : linha;
+}
+function erro(codigo, detalhe) {
+    return { ok: false, erro: { codigo, detalhe } };
+}
+/** O motivo tipado de uma chamada que falhou. */
+function classificarFalha(cmd, s) {
+    if (s.erro === 'ENOENT')
+        return { codigo: 'forja.ausente', detalhe: `${cmd} não está instalado nesta máquina` };
+    if (s.erro === 'ETIMEDOUT' || s.sinal === 'SIGTERM')
+        return { codigo: 'forja.tempo-esgotado', detalhe: `${cmd} não respondeu em ${PRAZO_MS / 1000} s` };
+    const texto = `${s.stderr}\n${s.stdout}`;
+    const detalhe = detalheSeguro(s.stderr || s.stdout || s.erro || `${cmd} saiu com ${s.status}`);
+    if (/"type"\s*:\s*"NOT_FOUND"|Could not resolve to a Repository|404 Not Found|HTTP 404|project not found/i.test(texto)) {
+        return { codigo: 'forja.nao-encontrado', detalhe };
+    }
+    if (/auth login|not logged|authentication|HTTP 401|Bad credentials|GH_TOKEN|GITLAB_TOKEN|unauthorized|no token/i.test(texto)) {
+        return { codigo: 'forja.sem-login', detalhe };
+    }
+    return { codigo: 'forja.inacessivel', detalhe };
+}
+const obj = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+class RespostaInvalida extends Error {
+}
+class NaoEncontrado extends Error {
+}
+const exigir = (condicao, onde) => { if (!condicao)
+    throw new RespostaInvalida(onde); };
+function chamarJson(executor, cmd, args, corpo) {
+    const s = executor(cmd, args, corpo, PRAZO_MS);
+    let json;
+    try {
+        json = JSON.parse(s.stdout);
+    }
+    catch {
+        json = undefined;
+    }
+    const erros = obj(json) && Array.isArray(json.errors) && json.errors.length > 0;
+    if (s.erro || s.status !== 0 || erros) {
+        const falha = classificarFalha(cmd, s.erro || s.status !== 0 ? s : { ...s, status: 1, stderr: JSON.stringify(json) });
+        // `gh` sai 1 com NOT_FOUND no corpo: o tipo do erro GraphQL vale mais que a frase.
+        if (erros && json.errors.some((e) => obj(e) && e.type === 'NOT_FOUND')) {
+            return { ok: false, erro: { codigo: 'forja.nao-encontrado', detalhe: falha.detalhe } };
+        }
+        return { ok: false, erro: falha };
+    }
+    if (json === undefined)
+        return { ok: false, erro: { codigo: 'forja.resposta-invalida', detalhe: `${cmd} não devolveu JSON` } };
+    return { ok: true, json };
+}
+/**
+ * O host vai sempre explicito: sem ele, o `gh` usa `GH_HOST` ou o unico host com login, e o `glab`,
+ * o host do remoto do cwd; a consulta iria para outra forja.
+ */
+const hostnameDe = (f) => ['--hostname', f.host];
+function arquivosDoGithub(entrada, dir) {
+    if (entrada === null)
+        return null;
+    exigir(obj(entrada), `${dir}: entrada`);
+    const objeto = entrada.object;
+    if (objeto === null)
+        return null;
+    exigir(obj(objeto) && Array.isArray(objeto.entries), `${dir}: diretorio`);
+    return objeto.entries.filter((e) => obj(e) && e.type === 'blob').map((e) => {
+        const x = e, blob = obj(x.object) ? x.object : {};
+        exigir(typeof x.name === 'string', `${dir}: nome`);
+        const legivel = typeof blob.text === 'string' && blob.isBinary !== true && blob.isTruncated !== true;
+        return { caminho: `${dir}/${x.name}`, texto: legivel ? blob.text : null };
+    });
+}
+function pontaDoGithub(ref, onde) {
+    if (ref === null)
+        return null;
+    exigir(obj(ref) && obj(ref.target), `${onde}: ref`);
+    const alvo = ref.target;
+    exigir(typeof alvo.oid === 'string' && SHA.test(alvo.oid), `${onde}: commit`);
+    return { commit: alvo.oid, dataDoCommit: typeof alvo.committedDate === 'string' ? alvo.committedDate : null,
+        nome: typeof ref.name === 'string' ? ref.name : onde, alvo };
+}
+/** Os commits de um `history` do GitHub, e se a forja cortou a pagina (mais de 100 na janela). */
+function commitsDoHistorico(historico, onde) {
+    const h = obj(historico) ? historico : {};
+    const nos = h.nodes ?? [];
+    exigir(Array.isArray(nos), `${onde}: commits`);
+    return {
+        commits: nos.filter(obj).map((n) => {
+            exigir(typeof n.oid === 'string' && typeof n.messageHeadline === 'string' && typeof n.committedDate === 'string', `${onde}: commit`);
+            return { commit: n.oid, assunto: n.messageHeadline, data: n.committedDate };
+        }),
+        parciais: obj(h.pageInfo) && h.pageInfo.hasNextPage === true,
+    };
+}
+/** Os commits da base desde `desde`, pelo REST do GitLab (GET), e se vieram 100 (pagina cheia). */
+function commitsDoGitlab(forja, commit, desde, executor) {
+    const rest = executor('glab', ['api', `projects/${encodeURIComponent(forja.repo)}/repository/commits?ref_name=${encodeURIComponent(commit)}` +
+            `&since=${encodeURIComponent(desde)}&per_page=100`, ...hostnameDe(forja)], '', PRAZO_MS);
+    if (rest.erro || rest.status !== 0)
+        return { ok: false, erro: classificarFalha('glab', rest) };
+    let lista;
+    try {
+        lista = JSON.parse(rest.stdout);
+    }
+    catch {
+        lista = undefined;
+    }
+    exigir(Array.isArray(lista), 'commits');
+    const commits = lista.map((c) => {
+        exigir(obj(c) && typeof c.id === 'string' && typeof c.title === 'string' && typeof c.committed_date === 'string', 'commit');
+        return { commit: c.id, assunto: c.title, data: c.committed_date };
+    });
+    return { ok: true, commits, parciais: commits.length >= 100 };
+}
+function consultaDoGithub(comBase) {
+    return `query($owner: String!, $name: String!${comBase ? ', $base: String!' : ''}, $desde: GitTimestamp!, $dirRoadmap: String!,
+  $manifesto: String!, $refReservas: String!, $dirReservas: String!, $refFabrica: String!, $dirFabrica: String!) {
+  repository(owner: $owner, name: $name) {
+    base: ${comBase ? 'ref(qualifiedName: $base)' : 'defaultBranchRef'} { name target { ... on Commit { oid committedDate
+      roadmap: file(path: $dirRoadmap) { object { ...Arquivos } }
+      manifesto: file(path: $manifesto) { object { ... on Blob { text isBinary isTruncated } } }
+      history(since: $desde, first: 100) { pageInfo { hasNextPage } nodes { oid messageHeadline committedDate } } } } }
+    reservas: ref(qualifiedName: $refReservas) { name target { ... on Commit { oid committedDate
+      arquivos: file(path: $dirReservas) { object { ...Arquivos } } } } }
+    fabrica: ref(qualifiedName: $refFabrica) { name target { ... on Commit { oid committedDate
+      arquivos: file(path: $dirFabrica) { object { ...Arquivos } } } } }
+  }
+}
+fragment Arquivos on Tree { entries { name type object { ... on Blob { text isBinary isTruncated } } } }`;
+}
+function lerDoGithub(forja, pedido, executor, lidoEm) {
+    const [owner, name] = forja.repo.split('/');
+    const comBase = !!pedido.base;
+    const corpo = JSON.stringify({ query: consultaDoGithub(comBase), variables: {
+            owner, name, ...(comBase ? { base: `refs/heads/${pedido.base}` } : {}), desde: pedido.desde,
+            dirRoadmap: pedido.dirRoadmap, manifesto: pedido.manifesto,
+            refReservas: `refs/heads/${pedido.reservas.branch}`, dirReservas: pedido.reservas.dir,
+            refFabrica: `refs/heads/${pedido.fabrica.branch}`, dirFabrica: pedido.fabrica.dir,
+        } });
+    const r = chamarJson(executor, 'gh', ['api', 'graphql', '--method', 'POST', '--input', '-', ...hostnameDe(forja)], corpo);
+    if (!r.ok)
+        return r;
+    const dados = obj(r.json) ? r.json.data : undefined;
+    exigir(obj(dados) && obj(dados.repository), 'repositorio');
+    const repo = dados.repository;
+    const base = pontaDoGithub(repo.base ?? null, 'base');
+    let leituraDaBase = null;
+    if (base) {
+        const manifesto = obj(base.alvo.manifesto) && obj(base.alvo.manifesto.object) &&
+            typeof base.alvo.manifesto.object.text === 'string' ? base.alvo.manifesto.object.text : null;
+        const historico = commitsDoHistorico(base.alvo.history, 'base');
+        leituraDaBase = { ref: base.nome, commit: base.commit, dataDoCommit: base.dataDoCommit,
+            arquivos: arquivosDoGithub(base.alvo.roadmap ?? null, pedido.dirRoadmap), parcial: false, manifesto,
+            commits: historico.commits, commitsParciais: historico.parciais };
+    }
+    const estado = (bruto, b) => {
+        const p = pontaDoGithub(bruto ?? null, b.branch);
+        return p ? { ref: b.branch, commit: p.commit, dataDoCommit: p.dataDoCommit, arquivos: arquivosDoGithub(p.alvo.arquivos ?? null, b.dir),
+            parcial: false } : null;
+    };
+    return { ok: true, leitura: { forja, lidoEm, chamadas: 1, base: leituraDaBase,
+            reservas: estado(repo.reservas, pedido.reservas), fabrica: estado(repo.fabrica, pedido.fabrica) } };
+}
+const CONSULTA_RAIZ_GITLAB = 'query($path: ID!) { project(fullPath: $path) { repository { rootRef } } }';
+const CONSULTA_ARVORES_GITLAB = `query($path: ID!, $base: String!, $dirRoadmap: String!, $refReservas: String!, $dirReservas: String!,
+  $refFabrica: String!, $dirFabrica: String!) {
+  project(fullPath: $path) { repository {
+    baseTopo: tree(ref: $base) { lastCommit { sha committedDate } }
+    baseDir: tree(ref: $base, path: $dirRoadmap) { blobs(first: 100) { pageInfo { hasNextPage } nodes { name path } } }
+    reservasTopo: tree(ref: $refReservas) { lastCommit { sha committedDate } }
+    reservasDir: tree(ref: $refReservas, path: $dirReservas) { blobs(first: 100) { pageInfo { hasNextPage } nodes { name path } } }
+    fabricaTopo: tree(ref: $refFabrica) { lastCommit { sha committedDate } }
+    fabricaDir: tree(ref: $refFabrica, path: $dirFabrica) { blobs(first: 100) { pageInfo { hasNextPage } nodes { name path } } }
+  } }
+}`;
+/** Os blobs de cada ponta que existe; so as partes pedidas entram na consulta (texto fixo, sem interpolar o pedido). */
+function consultaDeBlobsDoGitlab(partes) {
+    const sufixo = { base: 'Base', reservas: 'Reservas', fabrica: 'Fabrica' };
+    const declaracoes = ['$path: ID!', ...partes.flatMap((p) => [`$ref${sufixo[p]}: String!`, `$paths${sufixo[p]}: [String!]!`])];
+    const campos = partes.map((p) => `${p}: blobs(ref: $ref${sufixo[p]}, paths: $paths${sufixo[p]}, first: 100) ` +
+        '{ pageInfo { hasNextPage } nodes { path rawTextBlob } }');
+    return `query(${declaracoes.join(', ')}) { project(fullPath: $path) { repository { ${campos.join(' ')} } } }`;
+}
+function lerDoGitlab(forja, pedido, executor, lidoEm) {
+    const args = ['api', 'graphql', '--method', 'POST', '--input', '-', ...hostnameDe(forja)];
+    let chamadas = 0;
+    const graphql = (query, variables) => { chamadas++; return chamarJson(executor, 'glab', args, JSON.stringify({ query, variables })); };
+    const repositorio = (json) => {
+        const projeto = obj(json) && obj(json.data) ? json.data.project : undefined;
+        if (projeto === null)
+            throw new NaoEncontrado();
+        exigir(obj(projeto) && obj(projeto.repository), 'repositorio');
+        return projeto.repository;
+    };
+    let base = pedido.base ?? null;
+    if (!base) {
+        const r = graphql(CONSULTA_RAIZ_GITLAB, { path: forja.repo });
+        if (!r.ok)
+            return r;
+        const raiz = repositorio(r.json).rootRef;
+        base = typeof raiz === 'string' && raiz ? raiz : null;
+    }
+    const arvores = graphql(CONSULTA_ARVORES_GITLAB, { path: forja.repo, base: base ?? 'HEAD', dirRoadmap: pedido.dirRoadmap,
+        refReservas: pedido.reservas.branch, dirReservas: pedido.reservas.dir, refFabrica: pedido.fabrica.branch, dirFabrica: pedido.fabrica.dir });
+    if (!arvores.ok)
+        return arvores;
+    const repo = repositorio(arvores.json);
+    const topo = (chave) => {
+        const arvore = repo[chave];
+        if (!obj(arvore) || arvore.lastCommit === null || arvore.lastCommit === undefined)
+            return null;
+        const c = arvore.lastCommit;
+        exigir(obj(c) && typeof c.sha === 'string' && SHA.test(c.sha), `${chave}: commit`);
+        return { commit: c.sha, dataDoCommit: typeof c.committedDate === 'string' ? c.committedDate : null };
+    };
+    const cortadas = new Set();
+    const cortou = (conexao, chave) => {
+        if (obj(conexao.pageInfo) && conexao.pageInfo.hasNextPage === true)
+            cortadas.add(chave);
+    };
+    const caminhos = (chave) => {
+        const arvore = repo[chave];
+        if (!obj(arvore))
+            return null;
+        exigir(obj(arvore.blobs) && Array.isArray(arvore.blobs.nodes), `${chave}: blobs`);
+        cortou(arvore.blobs, chave);
+        return arvore.blobs.nodes.map((n) => {
+            exigir(obj(n) && typeof n.path === 'string', `${chave}: caminho`);
+            return n.path;
+        });
+    };
+    const [pontaBase, pontaReservas, pontaFabrica] = [base ? topo('baseTopo') : null, topo('reservasTopo'), topo('fabricaTopo')];
+    const dirBase = pontaBase ? caminhos('baseDir') : null;
+    const dirReservas = pontaReservas ? caminhos('reservasDir') : null, dirFabrica = pontaFabrica ? caminhos('fabricaDir') : null;
+    const pedidos = [
+        ['base', pontaBase, pontaBase ? [...(dirBase ?? []), pedido.manifesto] : []],
+        ['reservas', pontaReservas, dirReservas ?? []],
+        ['fabrica', pontaFabrica, dirFabrica ?? []],
+    ].filter(([, ponta, paths]) => ponta && paths.length > 0);
+    let conteudo = {};
+    if (pedidos.length) {
+        const sufixo = { base: 'Base', reservas: 'Reservas', fabrica: 'Fabrica' };
+        const variaveis = { path: forja.repo };
+        for (const [parte, ponta, paths] of pedidos) {
+            variaveis[`ref${sufixo[parte]}`] = ponta.commit;
+            variaveis[`paths${sufixo[parte]}`] = paths;
+        }
+        const blobs = graphql(consultaDeBlobsDoGitlab(pedidos.map(([parte]) => parte)), variaveis);
+        if (!blobs.ok)
+            return blobs;
+        conteudo = repositorio(blobs.json);
+    }
+    const textos = (chave) => {
+        const c = conteudo[chave];
+        if (c === null || c === undefined)
+            return new Map();
+        exigir(obj(c) && Array.isArray(c.nodes), `${chave}: conteudo`);
+        cortou(c, chave);
+        return new Map(c.nodes.map((n) => {
+            exigir(obj(n) && typeof n.path === 'string', `${chave}: blob`);
+            return [n.path, typeof n.rawTextBlob === 'string' ? n.rawTextBlob : null];
+        }));
+    };
+    const arquivos = (lista, mapa) => lista === null ? null : lista.map((caminho) => ({ caminho, texto: mapa.get(caminho) ?? null }));
+    let commits = [];
+    let commitsParciais = false;
+    if (pontaBase) {
+        chamadas++;
+        const r = commitsDoGitlab(forja, pontaBase.commit, pedido.desde, executor);
+        if (!r.ok)
+            return r;
+        commits = r.commits;
+        commitsParciais = r.parciais;
+    }
+    const [mapaBase, mapaReservas, mapaFabrica] = [textos('base'), textos('reservas'), textos('fabrica')];
+    const parcial = (dir, conteudo) => cortadas.has(dir) || cortadas.has(conteudo);
+    return { ok: true, leitura: { forja, lidoEm, chamadas,
+            base: pontaBase ? { ref: base ?? 'HEAD', ...pontaBase, arquivos: arquivos(dirBase, mapaBase), parcial: parcial('baseDir', 'base'),
+                manifesto: mapaBase.get(pedido.manifesto) ?? null, commits, commitsParciais } : null,
+            reservas: pontaReservas ? { ref: pedido.reservas.branch, ...pontaReservas, arquivos: arquivos(dirReservas, mapaReservas),
+                parcial: parcial('reservasDir', 'reservas') } : null,
+            fabrica: pontaFabrica ? { ref: pedido.fabrica.branch, ...pontaFabrica, arquivos: arquivos(dirFabrica, mapaFabrica),
+                parcial: parcial('fabricaDir', 'fabrica') } : null } };
+}
+const CONSULTA_DE_COMMITS_GITHUB = `query($owner: String!, $name: String!, $oid: GitObjectID!, $desde: GitTimestamp!) {
+  repository(owner: $owner, name: $name) { object(oid: $oid) { ... on Commit {
+    history(since: $desde, first: 100) { pageInfo { hasNextPage } nodes { oid messageHeadline committedDate } } } } }
+}`;
+/**
+ * So os commits de um commit da base desde `desde`, quando a janela da primeira leitura ficou curta:
+ * o fuso do projeto so se conhece depois de ler o manifesto dele (achado 5 da rodada 2). So consulta.
+ */
+function lerCommitsDaForja(forja, pedido, executor = exports.executorPadrao) {
+    if (!SHA.test(pedido.commit))
+        return erro('forja.resposta-invalida', 'commit da base fora do formato');
+    try {
+        if (forja.tipo === 'gitlab')
+            return commitsDoGitlab(forja, pedido.commit, pedido.desde, executor);
+        const [owner, name] = forja.repo.split('/');
+        const r = chamarJson(executor, 'gh', ['api', 'graphql', '--method', 'POST', '--input', '-', ...hostnameDe(forja)], JSON.stringify({ query: CONSULTA_DE_COMMITS_GITHUB, variables: { owner, name, oid: pedido.commit, desde: pedido.desde } }));
+        if (!r.ok)
+            return r;
+        const dados = obj(r.json) ? r.json.data : undefined;
+        exigir(obj(dados) && obj(dados.repository), 'repositorio');
+        const objeto = dados.repository.object;
+        exigir(obj(objeto), 'commit');
+        return { ok: true, ...commitsDoHistorico(objeto.history, 'commits') };
+    }
+    catch (e) {
+        if (e instanceof RespostaInvalida)
+            return erro('forja.resposta-invalida', `resposta fora do formato esperado em ${e.message}`);
+        throw e;
+    }
+}
+/**
+ * Le da forja a base (com `docs/roadmap`, o manifesto e os commits desde `desde`) e as duas branches
+ * de estado. So consulta; qualquer falha volta como erro tipado, com o detalhe redigido.
+ */
+function lerDaForja(forja, pedido, executor = exports.executorPadrao) {
+    const lidoEm = pedido.lidoEm ?? new Date().toISOString();
+    try {
+        return forja.tipo === 'github' ? lerDoGithub(forja, pedido, executor, lidoEm) : lerDoGitlab(forja, pedido, executor, lidoEm);
+    }
+    catch (e) {
+        if (e instanceof NaoEncontrado)
+            return erro('forja.nao-encontrado', `${(0, exports.rotuloDaForja)(forja)} não existe ou não é visível para o login da forja`);
+        if (e instanceof RespostaInvalida)
+            return erro('forja.resposta-invalida', `resposta fora do formato esperado em ${e.message}`);
+        throw e;
+    }
+}

package/dist/gates.js

@@ -20,6 +20,7 @@ exports.registrarGateLiberado = registrarGateLiberado;
 exports.descreverMotivo = descreverMotivo;
 exports.aprovarGateHumano = aprovarGateHumano;
 exports.aprovacaoHumanaProvada = aprovacaoHumanaProvada;
+exports.reciboHumanoConfere = reciboHumanoConfere;
 exports.aprovacoesHumanas = aprovacoesHumanas;
 const ledger_1 = require("./ledger");
 const modos_1 = require("./modos");
@@ -129,7 +130,14 @@ function formaDeAprovacao(e) {
  * trocados no disco ou com canal trocado no ledger.
  */
 function aprovacaoHumanaProvada(raiz, threadId, e) {
-    if (!formaDeAprovacao(e))
+    return formaDeAprovacao(e) && reciboHumanoConfere(raiz, threadId, e);
+}
+/**
+ * K3.1: a mesma prova, para qualquer veredito do gate. O dossiê de decisão mostra a resposta do
+ * dono só quando o recibo do ingresso confere; aprovar ou recusar não muda o que se reconfere.
+ */
+function reciboHumanoConfere(raiz, threadId, e) {
+    if (e.tipo !== ledger_1.TIPOS_DE_EVENTO.pausaHumana)
         return false;
     if (e.origem === 'telegram' || e.origem === 'native')
         return (0, hitl_ingress_receipt_1.validarEvidenciaDoIngresso)(raiz, threadId, e);

package/dist/hitl-classificacao.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CLASSES_QUE_NAO_BLOQUEIAM = exports.JANELA_PADRAO_MIN = void 0;
+exports.MOTIVOS_DO_ORQUESTRADOR = exports.CLASSES_QUE_NAO_BLOQUEIAM = exports.JANELA_PADRAO_MIN = void 0;
 exports.atoIrreversivelDoItem = atoIrreversivelDoItem;
+exports.quemDecide = quemDecide;
 exports.classificarItem = classificarItem;
 exports.contarClassificacoes = contarClassificacoes;
 /**
@@ -65,6 +66,15 @@ function atoIrreversivelDoItem(item) {
     }
     return hitl_contract_1.ATO_IRREVERSIVEL_DO_MOTIVO[item.motivo];
 }
+exports.MOTIVOS_DO_ORQUESTRADOR = Object.freeze([
+    'runtime.unavailable', 'runtime.silencio', 'runtime.rate-limited', 'artifact.missing',
+    'verify.failed', 'verify.regression', 'verify.timeout', 'verify.sem-veredito',
+    'claims.failed', 'claims.unverifiable', 'ci.failed', 'hitl.formato',
+    'lease.busy', 'vaga.stale', 'conducao.em-andamento', 'concurrency.limite',
+]);
+function quemDecide(motivo) {
+    return exports.MOTIVOS_DO_ORQUESTRADOR.includes(String(motivo ?? '')) ? 'orquestrador' : 'dono';
+}
 /** Nome curto da sessao, do jeito que o dono ja ve em `ork board` e nos comandos de log. */
 const sessaoCurta = (id) => id.slice(0, 8);
 function classificarItem(item, opcoes) {

package/dist/hitl-contract.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONTRATOS_DE_PEDIDO = exports.CAMPOS_DE_GATE = exports.TETOS_HITL_V2 = exports.LETRAS_DE_ALTERNATIVA = exports.CONTRATO_HITL_V2 = exports.ATO_IRREVERSIVEL_DO_MOTIVO = exports.ATOS_IRREVERSIVEIS = exports.CONTRATO_HITL = void 0;
+exports.CONTRATOS_DE_PEDIDO = exports.CAMPOS_DA_DECISAO_NO_MCP = exports.CAMPOS_DA_DECISAO_NO_CLI = exports.CAMPOS_DE_GATE = exports.TETOS_HITL_V2 = exports.LETRAS_DE_ALTERNATIVA = exports.CONTRATO_HITL_V2 = exports.ATO_IRREVERSIVEL_DO_MOTIVO = exports.ATOS_IRREVERSIVEIS = exports.CONTRATO_HITL = void 0;
 exports.atoDaPausa = atoDaPausa;
 exports.profundidadeDoModo = profundidadeDoModo;
 exports.profundidadeDoPedido = profundidadeDoPedido;
@@ -9,6 +9,7 @@ exports.estadoDoPedido = estadoDoPedido;
 exports.respostaAceitaDoPedido = respostaAceitaDoPedido;
 exports.validarRespostaHitl = validarRespostaHitl;
 exports.vereditoDoGate = vereditoDoGate;
+exports.recusaNaSuperficie = recusaNaSuperficie;
 exports.validarPedidoHitlV2 = validarPedidoHitlV2;
 exports.validarPedidoHitl = validarPedidoHitl;
 exports.ehV2 = ehV2;
@@ -216,24 +217,66 @@ function validarComumV2(v) {
         throw new Error('pedido HITL v2: identificação, modo, instante ou profundidade inválidos');
     }
 }
+/**
+ * RM-037 (rm037defeito, defeito 4): o que esta errado num campo de linha unica, ou null. A recusa diz
+ * o campo e o motivo real: texto presente e acima do teto respondia "exige o que foi decidido", e quem
+ * mandou os tres campos nao tinha como saber que o problema era o tamanho.
+ */
+function problemaDaLinha(campo, v, teto) {
+    if (typeof v !== 'string' || !v.trim())
+        return { ausente: true, texto: `falta ${campo}` };
+    if (/[\r\n]/.test(v))
+        return { ausente: false, texto: `${campo} tem quebra de linha; cada campo é uma linha só` };
+    if (/[\x00-\x08\x0b-\x1f\x7f]/.test(v))
+        return { ausente: false, texto: `${campo} tem caractere de controle` };
+    if (v.length > teto)
+        return { ausente: false, texto: `${campo} tem ${v.length} caracteres; o teto é ${teto}` };
+    return null;
+}
+/**
+ * Os campos da decisao informada como cada superficie os mostra (achado S4 do CHECK): a recusa do contrato
+ * usa o nome interno, e quem digitou `--como-mudar` ou mandou `custoAgora` precisa ler o nome que usou.
+ */
+exports.CAMPOS_DA_DECISAO_NO_CLI = Object.freeze({
+    decidido: '--decidido', porque: '--porque', comoMudar: '--como-mudar', 'custoDeReverter.agora': '--custo-agora',
+    'custoDeReverter.depois': '--custo-depois', 'criterio.referencia': '--criterio',
+});
+exports.CAMPOS_DA_DECISAO_NO_MCP = Object.freeze({
+    decidido: 'decidido', porque: 'porque', comoMudar: 'comoMudar', 'custoDeReverter.agora': 'custoAgora',
+    'custoDeReverter.depois': 'custoDepois', 'criterio.referencia': 'criterio.referencia',
+});
+/** Troca o nome interno do campo, onde a recusa o cita, pelo nome da superficie. */
+function recusaNaSuperficie(mensagem, nomes) {
+    return mensagem.replace(/(falta |: )(decidido|porque|comoMudar|custoDeReverter\.agora|custoDeReverter\.depois|criterio\.referencia)(?=\)| tem )/g, (_, antes, campo) => `${antes}${nomes[campo] ?? campo}`);
+}
 function validarDecidido(v) {
     for (const campo of exports.CAMPOS_DE_GATE) {
         if (v[campo] !== undefined)
             throw new Error(`pedido HITL v2: decisão informada não pode trazer ${campo}`);
     }
-    if (!linhaUnica(v.decidido, exports.TETOS_HITL_V2.campoDaDecisao) || !linhaUnica(v.porque, exports.TETOS_HITL_V2.campoDaDecisao) ||
-        !linhaUnica(v.comoMudar, exports.TETOS_HITL_V2.campoDaDecisao)) {
-        throw new Error('pedido HITL v2: decisão informada exige o que foi decidido, o porquê e como mudar');
+    for (const campo of ['decidido', 'porque', 'comoMudar']) {
+        const problema = problemaDaLinha(campo, v[campo], exports.TETOS_HITL_V2.campoDaDecisao);
+        if (problema?.ausente)
+            throw new Error(`pedido HITL v2: decisão informada exige o que foi decidido, o porquê e como mudar (${problema.texto})`);
+        if (problema)
+            throw new Error(`pedido HITL v2: decisão informada: ${problema.texto}`);
     }
     const custo = v.custoDeReverter;
-    if (!objeto(custo) || !linhaUnica(custo.agora, exports.TETOS_HITL_V2.custo) || !linhaUnica(custo.depois, exports.TETOS_HITL_V2.custo)) {
+    const problemasDoCusto = ['agora', 'depois']
+        .map(lado => problemaDaLinha(`custoDeReverter.${lado}`, objeto(custo) ? custo[lado] : undefined, exports.TETOS_HITL_V2.custo));
+    if (problemasDoCusto.some(p => p?.ausente)) {
         throw new Error('pedido HITL v2: custo de reverter exige agora e depois, os dois presentes');
     }
+    const doCusto = problemasDoCusto.find(p => p !== null);
+    if (doCusto)
+        throw new Error(`pedido HITL v2: custo de reverter: ${doCusto.texto}`);
     const criterio = v.criterio;
-    if (!objeto(criterio) || !['manifesto', 'ledger', 'medicao'].includes(criterio.tipo) ||
-        !linhaUnica(criterio.referencia, 300)) {
+    const daReferencia = objeto(criterio) ? problemaDaLinha('criterio.referencia', criterio.referencia, 300) : null;
+    if (!objeto(criterio) || !['manifesto', 'ledger', 'medicao'].includes(criterio.tipo) || daReferencia?.ausente) {
         throw new Error('pedido HITL v2: decisão informada exige critério citado e resolvível');
     }
+    if (daReferencia)
+        throw new Error(`pedido HITL v2: critério: ${daReferencia.texto}`);
     // R1, porta fechada: ato irreversivel nunca se qualifica como decisao informada.
     if (v.irreversivel === true)
         throw new Error('pedido HITL v2: ato irreversível nunca é decisão informada');