@orkastery/cli 0.5.3 → 0.6.0

package/dist/check-paralelo.js

@@ -0,0 +1,183 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.argvDoItem = argvDoItem;
+exports.esperaDoGrupo = esperaDoGrupo;
+exports.rodarEmParalelo = rodarEmParalelo;
+/**
+ * RM-072 (D6 da ork-check5x): o grupo paralelo do Agile Check sem mudar a assinatura do `verificar`.
+ *
+ * O `verificar` e sincrono e tem varios chamadores (CLI, MCP, ship, fix, retry, ci, noctum). Para rodar as lanes de teste
+ * e a varredura ao mesmo tempo, o verify chama este modulo com `spawnSync` como processo auxiliar: ele lanca cada
+ * comando ao mesmo tempo, cada um com o mesmo `timeout(1)` do `executar` (o estouro leva o grupo de processos inteiro),
+ * grava a saida de cada um num arquivo e espera todos. O pai le os arquivos e monta cada resultado pela mesma funcao do
+ * `executar`. O ambiente vem do pai, ja sem `ORK_HITL_*`; cada item so acrescenta variaveis sem segredo (o modo, o
+ * relatorio do CHECK, o prazo interno do scan). O item que nomeia outros em `apos` so comeca quando eles terminam (a lane
+ * de integracao depois da varredura), e `maxParalelo` limita quantos rodam ao mesmo tempo.
+ */
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const TIMEOUT_BIN = '/usr/bin/timeout';
+const NICE_BIN = '/usr/bin/nice';
+/** O argv de um item: `nice` (se pedido e existir), `timeout(1)` (se existir) e `bash -c`. */
+function argvDoItem(item, comGrupo = fs.existsSync(TIMEOUT_BIN), comNice = fs.existsSync(NICE_BIN)) {
+    const base = comGrupo
+        ? [TIMEOUT_BIN, '--kill-after=15', `${Math.ceil(item.prazoMs / 1000)}`, 'bash', '-c', item.comando]
+        : ['bash', '-c', item.comando];
+    return item.nice && comNice ? [NICE_BIN, '-n', String(item.nice), ...base] : base;
+}
+/** As vagas do grupo: no maximo `max` comandos ao mesmo tempo, na ordem em que pediram. */
+function vagas(max) {
+    let livres = max;
+    const fila = [];
+    return {
+        tomar: () => new Promise((pronto) => { if (livres > 0) {
+            livres--;
+            pronto();
+        }
+        else
+            fila.push(pronto); }),
+        soltar: () => { const proximo = fila.shift(); if (proximo)
+            proximo();
+        else
+            livres++; },
+    };
+}
+/**
+ * O lado do auxiliar: lanca cada item quando os de `apos` terminam e ha vaga, espera todos e grava `resultado.json` ao
+ * lado das saidas.
+ */
+async function rodarEspecificacao(esp) {
+    const comGrupo = fs.existsSync(TIMEOUT_BIN);
+    const limite = vagas(esp.maxParalelo && esp.maxParalelo > 0 ? esp.maxParalelo : esp.itens.length);
+    const porNome = new Map();
+    const terminados = await Promise.all(esp.itens.map((item, i) => {
+        const vez = (async () => {
+            for (const nome of item.apos ?? [])
+                await porNome.get(nome);
+            await limite.tomar();
+            try {
+                return await lancar(item, i);
+            }
+            finally {
+                limite.soltar();
+            }
+        })();
+        porNome.set(item.nome, vez);
+        return vez;
+    }));
+    fs.writeFileSync(path.join(esp.dir, 'resultado.json'), JSON.stringify(terminados), { mode: 0o600 });
+    function lancar(item, i) {
+        return new Promise((resolve) => {
+            const saida = fs.openSync(path.join(esp.dir, `${i}.out`), 'w', 0o600);
+            const erro = fs.openSync(path.join(esp.dir, `${i}.err`), 'w', 0o600);
+            const inicio = Date.now();
+            const [bin, ...args] = argvDoItem(item, comGrupo);
+            let fim = null;
+            const encerrar = (t) => {
+                if (fim)
+                    return;
+                fim = t;
+                fs.closeSync(saida);
+                fs.closeSync(erro);
+                resolve(t);
+            };
+            // Sem o `timeout(1)`, o proprio auxiliar mata pelo prazo, como o `spawnSync` do `exec` faria.
+            const filho = (0, node_child_process_1.spawn)(bin, args, { cwd: item.cwd, env: { ...process.env, ...item.ambiente }, stdio: ['ignore', saida, erro],
+                ...(comGrupo ? {} : { timeout: item.prazoMs, killSignal: 'SIGTERM' }) });
+            filho.on('error', (e) => encerrar({ nome: item.nome, code: null, signal: null,
+                error: e.code ?? e.message, duracaoMs: Date.now() - inicio, comGrupo }));
+            filho.on('close', (code, signal) => encerrar({ nome: item.nome, code, signal,
+                ...(!comGrupo && signal && Date.now() - inicio >= item.prazoMs ? { error: 'ETIMEDOUT' } : {}),
+                duracaoMs: Date.now() - inicio, comGrupo }));
+        });
+    }
+}
+/**
+ * A espera do grupo inteiro: o maior prazo, ou a soma deles quando ha fila (item com `apos` ou vagas a menos que itens),
+ * que e o teto do pior caso.
+ */
+function esperaDoGrupo(itens, maxParalelo) {
+    const comFila = itens.some((i) => i.apos?.length) || (!!maxParalelo && maxParalelo < itens.length);
+    return comFila ? itens.reduce((t, i) => t + i.prazoMs, 0) : Math.max(...itens.map((i) => i.prazoMs));
+}
+/**
+ * O lado do pai: roda o grupo pelo auxiliar e devolve cada processo, na ordem dos itens. A espera e a do grupo
+ * (`esperaDoGrupo`), com folga para o `--kill-after` e para o auxiliar gravar; o diretorio das saidas some no fim.
+ */
+function rodarEmParalelo(itens, ambiente = process.env, opcoes = {}) {
+    if (itens.length === 0)
+        return [];
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ork-check-paralelo-'));
+    try {
+        const especificacao = path.join(dir, 'especificacao.json');
+        const esp = { itens, dir, ...(opcoes.maxParalelo ? { maxParalelo: opcoes.maxParalelo } : {}) };
+        fs.writeFileSync(especificacao, JSON.stringify(esp), { mode: 0o600 });
+        const prazo = esperaDoGrupo(itens, opcoes.maxParalelo) + 60_000;
+        const r = (0, node_child_process_1.spawnSync)(process.execPath, [__filename, especificacao], { env: ambiente, encoding: 'utf8', timeout: prazo,
+            killSignal: 'SIGKILL' });
+        let terminados = [];
+        try {
+            terminados = JSON.parse(fs.readFileSync(path.join(dir, 'resultado.json'), 'utf8'));
+        }
+        catch { /* abaixo */ }
+        return itens.map((item, i) => {
+            const t = terminados[i];
+            const ler = (sufixo) => { try {
+                return fs.readFileSync(path.join(dir, `${i}.${sufixo}`), 'utf8');
+            }
+            catch {
+                return '';
+            } };
+            if (!t) {
+                // O auxiliar morreu antes de gravar: o comando nao tem veredito, e a causa vai junto.
+                const motivo = r.error ? r.error.code ?? r.error.message : `auxiliar saiu ${r.status ?? r.signal}`;
+                return { nome: item.nome, ok: false, code: -1, signal: r.signal ?? null, error: motivo, stdout: ler('out'),
+                    stderr: `${ler('err')}${r.stderr ?? ''}`, duracaoMs: 0, comGrupo: fs.existsSync(TIMEOUT_BIN), semResultado: true };
+            }
+            return { nome: item.nome, ok: t.code === 0, code: t.code ?? -1, signal: t.signal, ...(t.error ? { error: t.error } : {}),
+                stdout: ler('out'), stderr: ler('err'), duracaoMs: t.duracaoMs, comGrupo: t.comGrupo };
+        });
+    }
+    finally {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+}
+if (require.main === module) {
+    const esp = JSON.parse(fs.readFileSync(process.argv[2], 'utf8'));
+    rodarEspecificacao(esp).then(() => process.exit(0), (e) => { process.stderr.write(`check-paralelo: ${e.message}\n`); process.exit(1); });
+}

package/dist/ci.js

@@ -36,10 +36,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BUNDLE_LEGADO = exports.DIR_DO_BUNDLE = void 0;
 exports.motivoDiferimentoCi = motivoDiferimentoCi;
 exports.repositorioGitHub = repositorioGitHub;
+exports.loginDoGh = loginDoGh;
+exports.ciNaoExigida = ciNaoExigida;
 exports.consultarCi = consultarCi;
 exports.consultarCiDoRepositorio = consultarCiDoRepositorio;
+exports.consultarCiNaForja = consultarCiNaForja;
 exports.executarCi = executarCi;
 exports.arquivoDoBundle = arquivoDoBundle;
+exports.comandosDoBundle = comandosDoBundle;
 exports.lintDoBundle = lintDoBundle;
 exports.destinoDoBundle = destinoDoBundle;
 exports.prepararBundleCi = prepararBundleCi;
@@ -47,9 +51,22 @@ exports.bundleDaBranch = bundleDaBranch;
 exports.executarCiDaBranch = executarCiDaBranch;
 exports.executarBundleCi = executarBundleCi;
 /** GitHub CI como CHECK independente (I-12). */
+const ambiente_de_ci_1 = require("./forja/ambiente-de-ci");
+const endereco_1 = require("./forja/endereco");
+const forja_1 = require("./forja");
+const cli_1 = require("./forja/cli");
+const api_1 = require("./forja/api");
+const versao_1 = require("./forja/versao");
+const resolver_1 = require("./forja/resolver");
+const cache_1 = require("./forja/cache");
 const branch_de_estado_1 = require("./branch-de-estado");
 const util_1 = require("./util");
+const executor_1 = require("./forja/executor");
+const estado_1 = require("./forja/estado");
+const produtor_1 = require("./forja/produtor");
+const registro_1 = require("./forja/registro");
 const worktree_1 = require("./worktree");
+const procedencia_1 = require("./procedencia");
 const verify_1 = require("./verify");
 const verify_2 = require("./verify");
 const claims_1 = require("./claims");
@@ -59,6 +76,11 @@ const claim_lint_1 = require("./claim-lint");
 const integracoes_locais_1 = require("./integracoes-locais");
 const ledger_1 = require("./ledger");
 const thread_1 = require("./thread");
+const locale_1 = require("./locale");
+const dado_privado_1 = require("./dado-privado");
+const policies_1 = require("./policies");
+/** O comeco de todo retrato da CI exigida; `fonte` e `produtor` so com check decisivo. */
+const baseDaCi = (provider, repository, sha, context) => ({ schema: 'ork.ci-status/v2', required: true, provider, repository, sha, context, fonte: null, produtor: null });
 const MARCADORES_DE_HOST = [
     /(^|[\s;&|])\/home\//,
     /(^|[\s;&|])localhost(?=[:/\s;&|]|$)/,
@@ -125,61 +147,206 @@ function motivoDiferimentoCi(claim, raiz) {
     return null;
 }
 function repositorioGitHub(url) {
-    const match = url.trim().replace(/\.git$/, '').match(/(?:github\.com[/:])([^/]+\/[^/]+)$/i);
-    return match?.[1] ?? null;
+    const e = (0, endereco_1.lerEnderecoDoRemoto)(url);
+    return e && (e.host === 'github.com' || e.host === 'ssh.github.com') && e.caminho.split('/').length === 2 ? e.caminho : null;
+}
+/** O host da API para o gh: `--hostname host`, ou `GH_HOST=host:porta` (o gh recusa `--hostname` com porta). */
+function hostDoGh(host) {
+    return host.includes(':') ? { args: [], acrescentar: { GH_HOST: host } } : { args: ['--hostname', host] };
 }
 function executorPadrao(input) {
-    return (0, util_1.exec)('gh', [
-        'api', `repos/${input.repository}/commits/${input.sha}/check-runs`,
-        '-H', 'Accept: application/vnd.github+json',
-    ], process.cwd(), 120000);
+    // 32 MiB, o teto do `forja.ts`: uma pagina de 100 check-runs passa de 1 MiB com facilidade.
+    const h = hostDoGh(input.host ?? 'github.com');
+    const r = (0, executor_1.rodarCli)({ cmd: 'gh', args: ['api', ...h.args, input.caminho ?? `repos/${input.repository}/commits/${input.sha}/check-runs`,
+            '-H', 'Accept: application/vnd.github+json'], prazoMs: 120000, maxBuffer: 32 * 1024 * 1024, acrescentar: h.acrescentar });
+    return { ok: r.status === 0, code: r.status ?? -1, stdout: r.stdout, stderr: r.stderr };
+}
+/**
+ * O `gh` tem login no host exato (`host` ou `host:porta`)? So o github.com dispensa a pergunta. Com porta o
+ * `auth status` roda sem `--hostname` e sai 0 se QUALQUER host tem login: o `temLogin` confere a linha do host exato.
+ */
+function loginDoGh(host, rodar) {
+    const m = /^(.+?)(?::(\d+))?$/.exec(host);
+    return (0, api_1.temLogin)({ tipo: 'github', host: m ? m[1] : host, porta: m?.[2] ? Number(m[2]) : null, caminhoBase: '', ca: null }, rodar);
+}
+const loginPadrao = (host) => loginDoGh(host);
+/**
+ * A forja do remoto: o repositorio e o host saem de UM parse do remoto (`lerEnderecoDoRemoto`) e da forja resolvida (o
+ * bloco `forja:`, o host conhecido ou a sondagem pela CLI com login no host), sem host de reserva: o caminho nunca e
+ * consultado num host que o remoto ou o manifesto nao nomeiam. O nome do host nao decide o tipo. No GitHub o
+ * repositorio e `dono/nome`; no GitLab, o caminho inteiro, com subgrupos. `ssh.github.com` (SSH pela 443) e o
+ * github.com; a porta de um remoto SSH nao e a da API.
+ */
+function alvoDaCi(carregado, remoto, url, sondas) {
+    const naoReconhecido = () => ({ ok: false, detalhe: (0, locale_1.textoDoCatalogo)((m) => m.ship.ciRemotoNaoGithub(remoto)) });
+    const endereco = (0, endereco_1.lerEnderecoDoRemoto)(url.trim());
+    if (!endereco)
+        return naoReconhecido();
+    // O tipo sondado fica 24 h no cache da raiz: um GHE sem bloco `forja:` nao paga as sondas a cada consulta.
+    const forja = (0, resolver_1.resolverForja)({ endereco, manifesto: carregado.manifesto.forja, sondas, cache: (0, cache_1.dirDoCacheDaForja)(carregado.raiz) });
+    if (!forja.ok)
+        return { ok: false, detalhe: (0, locale_1.textoDoCatalogo)((m) => m.ship.ciForjaNaoResolvida(remoto, m.forja.motivo(forja.erro, null))) };
+    if (forja.valor.tipo === 'github' && forja.valor.repo.split('/').length !== 2)
+        return naoReconhecido();
+    return { ok: true, forja: forja.valor };
+}
+/** O resultado da CI quando o projeto nao a exige (`ci.required_for_ship: false`): nada e consultado na forja. */
+function ciNaoExigida(carregado, sha) {
+    const context = carregado.manifesto.ci.context || 'ork-verify';
+    return { ...baseDaCi(null, null, sha, context), required: false, ok: true, state: 'disabled', url: null,
+        detail: (0, locale_1.textoDoCatalogo)((m) => m.ship.ciNaoExigidoDetalhe) };
 }
-function consultarCi(carregado, sha, remoto = 'origin', executor = executorPadrao) {
+function consultarCi(carregado, sha, remoto = 'origin', executor = executorPadrao, loginNoHost = loginPadrao, sondas = resolver_1.SONDAS_PADRAO, api = {}) {
     const { ci } = carregado.manifesto;
     const context = ci.context || 'ork-verify';
+    const falha = (detalhe, provider = null) => ({ ...baseDaCi(provider, null, sha, context), ok: false, state: 'unavailable', url: null, detail: detalhe });
     if (!ci.required_for_ship)
-        return { schema: 'ork.ci-status/v1', required: false, ok: true, provider: 'github', repository: null, sha, context, state: 'disabled', url: null, detail: 'gate de CI não exigido pelo manifesto' };
+        return ciNaoExigida(carregado, sha);
     // RM-047: o `--remoto` do `ork ci status` vem da linha de comando; so nome de remoto chega ao git.
     const remote = (0, util_1.exec)('git', ['remote', 'get-url', '--', (0, branch_de_estado_1.exigirRemoto)(remoto, 'ci')], carregado.raiz);
-    const repository = remote.ok ? repositorioGitHub(remote.stdout) : null;
-    if (!repository)
-        return { schema: 'ork.ci-status/v1', required: true, ok: false, provider: 'github', repository: null, sha, context, state: 'unavailable', url: null, detail: `remoto ${remoto} não é um repositório GitHub reconhecível` };
-    return consultarCiDoRepositorio(repository, sha, context, executor);
+    const alvo = remote.ok ? alvoDaCi(carregado, remoto, remote.stdout, sondas)
+        : { ok: false, detalhe: (0, locale_1.textoDoCatalogo)((m) => m.ship.ciRemotoNaoGithub(remoto)) };
+    if (!alvo.ok)
+        return falha(alvo.detalhe);
+    const { forja } = alvo;
+    const produtores = (0, produtor_1.produtoresAceitos)(carregado.manifesto, forja.tipo);
+    // Fora do GitHub, a CI vai pela API da CLI logada (`chamarApi`), que confere o login no host antes da primeira chamada.
+    if (forja.tipo !== 'github')
+        return consultarCiNaForja(forja, sha, context, produtores, { api, cache: (0, cache_1.dirDoCacheDaForja)(carregado.raiz) });
+    // Fronteira de confianca: so o github.com e consultado sem pergunta; outro host so com login do `gh` nele.
+    const host = (0, cli_1.hostDaApi)(forja);
+    if (host !== 'github.com' && !loginNoHost(host))
+        return falha((0, locale_1.textoDoCatalogo)((m) => m.ship.ciHostSemLogin(host)), 'github');
+    return consultarCiDoRepositorio(forja.repo, sha, context, executor, host, produtores);
 }
 /**
  * O check `context` no `sha` de um repositorio GitHub ja resolvido: o do remoto do projeto ou, desde a
- * RM-037 (rm037defeito, defeito 5), um repositorio externo declarado em `ci.external_repositories`.
+ * RM-037 (rm037defeito, defeito 5), um repositorio externo declarado em `ci.external_repositories`. So produtor de
+ * `produtores` (`ci.produtor`) aprova.
  */
-function consultarCiDoRepositorio(repository, sha, context, executor = executorPadrao) {
-    const result = executor({ repository, sha, context });
-    if (!result.ok)
-        return { schema: 'ork.ci-status/v1', required: true, ok: false, provider: 'github', repository, sha, context, state: 'unavailable', url: null, detail: (result.stderr || result.stdout || 'consulta ao GitHub falhou').trim().slice(0, 400) };
-    let payload;
-    try {
-        payload = JSON.parse(result.stdout);
+function consultarCiDoRepositorio(repository, sha, context, executor = executorPadrao, host = 'github.com', produtores = produtor_1.PRODUTORES_PADRAO.github) {
+    const base = baseDaCi('github', repository, sha, context);
+    const lido = (0, registro_1.exigirCapacidade)((0, registro_1.adaptadorDaForja)('github'), 'checksNoCommit')({ repository, sha, context, executor, host });
+    if (!lido.ok && lido.erro.codigo === 'forja.resposta-invalida') {
+        return { ...base, ok: false, state: 'unavailable', url: null, detail: (0, locale_1.textoDoCatalogo)((m) => lido.erro.detalhe === 'incompleto'
+                ? m.ship.ciIncompleto(context) : m.ship.ciRespostaInvalida) };
     }
-    catch {
-        return { schema: 'ork.ci-status/v1', required: true, ok: false, provider: 'github', repository, sha, context, state: 'unavailable', url: null, detail: 'GitHub devolveu uma resposta de checks inválida' };
+    if (!lido.ok)
+        return { ...base, ok: false, state: 'unavailable', url: null, detail: (0, forja_1.detalheSeguro)(lido.erro.detalhe || (0, locale_1.textoDoCatalogo)((m) => m.ship.ciConsultaFalhou)) };
+    return decidirCi(base, lido.valor, produtores, (m) => m.ship.ciVerde);
+}
+/**
+ * O check `context` no `sha` pela API da forja ja resolvida (`estadoDeCi`): o GitLab do projeto ou, na entrega externa,
+ * o de um repositorio declarado. A versao abaixo do piso recusa antes de ler a CI. So produtor de `produtores` aprova; o
+ * check que so rodou em resultado mesclado sem vinculo com o `sha` nunca aprova (`ci.merged-results-sem-vinculo`).
+ */
+function consultarCiNaForja(forja, sha, context, produtores, o = {}) {
+    const base = baseDaCi(forja.tipo, forja.repo, sha, context);
+    const naoLida = (erro) => ({ ...base, ok: false, state: 'unavailable', url: null,
+        detail: (0, locale_1.textoDoCatalogo)((m) => m.ship.ciLeituraFalhou(context, m.forja.motivo(erro, forja.tipo))) });
+    const ler = (0, registro_1.adaptadorDaForja)(forja.tipo).estadoDeCi;
+    if (!ler)
+        return naoLida({ codigo: 'forja.sem-capacidade', detalhe: `${forja.tipo}: estadoDeCi` });
+    const api = (0, api_1.chamadorDaApi)(forja, o.api);
+    const meta = (0, versao_1.lerMetadados)(forja, { cache: o.cache ?? null, api });
+    if (!meta.ok)
+        return naoLida(meta.erro);
+    const piso = (0, versao_1.recusaAbaixoDoPiso)(forja.tipo, meta.valor);
+    if (piso)
+        return naoLida(piso);
+    const lido = ler({ api, repo: forja.repo, sha, context, edicao: meta.valor.edicao });
+    if (!lido.ok)
+        return naoLida(lido.erro);
+    const decidido = decidirCi(base, lido.valor.checks, produtores, (m) => (forja.tipo === 'gitlab' ? m.ship.ciVerdeNoGitlab : m.ship.ciVerde));
+    if (lido.valor.mescladoSemVinculo && decidido.state !== 'failure' && decidido.state !== 'pending') {
+        return { ...base, ok: false, state: 'missing', url: null, detail: (0, locale_1.textoDoCatalogo)((m) => m.ship.ciMescladoSemVinculo(context, sha.slice(0, 8))) };
     }
-    const checks = (payload.check_runs ?? []).filter((check) => check.name === context);
+    return decidido;
+}
+/** O motivo de um check bloqueado: a conclusao do check-run ou, sem ela, o estado do job (`manual`, `skipped`). */
+const motivoDoBloqueio = (c) => c.conclusao ?? c.status;
+/**
+ * A regra do gate sobre os checks lidos de qualquer forja. O mais novo de cada produtor conta. So produtor da lista
+ * aprova: o verde de quem esta fora dela e descartado; vermelho, pendente ou bloqueado de qualquer um continua contando
+ * (quem escreve status no repositorio pode atrasar o gate, nunca aprova-lo). Com varios, a combinacao e conservadora:
+ * vermelho ou bloqueado de qualquer um reprova; senao, pendente de qualquer um espera; so todos verdes passam. A fonte
+ * e o produtor do retrato sao os do check que decidiu.
+ */
+function decidirCi(base, checks, produtores, verde) {
+    const context = base.context;
     if (!checks.length)
-        return { schema: 'ork.ci-status/v1', required: true, ok: false, provider: 'github', repository, sha, context, state: 'missing', url: null, detail: `check ${context} não encontrado no commit` };
-    const check = checks.at(-1);
-    const status = check.status ?? 'unknown';
-    const conclusion = check.conclusion ?? '';
-    const url = check.html_url ?? '';
-    const state = status !== 'completed' ? 'pending' : conclusion === 'success' ? 'success' : 'failure';
-    return { schema: 'ork.ci-status/v1', required: true, ok: state === 'success', provider: 'github', repository, sha, context, state, url: url || null, detail: state === 'success' ? 'CHECK independente verde no GitHub' : `check ${context}: ${status}/${conclusion || 'sem conclusão'}` };
+        return { ...base, ok: false, state: 'missing', url: null, detail: (0, locale_1.textoDoCatalogo)((m) => m.ship.ciSemCheck(context)) };
+    const escolhidos = maisNovoPorProdutor(checks);
+    const contam = escolhidos.filter((c) => (0, produtor_1.produtorAceito)(c, produtores) || (0, estado_1.estadoDoCheck)(c.fonte, c.status, c.conclusao) !== 'verde');
+    if (!contam.length) {
+        const descartados = escolhidos.map(nomeDoProdutor).join(', ');
+        return { ...base, ok: false, state: 'missing', url: null, detail: (0, locale_1.textoDoCatalogo)((m) => escolhidos.every((c) => c.fonte === 'commit-status')
+                ? m.ship.ciStatusSemProdutorConfiavel(context) : m.ship.ciSemProdutorAceito(context, descartados, produtores.join(', '))) };
+    }
+    if (contam.length === 1) {
+        const check = contam[0];
+        const estado = (0, estado_1.estadoDoCheck)(check.fonte, check.status, check.conclusao);
+        const state = estadoNoGate(estado);
+        return { ...base, fonte: check.fonte, produtor: (0, produtor_1.produtorDeSaida)(check), ok: state === 'success', state, url: check.url || null,
+            ...(estado === 'bloqueado' ? { bloqueado: true } : {}),
+            detail: (0, locale_1.textoDoCatalogo)((m) => state === 'success' ? verde(m) : estado === 'bloqueado' ? m.ship.ciBloqueado(context, motivoDoBloqueio(check))
+                : m.ship.ciEstado(context, String(check.status), check.conclusao ?? '')) };
+    }
+    const lidos = contam.map((check) => {
+        const estado = (0, estado_1.estadoDoCheck)(check.fonte, check.status, check.conclusao);
+        return { check, estado, state: estadoNoGate(estado) };
+    });
+    const state = lidos.some((l) => l.state === 'failure') ? 'failure' : lidos.some((l) => l.state === 'pending') ? 'pending' : 'success';
+    const decisivo = lidos.find((l) => l.state === state);
+    // O estado do ork por produtor, com o motivo do bloqueio.
+    const porProdutor = lidos.map((l) => `${nomeDoProdutor(l.check)} ${l.estado}${l.estado === 'bloqueado' ? ` (${motivoDoBloqueio(l.check)})` : ''}`).join(', ');
+    // Bloqueado so quando todo check que conta e verde ou bloqueado: pendente ou vermelho de qualquer um desfaz a marca.
+    const soBloqueados = state === 'failure' && lidos.every((l) => l.estado === 'verde' || l.estado === 'bloqueado')
+        && lidos.some((l) => l.estado === 'bloqueado');
+    return { ...base, fonte: decisivo.check.fonte, produtor: (0, produtor_1.produtorDeSaida)(decisivo.check), ok: state === 'success', state, url: decisivo.check.url || null,
+        ...(soBloqueados ? { bloqueado: true } : {}),
+        detail: (0, locale_1.textoDoCatalogo)((m) => m.ship.ciProdutores(context, porProdutor)) };
 }
-function executarCi(carregado, threadId) {
+function estadoNoGate(estado) {
+    return estado === 'verde' ? 'success' : estado === 'pendente' ? 'pending' : 'failure';
+}
+/** O produtor como aparece no detalhe; check-run e commit status do mesmo nome sao produtores distintos. */
+function nomeDoProdutor(check) {
+    return `${check.produtor ?? '?'}${check.fonte === 'commit-status' ? ' (status)' : ''}`;
+}
+/**
+ * O check mais novo de cada produtor: maior `concluidoEm`, depois maior `ordem`. Sem `concluidoEm` (ainda rodando) e
+ * o mais novo; data ilegivel e a mais velha. Saida ordenada pelo nome do produtor, para o detalhe ser estavel.
+ */
+function maisNovoPorProdutor(checks) {
+    const quando = (c) => {
+        if (c.concluidoEm === null)
+            return Number.POSITIVE_INFINITY;
+        const t = Date.parse(c.concluidoEm);
+        return Number.isNaN(t) ? Number.NEGATIVE_INFINITY : t;
+    };
+    const porProdutor = new Map();
+    for (const c of checks) {
+        const chave = nomeDoProdutor(c);
+        const atual = porProdutor.get(chave);
+        if (!atual || quando(c) > quando(atual) || (quando(c) === quando(atual) && c.ordem > atual.ordem))
+            porProdutor.set(chave, c);
+    }
+    return [...porProdutor.entries()].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)).map(([, c]) => c);
+}
+/**
+ * `ork ci run <thread>`: o verify da thread no runner. O runner (GitHub Actions ou GitLab CI) diz a forja, o projeto e
+ * a pagina do job; fora dele, so o commit verificado.
+ */
+function executarCi(carregado, threadId, env = process.env) {
     const verify = (0, verify_1.verificar)(carregado, threadId);
     const context = carregado.manifesto.ci.context || 'ork-verify';
-    const repository = process.env.GITHUB_REPOSITORY ?? null;
+    const runner = (0, ambiente_de_ci_1.ambienteDeCi)(env);
     return {
         status: {
-            schema: 'ork.ci-status/v1', required: true, ok: verify.ok, provider: 'github', repository,
-            sha: verify.commit, context, state: verify.ok ? 'success' : 'failure',
-            url: process.env.GITHUB_SERVER_URL && repository && process.env.GITHUB_RUN_ID ? `${process.env.GITHUB_SERVER_URL}/${repository}/actions/runs/${process.env.GITHUB_RUN_ID}` : null,
+            ...baseDaCi(runner?.tipo ?? null, runner?.repository ?? null, verify.commit, context), ok: verify.ok,
+            state: verify.ok ? 'success' : 'failure', url: runner?.url ?? null,
+            fonte: runner ? (runner.tipo === 'github' ? 'check-run' : 'pipeline-job') : null, produtor: runner?.produtor ?? null,
             detail: verify.ok ? 'ork verify aprovado no runner independente' : `ork verify reprovou: ${verify.motivos.join(', ')}`,
         },
         verify,
@@ -202,10 +369,15 @@ function arquivoDoBundle(threadId) {
         throw new Error(`ci.bundle: "${threadId}" nao e id de thread`);
     return `${threadId}.json`;
 }
+/** Os comandos que o bundle leva ao runner; o `ork ship publicar` confere os do bundle no HEAD contra estes. */
 function comandosDoBundle(carregado) {
-    return carregado.manifesto.ci.command
-        ? [{ name: 'ci', command: carregado.manifesto.ci.command }]
-        : (0, verify_2.comandosDoManifesto)(carregado.manifesto).map(({ nome, comando }) => ({ name: nome, command: comando }));
+    // O scan e obrigatorio no runner: la a ferramenta ausente reprova em vez de ficar `unavailable` em silencio.
+    const doManifesto = (0, verify_2.comandosDoManifesto)(carregado.manifesto).map(({ nome, comando }) => ({
+        name: nome, command: nome === 'security_scan' ? `ORK_SECURITY_SCAN_REQUIRED=1 ${comando}` : comando,
+    }));
+    if (!carregado.manifesto.ci.command)
+        return doManifesto;
+    return [{ name: 'ci', command: carregado.manifesto.ci.command }, ...doManifesto.filter((c) => c.name === 'security_scan')];
 }
 /**
  * I-53 (RM-037, P6): o lint no `ci prepare`. Claim nascida sob a regra (com o campo `lint`) que
@@ -220,11 +392,16 @@ function lintDoBundle(claims) {
             if (achado.regra === 'suite-inteira' && claim.lint !== undefined)
                 recusas.push(linha);
             else
-                avisos.push(achado.regra === 'suite-inteira' ? `${linha} (claim anterior ao lint: so aviso)` : linha);
+                avisos.push(achado.regra === 'suite-inteira' ? anteriorAoLint(linha) : linha);
         }
     }
     return { recusas, avisos };
 }
+/** RM-061 (F3d, GO-FIX 1): a linha da claim anterior ao lint, remontavel no locale do comando como a linha de dentro. */
+function anteriorAoLint(linha) {
+    const montar = (0, locale_1.montadorDe)(linha);
+    return (0, locale_1.textoDoCatalogo)((m) => m.operacao.produto.ci.anteriorAoLint(montar(m)));
+}
 /**
  * RM-037 (rm037defeito, defeito 6): onde o bundle nasce. Ele e artefato da branch da thread (o commit
  * `ci(<thread>)` vai no PR dela), entao o destino e a worktree da thread, rodando o `ork` da raiz ou da
@@ -233,7 +410,9 @@ function lintDoBundle(claims) {
  */
 function destinoDoBundle(carregado, threadId) {
     const worktree = (0, thread_1.lerThread)(carregado.raiz, threadId).worktree;
-    return worktree && fs.existsSync(worktree) ? worktree : carregado.raiz;
+    // RM-047 (P2): o bundle so e gravado na worktree registrada; outro diretorio do thread.json cai na raiz.
+    return worktree && fs.existsSync(worktree) && (0, procedencia_1.cwdLocalOuNulo)(carregado.raiz, threadId, worktree, 'thread') !== null
+        ? worktree : carregado.raiz;
 }
 function prepararBundleCi(carregado, threadId, opcoes = {}) {
     const commands = comandosDoBundle(carregado);
@@ -247,14 +426,14 @@ function prepararBundleCi(carregado, threadId, opcoes = {}) {
     for (const aviso of lint.avisos)
         opcoes.aoAvisar?.(aviso);
     if (lint.recusas.length) {
-        throw new Error(`claims.lint: o bundle nao foi gerado; retire a claim e registre de novo com o comando focado:\n  ` +
-            lint.recusas.join('\n  '));
+        const montadores = lint.recusas.map(locale_1.montadorDe);
+        throw new locale_1.ErroDoCatalogo((m) => m.operacao.produto.ci.lintRecusado(montadores.map((montar) => montar(m)).join('\n  ')));
     }
     const destino = destinoDoBundle(carregado, threadId);
     // Achado S8 do CHECK: a worktree registrada que sumiu nao e silencio; o bundle na raiz vem com aviso.
     const registrada = (0, thread_1.lerThread)(carregado.raiz, threadId).worktree;
     if (registrada && destino !== registrada) {
-        opcoes.aoAvisar?.(`a worktree ${registrada} da thread nao existe mais; o bundle vai para a raiz do projeto`);
+        opcoes.aoAvisar?.((0, locale_1.textoDoCatalogo)((m) => m.operacao.produto.ci.worktreeSumiu(registrada)));
     }
     const classified = activeClaims.map((claim) => ({
         claim,
@@ -271,12 +450,37 @@ function prepararBundleCi(carregado, threadId, opcoes = {}) {
             .map((item) => ({ id: item.claim.id, reason: item.reason })),
         commands,
     };
+    const texto = JSON.stringify(bundle, null, 2) + '\n';
+    barreiraDoBundle(carregado, threadId, destino, path.posix.join(exports.DIR_DO_BUNDLE, nomeDoArquivo), texto, opcoes);
     const dir = path.join(destino, '.ork-ci');
     fs.mkdirSync(dir, { recursive: true });
     const file = path.join(dir, nomeDoArquivo);
-    fs.writeFileSync(file, JSON.stringify(bundle, null, 2) + '\n', 'utf8');
+    fs.writeFileSync(file, texto, 'utf8');
     return file;
 }
+/**
+ * RM-062 (F2): com a policy `dado_privado`, o diff da thread e o texto do bundle novo passam pela barreira antes de o
+ * arquivo existir. O bundle anterior da propria thread sai do diff, porque o novo o substitui. Em `block`, achado
+ * recusa e nada e gravado; em `warn`, avisa e grava. A linha da lista local (presente ou ausente) sai sempre.
+ */
+function barreiraDoBundle(carregado, threadId, destino, caminho, texto, opcoes) {
+    const barreira = (0, dado_privado_1.barreiraDaThread)(carregado, (0, thread_1.lerThread)(carregado.raiz, threadId), destino, 'ci.prepare', { extra: (c) => (0, dado_privado_1.varrerTexto)(c, caminho, texto), ignorar: [caminho] });
+    if (!barreira)
+        return;
+    const v = barreira.varredura;
+    opcoes.aoInformar?.(`dado privado (policy dado_privado em ${barreira.severidade}): ${(0, dado_privado_1.textoDoEscopo)(v)}; ` +
+        `lista local ${(0, dado_privado_1.textoDaListaLocal)(v)}`);
+    const recusas = (0, policies_1.bloqueantes)(barreira.violacoes);
+    if (recusas.length) {
+        throw new Error(`privado.achado: o bundle nao foi gerado; ${recusas.map((r) => r.detalhe).join('; ')}\n  ` +
+            [...v.achados.slice(0, 20).map(dado_privado_1.linhaDoAchado), `correcao: ${recusas[0].correcao}`].join('\n  '));
+    }
+    for (const aviso of (0, policies_1.avisos)(barreira.violacoes)) {
+        (0, ledger_1.registrar)((0, thread_1.dirThread)(carregado.raiz, threadId), threadId, ledger_1.TIPOS_DE_EVENTO.politicaAviso, { gate: 'ci.prepare',
+            policy: aviso.policy, motivo: aviso.motivo, detalhe: aviso.detalhe, correcao: aviso.correcao });
+        opcoes.aoAvisar?.(`policy ${aviso.policy}: ${aviso.detalhe}`);
+    }
+}
 function lerBundle(raiz, file) {
     const absolute = path.resolve(raiz, file);
     const stat = fs.statSync(absolute);
@@ -354,8 +558,13 @@ function rodarBundle(carregado, bundle) {
     const preparo = comandoDoPreparo
         ? (0, verify_2.executar)('preparo', comandoDoPreparo, carregado.raiz, (0, verify_2.prazoDoComando)(carregado.manifesto, 'preparo'))
         : null;
-    const claims = bundle.claims.map((claim) => (0, verify_2.verificarClaim)(claim, carregado.raiz));
-    const commands = bundle.commands.map((item) => (0, verify_2.executar)(item.name, item.command, carregado.raiz));
+    const claims = bundle.claims.map((claim) => (0, verify_2.verificarClaim)(claim, carregado.raiz, (0, verify_2.executorDoManifesto)(carregado.manifesto)));
+    // O comando lógico `ci` executa o script de testes hermético (`test:ci`) e herda o mesmo teto configurado
+    // para `test`. Assim a suíte não volta silenciosamente ao default de 600 s no runner hospedado.
+    const doManifesto = (0, verify_2.executorDoManifesto)(carregado.manifesto);
+    const commands = bundle.commands.map((item) => item.name === 'ci'
+        ? (0, verify_2.executar)(item.name, item.command, carregado.raiz, (0, verify_2.prazoDoComando)(carregado.manifesto, 'test'))
+        : doManifesto(item.name, item.command, carregado.raiz));
     const ok = claims.every((item) => item.verificado || item.motivo === 'claims.unverifiable') && commands.every((item) => item.ok);
     return { schema: 'ork.ci-run/v1', ok, thread: bundle.thread, commit: (0, verify_2.commitReal)(carregado.raiz), preparo, claims, commands };
 }

package/dist/ciclos.js

@@ -16,6 +16,7 @@ exports.somenteAnalise = somenteAnalise;
 exports.aplicarVariante = aplicarVariante;
 exports.tabelaDeVariantes = tabelaDeVariantes;
 const modos_1 = require("./modos");
+const locale_1 = require("./locale");
 /** As 5 variantes de ciclo, com o que cada uma muda na criacao da thread. */
 exports.VARIANTES = {
     greenfield: {
@@ -139,19 +140,20 @@ function aplicarVariante(blocos, variante) {
 }
 /** Tabela das variantes de ciclo, usada por `ork ciclos`. */
 function tabelaDeVariantes() {
-    const linhas = ['Variantes de ciclo (`ork thread new --ciclo <variante>`)', ''];
+    const m = (0, locale_1.msg)().operacao.ciclos;
+    const linhas = [m.titulo, ''];
     for (const v of exports.ORDEM_DAS_VARIANTES) {
         const def = exports.VARIANTES[v];
         const exige = [];
         if (def.exigeBranch)
             exige.push('--branch <existente>');
         if (def.exigeWorktree)
-            exige.push('worktree isolada');
-        linhas.push(`  ${v.padEnd(20)} ${def.descricao}`);
-        linhas.push(`  ${''.padEnd(20)} exige: ${exige.join(', ') || 'nada'} | ` +
-            `muda os blocos do modo: ${def.mudaBlocos ? 'sim' : 'nao'}`);
+            exige.push(m.worktree);
+        linhas.push(`  ${v.padEnd(20)} ${m.descricoes[v] ?? def.descricao}`);
+        linhas.push(`  ${''.padEnd(20)} ${m.exige}: ${exige.join(', ') || m.nada} | ` +
+            `${m.muda}: ${def.mudaBlocos ? m.sim : m.nao}`);
     }
     linhas.push('');
-    linhas.push('A variante muda como a thread NASCE. Verificacao e gates nao mudam.');
+    linhas.push(m.fecho);
     return linhas.join('\n');
 }