@orkastery/cli 0.6.2 → 0.6.4

package/dist/check-paralelo.js

@@ -34,6 +34,8 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.argvDoItem = argvDoItem;
+exports.chaveDoPerfilIntegracao = chaveDoPerfilIntegracao;
+exports.picoCpuPorFonte = picoCpuPorFonte;
 exports.esperaDoGrupo = esperaDoGrupo;
 exports.rodarEmParalelo = rodarEmParalelo;
 /**
@@ -48,12 +50,17 @@ exports.rodarEmParalelo = rodarEmParalelo;
  * de integracao depois da varredura), e `maxParalelo` limita quantos rodam ao mesmo tempo.
  */
 const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
 const fs = __importStar(require("node:fs"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const agendador_cpu_1 = require("./agendador-cpu");
+const integracoes_locais_1 = require("./integracoes-locais");
 const TIMEOUT_BIN = '/usr/bin/timeout';
 const NICE_BIN = '/usr/bin/nice';
+const TIME_BIN = '/usr/bin/time';
+const CONTRATO_PERFIL_INTEGRACAO = 'ork.check.cpu-integracao/v1';
+const INTERVALO_CPU_MS = 100;
 /** O argv de um item: `nice` (se pedido e existir), `timeout(1)` (se existir) e o `argv` do item ou `bash -c`. */
 function argvDoItem(item, comGrupo = fs.existsSync(TIMEOUT_BIN), comNice = fs.existsSync(NICE_BIN)) {
     const programa = item.argv?.length ? item.argv : ['bash', '-c', item.comando];
@@ -77,6 +84,243 @@ function vagas(max) {
             livres++; },
     };
 }
+function arquivoDoPerfilIntegracao() {
+    const base = process.env.XDG_CACHE_HOME && path.isAbsolute(process.env.XDG_CACHE_HOME)
+        ? process.env.XDG_CACHE_HOME : path.join(os.homedir(), '.cache');
+    return path.join(base, 'orkastery', 'check', 'cpu-integracao.json');
+}
+/** Os arquivos da lane de integracao, pela mesma regra do `test-lanes.cjs`: a lista do ambiente ou a do nucleo. */
+function arquivosDaIntegracao(env = process.env) {
+    const lista = env.ORK_LANES_INTEGRACAO !== undefined
+        ? env.ORK_LANES_INTEGRACAO.split(',').map((n) => n.trim()).filter(Boolean) : [...integracoes_locais_1.TESTES_DE_INTEGRACAO_LOCAL];
+    return [...new Set(lista)].sort();
+}
+/**
+ * A medida so atravessa rodadas quando comando, capacidade e entradas que definem a lane continuam iguais: o script das
+ * lanes, a lista de integracao e o conteudo compilado de cada teste dela. Teste novo, mudado ou ausente troca a chave.
+ */
+function chaveDoPerfilIntegracao(itens, cpus, arquivos = arquivosDaIntegracao()) {
+    const integracao = itens.filter((i) => i.papelCpu === 'integracao');
+    if (!integracao.length)
+        return null;
+    const h = (0, node_crypto_1.createHash)('sha256').update(JSON.stringify({ cpus, node: process.version,
+        comandos: integracao.map((i) => i.comando), arquivos }));
+    const cwd = integracao[0].cwd;
+    const relativos = ['core/dist/integracoes-locais.js', 'core/scripts/test-lanes.cjs',
+        ...arquivos.map((nome) => path.join('core', 'dist-test', 'test', nome))];
+    for (const relativo of relativos) {
+        try {
+            h.update(relativo).update(fs.readFileSync(path.join(cwd, relativo)));
+        }
+        catch {
+            h.update(`${relativo}:ausente`);
+        }
+    }
+    return h.digest('hex');
+}
+function lerPerfilIntegracao(chave, cpus) {
+    if (!chave)
+        return null;
+    try {
+        const p = JSON.parse(fs.readFileSync(arquivoDoPerfilIntegracao(), 'utf8'));
+        return p?.contrato === CONTRATO_PERFIL_INTEGRACAO && p.chave === chave && p.cpus === cpus && p.completa
+            && Number.isFinite(p.picoCpus) && p.picoCpus > 0 && p.picoCpus <= cpus ? p : null;
+    }
+    catch {
+        return null;
+    }
+}
+function gravarPerfilIntegracao(chave, cpus, medicao) {
+    if (!chave || !medicao.completa || medicao.anomalia || medicao.picoCpus === null
+        || !(medicao.picoCpus > 0) || medicao.picoCpus > cpus)
+        return;
+    const arquivo = arquivoDoPerfilIntegracao();
+    try {
+        fs.mkdirSync(path.dirname(arquivo), { recursive: true });
+        const temporario = `${arquivo}.${process.pid}.tmp`;
+        const perfil = { contrato: CONTRATO_PERFIL_INTEGRACAO, chave, cpus,
+            picoCpus: medicao.picoCpus, completa: true, medidoEm: new Date().toISOString() };
+        fs.writeFileSync(temporario, JSON.stringify(perfil) + '\n', { mode: 0o600 });
+        fs.renameSync(temporario, arquivo);
+    }
+    catch { /* cache de desempenho ausente conserva a reserva; nunca derruba o CHECK */ }
+}
+const CLK_TCK = (() => {
+    const r = (0, node_child_process_1.spawnSync)('getconf', ['CLK_TCK'], { encoding: 'utf8', timeout: 1000 });
+    const n = Number(r.stdout?.trim());
+    return Number.isFinite(n) && n > 0 ? n : 100;
+})();
+function processosCpu() {
+    const tabela = new Map();
+    let nomes = [];
+    try {
+        nomes = fs.readdirSync('/proc');
+    }
+    catch {
+        return tabela;
+    }
+    for (const nome of nomes) {
+        if (!/^\d+$/.test(nome))
+            continue;
+        try {
+            const stat = fs.readFileSync(`/proc/${nome}/stat`, 'utf8');
+            const depois = stat.slice(stat.lastIndexOf(')') + 2).trim().split(/\s+/);
+            tabela.set(Number(nome), { ppid: Number(depois[1]), cpuMs: (Number(depois[11]) + Number(depois[12])) * 1000 / CLK_TCK,
+                inicio: depois[19] });
+        }
+        catch { /* acabou entre a lista e a leitura */ }
+    }
+    return tabela;
+}
+function arvoreDeProcessos(raiz, tabela) {
+    const filhos = new Map();
+    for (const [pid, p] of tabela) {
+        const lista = filhos.get(p.ppid) ?? [];
+        lista.push(pid);
+        filhos.set(p.ppid, lista);
+    }
+    const vistos = new Set(), pilha = [raiz];
+    while (pilha.length) {
+        const pid = pilha.pop();
+        if (vistos.has(pid))
+            continue;
+        vistos.add(pid);
+        pilha.push(...(filhos.get(pid) ?? []));
+    }
+    return [...vistos];
+}
+function nomesDosContainers(arquivo) {
+    try {
+        return [...new Set(fs.readFileSync(arquivo, 'utf8').split('\n').filter(Boolean).flatMap((linha) => {
+                try {
+                    const r = JSON.parse(linha);
+                    return typeof r.nome === 'string' ? [r.nome] : [];
+                }
+                catch {
+                    return [];
+                }
+            }))];
+    }
+    catch {
+        return [];
+    }
+}
+function arquivoCpuDoContainer(nome) {
+    const r = (0, node_child_process_1.spawnSync)('docker', ['inspect', '--format', '{{.Id}} {{.State.Pid}}', nome], { encoding: 'utf8', timeout: 1000 });
+    const [id = '', pidTexto = ''] = r.stdout?.trim().split(/\s+/) ?? [];
+    const pid = Number(pidTexto);
+    if (r.status !== 0)
+        return { fonte: null, motivo: 'docker inspect nao encontrou o conteiner' };
+    if (!/^[a-f0-9]{12,64}$/.test(id) || !Number.isInteger(pid) || pid <= 0) {
+        return { fonte: null, motivo: 'PID ou identificador do conteiner indisponivel' };
+    }
+    let linhas = '';
+    try {
+        linhas = fs.readFileSync(`/proc/${pid}/cgroup`, 'utf8');
+    }
+    catch {
+        return { fonte: null, motivo: 'cgroup do PID do conteiner indisponivel' };
+    }
+    const unificado = /^0::(.+)$/m.exec(linhas)?.[1];
+    const candidatos = [
+        ...(unificado ? [{ arquivo: path.join('/sys/fs/cgroup', unificado, 'cpu.stat'), divisor: 1000 }] : []),
+        { arquivo: path.join('/sys/fs/cgroup/system.slice', `docker-${id}.scope`, 'cpu.stat'), divisor: 1000 },
+        { arquivo: path.join('/sys/fs/cgroup/docker', id, 'cpu.stat'), divisor: 1000 },
+    ];
+    const legado = /^(?:\d+):[^\n]*(?:cpuacct|cpu)[^\n]*:(.+)$/m.exec(linhas)?.[1];
+    if (legado)
+        candidatos.push({ arquivo: path.join('/sys/fs/cgroup/cpuacct', legado, 'cpuacct.usage'), divisor: 1_000_000 });
+    const fonte = candidatos.find((x) => fs.existsSync(x.arquivo)) ?? null;
+    return fonte ? { fonte, motivo: null }
+        : { fonte: null, motivo: 'cpu.stat ausente no cgroup v2, no escopo do systemd e no caminho legado' };
+}
+function lerCpuDoCgroup(fonte) {
+    try {
+        const texto = fs.readFileSync(fonte.arquivo, 'utf8');
+        const bruto = fonte.arquivo.endsWith('cpu.stat') ? Number(/^usage_usec\s+(\d+)$/m.exec(texto)?.[1]) : Number(texto.trim());
+        return Number.isFinite(bruto) && bruto >= 0 ? bruto / fonte.divisor : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Calcula o pico por fonte. A primeira leitura vira baseline; uma fonte que nasce depois dela contribui com o acumulado
+ * desde seu nascimento, sem despejar na janela o tempo anterior de processos ou conteineres que ja existiam.
+ */
+function picoCpuPorFonte(amostras, cpus) {
+    let pico = 0;
+    for (let i = 1; i < amostras.length; i++) {
+        const anterior = amostras[i - 1], atual = amostras[i];
+        if (!(atual.em > anterior.em))
+            continue;
+        let delta = 0;
+        for (const [fonte, acumulado] of Object.entries(atual.fontes)) {
+            const base = anterior.fontes[fonte];
+            delta += Math.max(0, acumulado - (base ?? 0));
+        }
+        pico = Math.max(pico, delta / (atual.em - anterior.em));
+    }
+    if (pico > cpus + 1e-9) {
+        return { picoCpus: null, anomalia: `pico medido de ${pico.toFixed(2)} CPU excede a capacidade de ${cpus} CPU` };
+    }
+    return { picoCpus: pico > 0 ? Math.ceil(pico * 100) / 100 : null, anomalia: null };
+}
+/** CPU acumulada e pico por janela da integracao; nomes registrados mas nunca observados tornam a medida incompleta. */
+function sondarCpuDaIntegracao(pid, registro, cpus) {
+    const fontes = new Map();
+    const motivos = new Map();
+    const amostras = [];
+    const primeiraCpuDosContainers = new Map();
+    const ultimaCpuDosContainers = new Map();
+    const amostrar = () => {
+        const tabela = processosCpu();
+        const atuais = {};
+        for (const p of arvoreDeProcessos(pid, tabela)) {
+            const x = tabela.get(p);
+            if (x)
+                atuais[`processo:${p}:${x.inicio}`] = x.cpuMs;
+        }
+        for (const nome of nomesDosContainers(registro)) {
+            let fonte = fontes.get(nome);
+            if (!fonte) {
+                const busca = arquivoCpuDoContainer(nome);
+                if (busca.fonte) {
+                    fonte = busca.fonte;
+                    fontes.set(nome, fonte);
+                    motivos.delete(nome);
+                }
+                else if (busca.motivo)
+                    motivos.set(nome, busca.motivo);
+            }
+            const cpu = fonte ? lerCpuDoCgroup(fonte) : null;
+            if (cpu !== null) {
+                atuais[`conteiner:${nome}`] = cpu;
+                if (!primeiraCpuDosContainers.has(nome))
+                    primeiraCpuDosContainers.set(nome, amostras.length === 0 ? cpu : 0);
+                ultimaCpuDosContainers.set(nome, cpu);
+                motivos.delete(nome);
+            }
+            else if (fonte)
+                motivos.set(nome, 'contador de CPU do cgroup ilegivel');
+        }
+        amostras.push({ em: Date.now(), fontes: atuais });
+    };
+    return {
+        amostrar,
+        fechar: (arvoreMs, paredeMs) => {
+            amostrar();
+            const nomes = nomesDosContainers(registro);
+            const containersMs = nomes.reduce((total, nome) => total + Math.max(0, (ultimaCpuDosContainers.get(nome) ?? 0) - (primeiraCpuDosContainers.get(nome) ?? 0)), 0);
+            const ausentes = nomes.filter((nome) => !ultimaCpuDosContainers.has(nome));
+            const pico = picoCpuPorFonte(amostras, cpus);
+            return { arvoreMs, containersMs, totalMs: arvoreMs + containersMs, paredeMs,
+                picoCpus: pico.picoCpus, completa: ausentes.length === 0 && !pico.anomalia,
+                containers: nomes, ausentes, motivosDosAusentes: ausentes.map((container) => ({ container,
+                    motivo: motivos.get(container) ?? 'conteiner terminou antes de uma amostra completa' })), anomalia: pico.anomalia };
+        },
+    };
+}
 /**
  * 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.
@@ -84,8 +328,17 @@ function vagas(max) {
 async function rodarEspecificacao(esp) {
     const comGrupo = fs.existsSync(TIMEOUT_BIN);
     const usaAgendador = esp.itens.some((i) => i.papelCpu === 'hermetica');
-    const plano = usaAgendador ? (0, agendador_cpu_1.planejarCpuDoGrupo)(esp.cpus ?? os.availableParallelism(), esp.medicaoCpu ?? await (0, agendador_cpu_1.medirCpuDoGrupo)()) : undefined;
-    const itens = plano ? aplicarPlano(esp.itens, plano) : esp.itens;
+    const cpus = esp.cpus ?? os.availableParallelism();
+    const chaveDoPerfil = usaAgendador ? chaveDoPerfilIntegracao(esp.itens, cpus) : null;
+    const perfil = esp.medicaoCpu?.cpusIntegracao === undefined ? lerPerfilIntegracao(chaveDoPerfil, cpus) : null;
+    const medicao = esp.medicaoCpu ?? await (0, agendador_cpu_1.medirCpuDoGrupo)();
+    if (perfil)
+        Object.assign(medicao, { cpusIntegracao: perfil.picoCpus, fonteCpusIntegracao: 'medida' });
+    else if (medicao.cpusIntegracao === undefined)
+        Object.assign(medicao, { cpusIntegracao: null, fonteCpusIntegracao: 'conservadora' });
+    const plano = usaAgendador ? (0, agendador_cpu_1.planejarCpuDoGrupo)(cpus, medicao) : undefined;
+    const sinalDaReserva = plano && !plano.saturado ? path.join(esp.dir, 'reserva-devolvida.json') : undefined;
+    const itens = plano ? aplicarPlano(esp.itens, plano, sinalDaReserva) : esp.itens;
     const limite = vagas(esp.maxParalelo && esp.maxParalelo > 0 ? esp.maxParalelo : itens.length);
     const porNome = new Map();
     const indice = new Map(itens.map((item, i) => [item.nome, i]));
@@ -112,26 +365,92 @@ async function rodarEspecificacao(esp) {
         porNome.set(item.nome, vez);
         return vez;
     };
-    const terminados = await Promise.all(itens.map(vezDoItem));
+    const todos = Promise.all(itens.map(vezDoItem));
+    const reservados = itens.filter((item) => item.papelCpu === 'varredura' || item.papelCpu === 'integracao');
+    const devolverReserva = async () => {
+        if (!sinalDaReserva || !reservados.some((item) => item.papelCpu === 'varredura')
+            || !reservados.some((item) => item.papelCpu === 'integracao'))
+            return;
+        const varreduras = reservados.filter((item) => item.papelCpu === 'varredura');
+        const integracoes = reservados.filter((item) => item.papelCpu === 'integracao');
+        const degrau = async (origem, pecas, vagas, antes) => {
+            await Promise.all(pecas.map((item) => vezDoItem(item, indice.get(item.nome))));
+            fs.appendFileSync(sinalDaReserva, JSON.stringify({ contrato: 'ork.check.reserva-devolvida/v2', origem,
+                em: new Date().toISOString(), vagasGanhas: vagas - antes, vagas }) + '\n', { mode: 0o600 });
+        };
+        if (!plano.integracaoEmParalelo) {
+            await degrau('varredura', varreduras, plano.cpusHermeticaAposVarredura, plano.cpusHermetica);
+            await degrau('integracao', integracoes, plano.cpusHermeticaAposReserva, plano.cpusHermeticaAposVarredura);
+        }
+        else {
+            // As promessas escrevem em série no event loop; o primeiro término recebe somente a reserva da própria peça.
+            let vagas = plano.cpusHermetica;
+            const aoTerminar = async (origem, pecas, libera) => {
+                await Promise.all(pecas.map((item) => vezDoItem(item, indice.get(item.nome))));
+                const antes = vagas;
+                vagas = Math.min(plano.cpus, vagas + libera);
+                fs.appendFileSync(sinalDaReserva, JSON.stringify({ contrato: 'ork.check.reserva-devolvida/v2', origem,
+                    em: new Date().toISOString(), vagasGanhas: vagas - antes, vagas }) + '\n', { mode: 0o600 });
+            };
+            await Promise.all([aoTerminar('varredura', varreduras, plano.cpusDaFatia),
+                aoTerminar('integracao', integracoes, plano.cpusIntegracao)]);
+        }
+    };
+    const [, terminados] = await Promise.all([devolverReserva(), todos]);
+    const medidaDaIntegracao = terminados.find((t) => t.medicaoCpu)?.medicaoCpu;
+    if (plano && medidaDaIntegracao) {
+        plano.medicaoCpuIntegracao = medidaDaIntegracao;
+        gravarPerfilIntegracao(chaveDoPerfil, cpus, medidaDaIntegracao);
+    }
     fs.writeFileSync(path.join(esp.dir, 'resultado.json'), JSON.stringify({ terminados, ...(plano ? { agendamentoCpu: plano } : {}) }), { 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);
+            const medirIntegracao = item.papelCpu === 'integracao';
+            const registro = path.join(esp.dir, `${i}.containers.jsonl`);
+            const tempo = path.join(esp.dir, `${i}.tempo`);
+            if (medirIntegracao)
+                fs.writeFileSync(registro, '', { mode: 0o600 });
+            const base = argvDoItem(item, comGrupo);
+            const medido = medirIntegracao && fs.existsSync(TIME_BIN)
+                ? [TIME_BIN, '-f', '%U %S', '-o', tempo, ...base] : base;
+            const [bin, ...args] = medido;
             let fim = null;
+            let sonda = null;
+            let relogio = null;
             const encerrar = (t) => {
                 if (fim)
                     return;
-                fim = t;
+                if (relogio)
+                    clearInterval(relogio);
+                let arvoreMs = 0;
+                if (medirIntegracao) {
+                    try {
+                        const [user, sys] = fs.readFileSync(tempo, 'utf8').trim().split(/\s+/).map(Number);
+                        arvoreMs = (user + sys) * 1000;
+                    }
+                    catch { /* medida incompleta abaixo */ }
+                }
+                const medicaoCpu = medirIntegracao && sonda ? sonda.fechar(arvoreMs, t.duracaoMs) : undefined;
+                if (medicaoCpu && !(arvoreMs > 0))
+                    medicaoCpu.completa = false;
+                fim = { ...t, ...(medicaoCpu ? { medicaoCpu } : {}) };
                 fs.closeSync(saida);
                 fs.closeSync(erro);
-                resolve(t);
+                resolve(fim);
             };
             // 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],
+            const ambiente = { ...process.env, ...item.ambiente,
+                ...(medirIntegracao ? { [agendador_cpu_1.ENV_CONTAINERS_DA_LANE]: registro } : {}) };
+            const filho = (0, node_child_process_1.spawn)(bin, args, { cwd: item.cwd, env: ambiente, stdio: ['ignore', saida, erro],
                 ...(comGrupo ? {} : { timeout: item.prazoMs, killSignal: 'SIGTERM' }) });
+            if (medirIntegracao) {
+                sonda = sondarCpuDaIntegracao(filho.pid, registro, cpus);
+                sonda.amostrar();
+                relogio = setInterval(sonda.amostrar, INTERVALO_CPU_MS);
+            }
             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,
@@ -141,7 +460,7 @@ async function rodarEspecificacao(esp) {
     }
 }
 /** Aplica a mesma conta aos processos, as lanes e aos conteineres que eles criarem. */
-function aplicarPlano(originais, plano) {
+function aplicarPlano(originais, plano, sinalDaReserva) {
     const itens = originais.map((item) => ({ ...item, ambiente: { ...item.ambiente } }));
     const porPapel = (papel) => itens.filter((i) => i.papelCpu === papel);
     const hermetica = porPapel('hermetica')[0];
@@ -158,23 +477,27 @@ function aplicarPlano(originais, plano) {
             item.ambiente = { ...item.ambiente, ...valores };
     };
     const cpusContainer = String(plano.cpusPorContainer);
-    ambiente(hermetica, { [agendador_cpu_1.ENV_CPUS_DA_LANE]: String(plano.cpusHermetica), [agendador_cpu_1.ENV_CPUS_DOCKER]: cpusContainer });
+    ambiente(hermetica, { [agendador_cpu_1.ENV_CPUS_DA_LANE]: String(plano.cpusHermetica), [agendador_cpu_1.ENV_CPUS_DOCKER]: cpusContainer,
+        ...(sinalDaReserva && varredura && integracoes.length > 0 ? {
+            [agendador_cpu_1.ENV_CPUS_DA_LANE_APOS_VARREDURA]: String(plano.cpusHermeticaAposVarredura),
+            [agendador_cpu_1.ENV_CPUS_DA_LANE_APOS_RESERVA]: String(plano.cpusHermeticaAposReserva), [agendador_cpu_1.ENV_SINAL_DA_RESERVA]: sinalDaReserva,
+        } : {}) });
     ambiente(varredura, {
         ORK_CHECK_VARREDURA_PARALELA: String(plano.ferramentasDaVarredura),
         [agendador_cpu_1.ENV_CPUS_DOCKER]: cpusContainer,
     });
-    let anterior = varredura?.nome;
+    let anteriorIntegracao;
     for (const item of integracoes) {
         ambiente(item, { [agendador_cpu_1.ENV_CPUS_DA_LANE]: String(plano.cpusIntegracao), [agendador_cpu_1.ENV_CPUS_DOCKER]: cpusContainer });
-        depender(item, [anterior]);
-        anterior = item.nome;
+        depender(item, [anteriorIntegracao ?? (plano.integracaoEmParalelo ? undefined : varredura?.nome)]);
+        anteriorIntegracao = item.nome;
     }
     if (plano.saturado)
         depender(varredura, [hermetica?.nome]);
     // Comandos sem papel conhecido nao disputam CPU com as tres pecas: fecham a cadeia, um por vez.
     for (const item of outros) {
-        depender(item, [hermetica?.nome, anterior]);
-        anterior = item.nome;
+        depender(item, [hermetica?.nome, varredura?.nome, anteriorIntegracao]);
+        anteriorIntegracao = item.nome;
     }
     return itens;
 }

package/dist/claims.js

@@ -127,7 +127,7 @@ function montarClaim(entrada) {
         criadoEm: (0, util_1.agora)(),
         estado: verificar.length > 0 ? 'pendente' : 'nao-verificavel',
         ...(entrada.origem ? { origem: entrada.origem } : {}),
-        // I-53 (RM-037, P6): a mesma regra para CLI, MCP, canarios e auditor, porque todos passam aqui.
+        // I-53 (RM-037, P6): a mesma regra para CLI, MCP, cenarios e auditor, porque todos passam aqui.
         lint: (0, claim_lint_1.analisarComandos)(verificar),
     };
 }

package/dist/docs.js

@@ -110,7 +110,7 @@ exports.DIMENSOES = {
     codigo: ['Não iniciado', 'Branch criada', 'PR aberto', 'Mesclado'],
     testes: ['Não iniciados', 'Em execução', 'Aprovados', 'Falhando'],
     deploy: ['Não implantado', 'Dev', 'Staging', 'Produção'],
-    exposicao: ['Flag desligada', 'Piloto/Canary', 'Parcial', 'Geral'],
+    exposicao: ['Flag desligada', 'Piloto/Gradual', 'Parcial', 'Geral'],
     habilitacao: ['Pendente', 'Em andamento', 'Concluída'],
 };
 exports.CATEGORIAS = ['iniciativa', 'épico', 'feature', 'melhoria'];

package/dist/evalrunner.js

@@ -4,7 +4,7 @@
  *
  * Ele julga duas coisas, e diz em voz alta que so uma delas ele consegue julgar.
  *
- *  1. **Os canarios** (`eval/fixtures/fx-*`): comportamento real do nucleo, exercitado ponta a
+ *  1. **Os cenarios** (`eval/fixtures/fx-*`): comportamento real do nucleo, exercitado ponta a
  *     ponta contra git de verdade, comparado com o que a fixture declara esperar.
  *  2. **O corpus das skills** (`eval/casos/*.json`): as regras que precisam EXISTIR no arquivo
  *     da skill para o comportamento ser possivel. Isso e deterministico, e e o que o runner
@@ -60,12 +60,12 @@ exports.posicoesDaAssercao = posicoesDaAssercao;
 exports.dirDeCasos = dirDeCasos;
 exports.dirDeFixtures = dirDeFixtures;
 exports.lerCasos = lerCasos;
-exports.rodarCanarios = rodarCanarios;
+exports.rodarCenarios = rodarCenarios;
 exports.rodarEval = rodarEval;
 exports.textoDoEval = textoDoEval;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
-const canarios_1 = require("./canarios");
+const cenarios_1 = require("./cenarios");
 const catalogo_1 = require("./catalogo");
 const util_1 = require("./util");
 const locale_1 = require("./locale");
@@ -271,20 +271,20 @@ function comparar(esperado, observado) {
     }
     return divergencias;
 }
-/** Roda os canarios cujas fixtures existem em `eval/fixtures/fx-*`. */
-function rodarCanarios(catalogo, filtro) {
+/** Roda os cenarios cujas fixtures existem em `eval/fixtures/fx-*`. */
+function rodarCenarios(catalogo, filtro) {
     const dir = dirDeFixtures(catalogo);
     const resultados = [];
     const falhas = [];
     const m = (0, locale_1.msg)().operacao.restante.eval;
-    const temGit = (0, canarios_1.gitDisponivel)();
+    const temGit = (0, cenarios_1.gitDisponivel)();
     const nomes = fs.existsSync(dir) ? fs.readdirSync(dir).sort() : [];
     if (filtro && filtro.length === 0) {
         falhas.push({ codigo: 'fixture-invalida', detalhe: m.filtroVazio });
     }
     for (const id of new Set(filtro ?? [])) {
-        if (!nomes.includes(id) || !(0, canarios_1.canarioPorId)(id)) {
-            falhas.push({ codigo: 'canario-sem-executor', caso: id, detalhe: m.canarioAusente(id) });
+        if (!nomes.includes(id) || !(0, cenarios_1.cenarioPorId)(id)) {
+            falhas.push({ codigo: 'cenario-sem-executor', caso: id, detalhe: m.cenarioAusente(id) });
         }
     }
     for (const nome of nomes) {
@@ -305,22 +305,22 @@ function rodarCanarios(catalogo, filtro) {
             falhas.push({ codigo: 'fixture-invalida', detalhe: `${nome}: ${e.message}` });
             continue;
         }
-        const canario = (0, canarios_1.canarioPorId)(fixture.id ?? nome);
+        const cenario = (0, cenarios_1.cenarioPorId)(fixture.id ?? nome);
         if (fixture.id !== nome) {
             falhas.push({ codigo: 'fixture-invalida', caso: nome, detalhe: m.fixtureDiverge });
             continue;
         }
-        if (!canario) {
+        if (!cenario) {
             falhas.push({
-                codigo: 'canario-sem-executor',
+                codigo: 'cenario-sem-executor',
                 detalhe: m.semExecutor(nome, fixture.id ?? nome),
             });
             continue;
         }
-        if (canario.precisaDeGit && !temGit) {
+        if (cenario.precisaDeGit && !temGit) {
             resultados.push({
-                id: canario.id,
-                sobre: canario.sobre,
+                id: cenario.id,
+                sobre: cenario.sobre,
                 estado: 'unavailable',
                 divergencias: [],
                 motivo: m.semGit,
@@ -329,11 +329,11 @@ function rodarCanarios(catalogo, filtro) {
             continue;
         }
         try {
-            const observado = canario.rodar({ catalogo });
+            const observado = cenario.rodar({ catalogo });
             const divergencias = comparar(fixture.esperado ?? {}, observado);
             resultados.push({
-                id: canario.id,
-                sobre: canario.sobre,
+                id: cenario.id,
+                sobre: cenario.sobre,
                 estado: divergencias.length === 0 ? 'passou' : 'falhou',
                 divergencias,
                 motivo: divergencias.length === 0 ? '' : `${divergencias.length} chave(s) divergente(s)`,
@@ -341,33 +341,33 @@ function rodarCanarios(catalogo, filtro) {
             });
             for (const d of divergencias) {
                 falhas.push({
-                    codigo: 'canario',
-                    caso: `${canario.id}/${d.chave}`,
+                    codigo: 'cenario',
+                    caso: `${cenario.id}/${d.chave}`,
                     detalhe: m.divergencia(JSON.stringify(d.esperado), JSON.stringify(d.observado)),
                 });
             }
         }
         catch (e) {
             resultados.push({
-                id: canario.id,
-                sobre: canario.sobre,
+                id: cenario.id,
+                sobre: cenario.sobre,
                 estado: 'falhou',
                 divergencias: [],
                 motivo: e.message,
                 observado: {},
             });
-            falhas.push({ codigo: 'canario', caso: canario.id, detalhe: e.message });
+            falhas.push({ codigo: 'cenario', caso: cenario.id, detalhe: e.message });
         }
     }
-    // Canario registrado no codigo e sem fixture em disco tambem e defeito: a expectativa
+    // Cenario registrado no codigo e sem fixture em disco tambem e defeito: a expectativa
     // precisa ser dado versionado, revisavel por quem nao le TypeScript.
     if (!filtro) {
-        for (const c of canarios_1.CANARIOS) {
+        for (const c of cenarios_1.CENARIOS) {
             if (!fs.existsSync(path.join(dir, c.id, 'caso.json'))) {
                 falhas.push({
                     codigo: 'fixture-invalida',
                     caso: c.id,
-                    detalhe: m.canarioSemFixture(c.id),
+                    detalhe: m.cenarioSemFixture(c.id),
                 });
             }
         }
@@ -377,20 +377,20 @@ function rodarCanarios(catalogo, filtro) {
 // ---------------------------------------------------------------------------
 // Orquestracao
 // ---------------------------------------------------------------------------
-/** Roda o eval inteiro: canarios mais corpus das skills. */
+/** Roda o eval inteiro: cenarios mais corpus das skills. */
 function rodarEval(opcoes) {
     const { catalogo } = opcoes;
     const falhas = [];
     const linhas = [];
-    let canarios = [];
+    let cenarios = [];
     if (!opcoes.soSkills) {
-        const r = rodarCanarios(catalogo, opcoes.canarios);
-        canarios = r.resultados;
+        const r = rodarCenarios(catalogo, opcoes.cenarios);
+        cenarios = r.resultados;
         falhas.push(...r.falhas);
     }
     let totalDeCasos = 0;
     let totalDeAssercoes = 0;
-    if (!opcoes.soCanarios) {
+    if (!opcoes.soCenarios) {
         const { arquivos, falhas: falhasDeLeitura } = lerCasos(catalogo);
         falhas.push(...falhasDeLeitura);
         const doCatalogo = (0, catalogo_1.skillsDoCatalogo)(catalogo);
@@ -428,7 +428,7 @@ function rodarEval(opcoes) {
     return {
         catalogo,
         skills: linhas,
-        canarios,
+        cenarios,
         falhas,
         totalDeCasos,
         totalDeAssercoes,
@@ -442,10 +442,10 @@ function textoDoEval(r) {
     const linhas = [];
     linhas.push(m.titulo(r.catalogo));
     linhas.push('');
-    if (r.canarios.length > 0) {
-        linhas.push(m.canarios);
+    if (r.cenarios.length > 0) {
+        linhas.push(m.cenarios);
         linhas.push('');
-        linhas.push((0, util_1.tabela)([...m.colunasCanarios], r.canarios.map((c) => [c.id, m.estados[c.estado] ?? c.estado, c.estado === 'passou' ? c.sobre : c.motivo || c.sobre])));
+        linhas.push((0, util_1.tabela)([...m.colunasCenarios], r.cenarios.map((c) => [c.id, m.estados[c.estado] ?? c.estado, c.estado === 'passou' ? c.sobre : c.motivo || c.sobre])));
         linhas.push('');
     }
     if (r.skills.length > 0) {
@@ -463,9 +463,9 @@ function textoDoEval(r) {
         }
         linhas.push('');
     }
-    const passaram = r.canarios.filter((c) => c.estado === 'passou').length;
-    const indisponiveis = r.canarios.filter((c) => c.estado === 'unavailable').length;
-    linhas.push(m.resumoCanarios(passaram, r.canarios.length, indisponiveis));
+    const passaram = r.cenarios.filter((c) => c.estado === 'passou').length;
+    const indisponiveis = r.cenarios.filter((c) => c.estado === 'unavailable').length;
+    linhas.push(m.resumoCenarios(passaram, r.cenarios.length, indisponiveis));
     linhas.push(m.resumoSkills(r.skills.length, r.totalDeCasos, r.totalDeAssercoes, r.falhas.length));
     linhas.push(m.metade);
     linhas.push(m.veredito(r.ok));

package/dist/hitl-canais.js

@@ -204,7 +204,7 @@ function recusarIngressoNaoHomologado(ingresso) {
     }
     return ingresso;
 }
-/** Invariantes do registro. O teste chama isto; o produto tambem, no canario. */
+/** Invariantes do registro. O teste chama isto; o produto tambem, no cenario. */
 function conferirRegistro() {
     const canais = canaisHomologados();
     if (canais.length !== hosts_1.ORDEM_DOS_HOSTS.length || canais.length !== 4) {

package/dist/hitl-presentation.js

@@ -178,7 +178,7 @@ function pedidoHitlAberto(raiz, id, fase, sessionId) {
 /**
  * FX6: a oferta de canais que acompanha um pedido HITL REAL.
  *
- * `ofertaDeCanais` existia desde D12 e era chamada de um lugar so: o canario. No caminho de
+ * `ofertaDeCanais` existia desde D12 e era chamada de um lugar so: o cenario. No caminho de
  * producao o humano via a pergunta e um `comandoResposta`, e nada dizia por quais canais dava
  * para responder AGORA nem por que os outros nao serviam. Uma oferta que so aparece em
  * simulacao nao e oferta; e uma tabela bonita, como a propria narrativa de D12 admitia.