@orkastery/cli 0.5.3 → 0.6.0

package/dist/noctum-capacidade.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fatosDeCapacidade = fatosDeCapacidade;
+exports.admitir = admitir;
+exports.escolherConta = escolherConta;
+const conducao_1 = require("./conducao");
+const ledger_1 = require("./ledger");
+const ocupacao_1 = require("./ocupacao");
+const sessoes_contas_1 = require("./sessoes-contas");
+const thread_1 = require("./thread");
+/** O runtime mostra a sessão trabalhando agora: o claude-bg diz `running` ou `busy` (o watcher chama de `working`). */
+const TRABALHANDO = ['running', 'busy', 'working'];
+const estadoDe = (s) => String(s.state ?? s.status ?? '').trim().toLowerCase();
+/**
+ * O runtime prova que a sessão do lease acabou? Presente com estado terminal ou fantasma, sim. Ausente, só no
+ * claude-bg (o `claude agents` lista as sessões que o daemon da conta mantém), com todas as fontes lidas e a conta
+ * dela entre as consultadas. O codex lista só rollouts recentes: ausência lá não prova nada.
+ */
+function encerradaPeloRuntime(dono, leitura, porSessao, semLacuna) {
+    const vista = porSessao.get(dono.sessionId);
+    if (vista)
+        return (0, sessoes_contas_1.encerradaNaLista)(vista);
+    if (!semLacuna || dono.runtime !== 'claude-bg')
+        return false;
+    return leitura.contas.some(c => c.runtime === 'claude-bg' && (c.perfil?.id ?? null) === dono.perfil);
+}
+/**
+ * A ocupação desta máquina agora, relida a cada chamada. `consultar` é dependência dos testes; sem ela, as sessões de
+ * todas as contas pelo `consultarContas`, a mesma leitura do escalonador.
+ */
+function fatosDeCapacidade(carregado, opcoes = {}) {
+    const quando = opcoes.quando ?? new Date().toISOString();
+    const { raiz, manifesto } = carregado;
+    const staleMin = manifesto.concurrency.stale_after_min;
+    const leitura = (opcoes.consultar ?? (() => (0, sessoes_contas_1.consultarContas)(raiz, { staleMin })))();
+    const lacunas = leitura.fontes.filter(f => !f.ok).map(f => `${f.origem}: ${f.detalhe}`);
+    const porSessao = new Map(leitura.sessoes.map(s => [s.sessionId, s]));
+    const ocupantes = [];
+    const encerradasPeloRuntime = [];
+    const contadas = new Set();
+    // A sessão que a regra da vaga solta (turno encerrado, espera do dono, parada) não volta pela lista do runtime,
+    // a não ser que o runtime a mostre trabalhando agora (A8 do CHECK): a regra da vaga lê só o ledger.
+    const soltas = new Set();
+    for (const id of (0, thread_1.listarIds)(raiz)) {
+        let atual = null;
+        try {
+            atual = (0, conducao_1.conducaoDaThread)(raiz, id);
+        }
+        catch {
+            continue;
+        }
+        if (!atual)
+            continue;
+        if (atual.dono.tipo === 'processo' && (atual.operacao === 'phase.run' || atual.operacao === 'retry.run')) {
+            ocupantes.push({ sessionId: null, thread: id, runtime: null, conta: null, revisao: atual.fase === 'CHECK', origem: 'despacho' });
+            continue;
+        }
+        if (atual.dono.tipo !== 'sessao')
+            continue;
+        const dono = atual.dono;
+        const vista = porSessao.get(dono.sessionId);
+        try {
+            if ((0, ocupacao_1.sessaoLivreDaVaga)((0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, id)), atual.desde, quando, staleMin, dono.sessionId) &&
+                !(vista?.viva && TRABALHANDO.includes(estadoDe(vista)))) {
+                soltas.add(dono.sessionId);
+                continue;
+            }
+        }
+        catch { /* ledger ilegível: a condução viva continua contando, como no portão do phase run */ }
+        if (encerradaPeloRuntime(dono, leitura, porSessao, lacunas.length === 0)) {
+            encerradasPeloRuntime.push(dono.sessionId);
+            continue;
+        }
+        contadas.add(dono.sessionId);
+        // A5 do CHECK: o despacho sem `--perfil` grava o lease sem conta; a conta é a que o runtime atribui à sessão.
+        ocupantes.push({ sessionId: dono.sessionId, thread: id, runtime: dono.runtime, conta: dono.perfil ?? vista?.perfil ?? null,
+            revisao: atual.fase === 'CHECK', origem: 'conducao' });
+    }
+    for (const s of leitura.sessoes) {
+        if (!s.viva || !TRABALHANDO.includes(estadoDe(s)) || contadas.has(s.sessionId) || soltas.has(s.sessionId) ||
+            encerradasPeloRuntime.includes(s.sessionId))
+            continue;
+        contadas.add(s.sessionId);
+        ocupantes.push({ sessionId: s.sessionId, thread: null, runtime: s.runtime, conta: s.perfil, revisao: false, origem: 'runtime' });
+    }
+    return { quando, ocupantes, lacunas, encerradasPeloRuntime };
+}
+const limiteDe = (lista, chave, nome) => lista.find(x => x[chave] === nome)?.sessoes ?? null;
+/**
+ * Cabe mais esta sessão? Todos os limites ao mesmo tempo, na ordem: leitura completa, conta e runtime autorizados,
+ * o projeto (o portão do `phase run`, que o chamador consulta para a thread), a máquina, a margem de revisão (a
+ * execução não usa os slots reservados ao CHECK), a conta e o runtime.
+ */
+function admitir(pedido, limites, fatos, vagaDoProjeto) {
+    if (fatos.lacunas.length) {
+        return { ok: false, motivo: 'capacidade.fonte-indisponivel', detalhe: `sessões sem leitura: ${fatos.lacunas.join('; ')}` };
+    }
+    const limiteDoRuntime = limiteDe(limites.porRuntime, 'runtime', pedido.runtime);
+    if (limiteDoRuntime === null) {
+        return { ok: false, motivo: 'capacidade.runtime-nao-autorizado', detalhe: `o runtime ${pedido.runtime} não está no envelope` };
+    }
+    const limiteDaConta = limiteDe(limites.porConta, 'conta', pedido.conta);
+    if (limiteDaConta === null) {
+        return { ok: false, motivo: 'capacidade.conta-nao-autorizada', detalhe: `a conta ${pedido.conta} não está no envelope` };
+    }
+    if (vagaDoProjeto)
+        return { ok: false, motivo: 'capacidade.projeto', detalhe: vagaDoProjeto.detalhe };
+    const total = fatos.ocupantes.length;
+    if (total >= limites.maquina) {
+        return { ok: false, motivo: 'capacidade.maquina', detalhe: `${total} sessão(ões) nesta máquina e o limite do envelope é ${limites.maquina}` };
+    }
+    const execucao = fatos.ocupantes.filter(o => !o.revisao).length;
+    if (!pedido.revisao && execucao >= limites.maquina - limites.revisao) {
+        return { ok: false, motivo: 'capacidade.revisao', detalhe: `${execucao} sessão(ões) de execução e ${limites.revisao} slot(s) ` +
+                `reservado(s) à revisão de ${limites.maquina}: só o CHECK usa o que sobra` };
+    }
+    const naConta = fatos.ocupantes.filter(o => o.conta === pedido.conta).length;
+    if (naConta >= limiteDaConta) {
+        return { ok: false, motivo: 'capacidade.conta', detalhe: `${naConta} sessão(ões) na conta ${pedido.conta} e o limite é ${limiteDaConta}` };
+    }
+    const noRuntime = fatos.ocupantes.filter(o => o.runtime === pedido.runtime).length;
+    if (noRuntime >= limiteDoRuntime) {
+        return { ok: false, motivo: 'capacidade.runtime', detalhe: `${noRuntime} sessão(ões) no ${pedido.runtime} e o limite é ${limiteDoRuntime}` };
+    }
+    return { ok: true };
+}
+/**
+ * A conta do despacho: entre as do envelope que são perfis do runtime (`perfisDoRuntime`, do store de contas), a com
+ * mais folga no limite dela; empate pela ordem do envelope. `null` quando nenhuma tem vaga.
+ */
+function escolherConta(limites, fatos, perfisDoRuntime) {
+    let melhor = null;
+    for (const { conta, sessoes } of limites.porConta) {
+        if (!perfisDoRuntime.includes(conta))
+            continue;
+        const folga = sessoes - fatos.ocupantes.filter(o => o.conta === conta).length;
+        if (folga > 0 && (!melhor || folga > melhor.folga))
+            melhor = { conta, folga };
+    }
+    return melhor?.conta ?? null;
+}

package/dist/noctum-changelog.js

@@ -0,0 +1,399 @@
+"use strict";
+/**
+ * RM-058, fatia N5 (D4 e D5 da ork-rm058n5): o CHANGELOG e os conflitos só aditivos da atualização do candidato.
+ *
+ * Nas noites de 11 a 13/10 a `main` andou várias vezes, e cada PR precisou de merge da base com conflito só aditivo no
+ * `CHANGELOG.md` (às vezes no código). Depois de uma versão, o merge ainda pôs a linha da thread dentro de `## [versão]`,
+ * logo abaixo de um "Não publicado" vazio, sem conflito textual nenhum. Aqui mora a regra que o núcleo aplica sozinho:
+ *
+ * - um conflito diff3 é só aditivo quando a seção do ancestral comum está vazia, ou é prefixo (ou sufixo) dos dois lados
+ *   sem mudança; ele vira a união, com o lado da base de destino primeiro e o da thread depois. Qualquer outro conflito, ou
+ *   marcador fora do formato, é recusa: o núcleo não escolhe por ninguém;
+ * - a entrada da thread é o bloco novo em "Não publicado" do lado da thread desde o ancestral comum; depois do merge, a que
+ *   caiu numa seção de versão que, na base, não a tem volta para "Não publicado", na subseção de origem;
+ * - a regra do `core/scripts/checar-changelog.cjs` (que não vai no pacote) está portada aqui para a prova da entrega.
+ *
+ * Puro: texto entra, texto sai. Quem lê o git e grava o merge é `noctum-entrega.ts`; quem recomputa um merge para saber se
+ * ele foi mecânico é `noctum-provas.ts`. As duas usam estas mesmas funções, então a recomputação reproduz a atualização.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARQUIVO_DO_CHANGELOG = exports.SECAO_NAO_PUBLICADO = void 0;
+exports.blocosNaoPublicados = blocosNaoPublicados;
+exports.entradasDaThread = entradasDaThread;
+exports.resolverConflitosAditivos = resolverConflitosAditivos;
+exports.posicionarEntradas = posicionarEntradas;
+exports.linhasRemovidas = linhasRemovidas;
+exports.linhasDaBasePerdidas = linhasDaBasePerdidas;
+exports.ehTeste = ehTeste;
+exports.pedeLinha = pedeLinha;
+exports.linhasDaSecao = linhasDaSecao;
+exports.versoes = versoes;
+exports.conferirChangelog = conferirChangelog;
+exports.SECAO_NAO_PUBLICADO = '## Não publicado';
+exports.ARQUIVO_DO_CHANGELOG = 'CHANGELOG.md';
+/**
+ * As linhas como estão, sem converter CRLF (B3 da rodada 1 do CHECK): a resolução não pode mudar a quebra de linha de quem
+ * não conflitou. A linha em branco é a que só tem espaço (`branca`), com ou sem o `\r`.
+ */
+const linhasDe = (texto) => texto.split('\n');
+const branca = (l) => l !== undefined && l.trim() === '';
+const chaveDoBloco = (b) => b.linhas.join('\n');
+const titulo = (linha) => /^## /.test(linha);
+const subtitulo = (linha) => /^### /.test(linha);
+const continuacao = (linha) => /^\s+\S/.test(linha);
+/** As seções de nível 2, com o índice da linha do título e o fim exclusivo (o título seguinte, ou o fim do texto). */
+function secoes(linhas) {
+    const s = [];
+    linhas.forEach((l, i) => {
+        if (!titulo(l))
+            return;
+        if (s.length)
+            s[s.length - 1].fim = i;
+        s.push({ titulo: l.trim(), inicio: i, fim: linhas.length });
+    });
+    return s;
+}
+/** Os blocos de uma seção, com a posição de cada um. */
+function blocosComPosicao(linhas, secao) {
+    const blocos = [];
+    let subsecao = null;
+    for (let i = secao.inicio + 1; i < secao.fim; i++) {
+        const l = linhas[i];
+        if (subtitulo(l)) {
+            subsecao = l.trim();
+            continue;
+        }
+        if (!/^- /.test(l))
+            continue;
+        let j = i + 1;
+        while (j < secao.fim && continuacao(linhas[j]))
+            j++;
+        blocos.push({ linhas: linhas.slice(i, j), subsecao, inicio: i });
+        i = j - 1;
+    }
+    return blocos;
+}
+const secaoNaoPublicada = (linhas) => secoes(linhas).find(s => s.titulo === exports.SECAO_NAO_PUBLICADO) ?? null;
+/** Os blocos da seção "Não publicado", ou `null` quando ela não existe. */
+function blocosNaoPublicados(texto) {
+    const linhas = linhasDe(texto);
+    const s = secaoNaoPublicada(linhas);
+    return s ? blocosComPosicao(linhas, s).map(({ linhas: l, subsecao }) => ({ linhas: l, subsecao })) : null;
+}
+/**
+ * D5: as entradas que a thread acrescentou em "Não publicado": os blocos de `depois` que `antes` não tinha na mesma seção,
+ * contados como multiconjunto (um bloco repetido que já existia não conta como novo), na ordem em que aparecem.
+ */
+function entradasDaThread(antes, depois) {
+    const naBase = new Map();
+    for (const b of blocosNaoPublicados(antes) ?? [])
+        naBase.set(chaveDoBloco(b), (naBase.get(chaveDoBloco(b)) ?? 0) + 1);
+    const novas = [];
+    for (const b of blocosNaoPublicados(depois) ?? []) {
+        const n = naBase.get(chaveDoBloco(b)) ?? 0;
+        if (n > 0)
+            naBase.set(chaveDoBloco(b), n - 1);
+        else
+            novas.push(b);
+    }
+    return novas;
+}
+// ---------------------------------------------------------------------------
+// D4: conflitos diff3 só aditivos.
+// ---------------------------------------------------------------------------
+const INICIO = /^<{7}(?: |\r?$)/;
+const ANCESTRAL = /^\|{7}(?: |\r?$)/;
+const MEIO = /^={7}\r?$/;
+const FIM = /^>{7}(?: |\r?$)/;
+const marcador = (l) => INICIO.test(l) || ANCESTRAL.test(l) || MEIO.test(l) || FIM.test(l);
+const comeca = (a, p) => p.every((l, i) => a[i] === l);
+const termina = (a, s) => s.every((l, i) => a[a.length - s.length + i] === l);
+/**
+ * Um conflito: `primeiro` é o lado do HEAD do merge (a thread), `segundo` o lado que entra (a base de destino) e
+ * `ancestral` a seção do ancestral comum. Só aditivo: a união, com a base primeiro; senão, `null`.
+ */
+function unir(primeiro, ancestral, segundo) {
+    if (ancestral.length === 0)
+        return [...segundo, ...primeiro];
+    const n = ancestral.length;
+    if (primeiro.length >= n && segundo.length >= n && comeca(primeiro, ancestral) && comeca(segundo, ancestral)) {
+        return [...ancestral, ...segundo.slice(n), ...primeiro.slice(n)];
+    }
+    if (primeiro.length >= n && segundo.length >= n && termina(primeiro, ancestral) && termina(segundo, ancestral)) {
+        return [...segundo.slice(0, segundo.length - n), ...primeiro.slice(0, primeiro.length - n), ...ancestral];
+    }
+    return null;
+}
+/**
+ * D4: resolve os conflitos diff3 de um arquivo (os marcadores `<<<<<<<`, `|||||||`, `=======` e `>>>>>>>` do
+ * `merge.conflictStyle=diff3`). Só aditivo vira a união; o conflito que muda linha do ancestral, o conflito sem a seção do
+ * ancestral (outro estilo de merge) e o marcador fora do formato voltam como recusa, com o motivo.
+ */
+function resolverConflitosAditivos(texto) {
+    const saida = [];
+    let estado = 'fora';
+    let primeiro = [], ancestral = [], segundo = [];
+    let conflitos = 0;
+    const recusa = (motivo, n) => ({ ok: false, recusa: `${motivo} (linha ${n + 1})` });
+    const linhas = linhasDe(texto);
+    for (let i = 0; i < linhas.length; i++) {
+        const l = linhas[i];
+        if (estado === 'fora') {
+            if (INICIO.test(l)) {
+                estado = 'primeiro';
+                primeiro = [];
+                ancestral = [];
+                segundo = [];
+                continue;
+            }
+            if (marcador(l))
+                return recusa('marcador de conflito fora do formato', i);
+            saida.push(l);
+        }
+        else if (estado === 'primeiro') {
+            if (ANCESTRAL.test(l)) {
+                estado = 'ancestral';
+                continue;
+            }
+            if (marcador(l))
+                return recusa('conflito sem a seção do ancestral comum (o merge precisa de merge.conflictStyle=diff3)', i);
+            primeiro.push(l);
+        }
+        else if (estado === 'ancestral') {
+            if (MEIO.test(l)) {
+                estado = 'segundo';
+                continue;
+            }
+            if (marcador(l))
+                return recusa('marcador de conflito fora do formato', i);
+            ancestral.push(l);
+        }
+        else {
+            if (FIM.test(l)) {
+                const unido = unir(primeiro, ancestral, segundo);
+                if (!unido)
+                    return recusa('conflito que muda linha do ancestral comum: não é só aditivo', i);
+                saida.push(...unido);
+                conflitos += 1;
+                estado = 'fora';
+                continue;
+            }
+            if (marcador(l))
+                return recusa('marcador de conflito fora do formato', i);
+            segundo.push(l);
+        }
+    }
+    if (estado !== 'fora')
+        return recusa('conflito sem o marcador de fim', linhas.length - 1);
+    return { ok: true, texto: saida.join('\n'), conflitos };
+}
+// ---------------------------------------------------------------------------
+// D5: a entrada da thread em "Não publicado".
+// ---------------------------------------------------------------------------
+/** O índice da primeira linha de cada ocorrência do bloco como item inteiro (nem pedaço de outro item, nem prefixo). */
+function ocorrencias(linhas, bloco) {
+    const achadas = [];
+    for (let i = 0; i + bloco.linhas.length <= linhas.length; i++) {
+        if (!bloco.linhas.every((l, k) => linhas[i + k] === l))
+            continue;
+        const depois = linhas[i + bloco.linhas.length];
+        if (depois !== undefined && continuacao(depois))
+            continue;
+        achadas.push(i);
+    }
+    return achadas;
+}
+/** A seção que contém a linha `i`, ou `null` quando ela vem antes da primeira seção. */
+const secaoDaLinha = (s, i) => s.find(x => i > x.inicio && i < x.fim) ?? null;
+/** A versão é seção de versão? `## [0.5.0] - 2026-09-30` e o formato antigo `## 0.4.3`, sem colchetes. */
+const ehVersao = (t) => /^## \[?\d+\.\d+\.\d+/.test(t);
+/**
+ * D5: põe em "Não publicado" as entradas da thread que caíram numa seção de versão que, em `daBase` (o CHANGELOG da base de
+ * destino), não tem o mesmo bloco. A entrada volta para a subseção de origem (criada no alto da seção quando falta), e
+ * "Não publicado" é criada antes da primeira versão quando falta. O subtítulo que fica vazio na versão e que a base não tem
+ * sai junto. Entrada que já está em "Não publicado" não muda; a que sumiu conta em `perdidas`.
+ */
+function posicionarEntradas(texto, entradas, daBase) {
+    const linhas = linhasDe(texto);
+    const base = linhasDe(daBase);
+    const naBase = new Map();
+    for (const s of secoes(base)) {
+        naBase.set(s.titulo, new Set(blocosComPosicao(base, s).map(chaveDoBloco)));
+    }
+    const subtitulosDaBase = new Map();
+    for (const s of secoes(base)) {
+        subtitulosDaBase.set(s.titulo, new Set(base.slice(s.inicio + 1, s.fim).filter(subtitulo).map(l => l.trim())));
+    }
+    let movidas = 0, perdidas = 0;
+    for (const e of entradas) {
+        const s = secoes(linhas);
+        const achadas = ocorrencias(linhas, e);
+        if (!achadas.length) {
+            perdidas += 1;
+            continue;
+        }
+        if (achadas.some(i => secaoDaLinha(s, i)?.titulo === exports.SECAO_NAO_PUBLICADO))
+            continue;
+        const fora = achadas.find(i => {
+            const sec = secaoDaLinha(s, i);
+            return !!sec && ehVersao(sec.titulo) && !naBase.get(sec.titulo)?.has(chaveDoBloco(e));
+        });
+        if (fora === undefined)
+            continue;
+        const sec = secaoDaLinha(s, fora);
+        // Tira o bloco e a linha em branco que sobraria dobrada.
+        linhas.splice(fora, e.linhas.length);
+        if (branca(linhas[fora]) && (fora === 0 || branca(linhas[fora - 1])))
+            linhas.splice(fora, 1);
+        // O subtítulo que ficou sem nada na versão, e que a base não tem nela, era da thread: sai também.
+        const subAcima = (() => { for (let k = fora - 1; k > sec.inicio; k--) {
+            if (subtitulo(linhas[k]))
+                return k;
+            if (/^- /.test(linhas[k]) || continuacao(linhas[k]))
+                return -1;
+        } return -1; })();
+        if (subAcima > 0) {
+            let k = subAcima + 1;
+            while (k < linhas.length && branca(linhas[k]))
+                k++;
+            const vazio = k >= linhas.length || titulo(linhas[k]) || subtitulo(linhas[k]);
+            if (vazio && !subtitulosDaBase.get(sec.titulo)?.has(linhas[subAcima].trim())) {
+                linhas.splice(subAcima, branca(linhas[subAcima + 1]) ? 2 : 1);
+            }
+        }
+        inserirEmNaoPublicado(linhas, e);
+        movidas += 1;
+    }
+    return { texto: linhas.join('\n'), movidas, perdidas };
+}
+/** Insere o bloco no alto da subseção de origem dele em "Não publicado", criando a seção e a subseção quando faltam. */
+function inserirEmNaoPublicado(linhas, e) {
+    let s = secaoNaoPublicada(linhas);
+    if (!s) {
+        const primeiraVersao = secoes(linhas).find(x => ehVersao(x.titulo));
+        const onde = primeiraVersao ? primeiraVersao.inicio : linhas.length;
+        const antes = onde > 0 && !branca(linhas[onde - 1]) ? [''] : [];
+        linhas.splice(onde, 0, ...antes, exports.SECAO_NAO_PUBLICADO, '');
+        s = secaoNaoPublicada(linhas);
+    }
+    // Depois do título da seção (e da linha em branco dele, que é criada quando falta).
+    if (!branca(linhas[s.inicio + 1]))
+        linhas.splice(s.inicio + 1, 0, '');
+    s = secaoNaoPublicada(linhas);
+    let alvo = s.inicio + 2;
+    if (e.subsecao !== null) {
+        const h = linhas.slice(s.inicio + 1, s.fim).findIndex(l => l.trim() === e.subsecao);
+        if (h < 0) {
+            linhas.splice(s.inicio + 2, 0, e.subsecao, '');
+            alvo = s.inicio + 4;
+        }
+        else {
+            const k = s.inicio + 1 + h;
+            if (!branca(linhas[k + 1]))
+                linhas.splice(k + 1, 0, '');
+            alvo = k + 2;
+        }
+    }
+    linhas.splice(alvo, 0, ...e.linhas, '');
+}
+/** As linhas de texto de `antes` que `depois` não tem mais (multiconjunto, sem as linhas em branco). */
+function linhasRemovidas(antes, depois) {
+    const restantes = new Map();
+    for (const l of linhasDe(depois))
+        if (l.trim())
+            restantes.set(l, (restantes.get(l) ?? 0) + 1);
+    const removidas = [];
+    for (const l of linhasDe(antes)) {
+        if (!l.trim())
+            continue;
+        const n = restantes.get(l) ?? 0;
+        if (n > 0)
+            restantes.set(l, n - 1);
+        else
+            removidas.push(l);
+    }
+    return removidas;
+}
+/**
+ * As linhas de texto da base que o resultado não tem mais (multiconjunto, sem as linhas em branco), fora as que a própria
+ * thread tirou desde o ancestral comum (`daThread`, A3 da rodada 1): a correção de uma linha antiga não é perda.
+ */
+function linhasDaBasePerdidas(daBase, resultado, daThread = []) {
+    const permitidas = new Map();
+    for (const l of daThread)
+        permitidas.set(l, (permitidas.get(l) ?? 0) + 1);
+    return linhasRemovidas(daBase, resultado).filter(l => {
+        const n = permitidas.get(l) ?? 0;
+        if (n > 0) {
+            permitidas.set(l, n - 1);
+            return false;
+        }
+        return true;
+    });
+}
+// ---------------------------------------------------------------------------
+// A regra do checador do CHANGELOG (core/scripts/checar-changelog.cjs), portada.
+// ---------------------------------------------------------------------------
+const PASTAS_DE_PRODUTO = ['core/', 'adapters/', 'marketplaces/'];
+const DE_CI = [/^\.github\//, /^\.ork-ci\//, /^core\/scripts\/test-ci\.js$/, /^core\/scripts\/checar-[a-z0-9-]+\.cjs$/];
+/** Arquivo de teste: pasta `test`, `tests` ou `__tests__` no caminho, ou nome `*.test.*`/`*.spec.*`. */
+function ehTeste(arquivo) {
+    const partes = arquivo.split('/');
+    return partes.slice(0, -1).some(p => p === 'test' || p === 'tests' || p === '__tests__')
+        || /\.(test|spec)\.[A-Za-z0-9]+$/.test(partes[partes.length - 1]);
+}
+/** Arquivo que pede linha no CHANGELOG: dentro das pastas do produto, fora de teste e de CI. */
+function pedeLinha(arquivo) {
+    return PASTAS_DE_PRODUTO.some(p => arquivo.startsWith(p)) && !ehTeste(arquivo) && !DE_CI.some(re => re.test(arquivo));
+}
+/** As linhas de texto da seção "Não publicado" (sem título e sem linha em branco); `null` sem a seção. */
+function linhasDaSecao(texto) {
+    const linhas = linhasDe(texto);
+    const inicio = linhas.findIndex(l => l.trim() === exports.SECAO_NAO_PUBLICADO);
+    if (inicio < 0)
+        return null;
+    const corpo = [];
+    for (const linha of linhas.slice(inicio + 1)) {
+        if (/^## /.test(linha))
+            break;
+        if (linha.trim() && !/^#/.test(linha.trim()))
+            corpo.push(linha.trimEnd());
+    }
+    return corpo;
+}
+/** As versões do CHANGELOG, nos dois formatos que ele já teve. */
+function versoes(texto) {
+    return new Set([...texto.replace(/\r\n/g, '\n').matchAll(/^## \[?(\d+\.\d+\.\d+[0-9A-Za-z.+-]*)\]?(?=\s|$)/gm)].map(m => m[1]));
+}
+/**
+ * A regra do job `documentacao`: o diff que muda `core/`, `adapters/` ou `marketplaces/` (fora de teste e de CI) acrescenta
+ * ao menos uma linha em "Não publicado" ou abre uma versão nova. `antes` é o CHANGELOG no ancestral comum com a base;
+ * `depois`, o da fonte; `arquivos`, os caminhos que a fonte muda desde esse ancestral.
+ */
+function conferirChangelog(antes, depois, arquivos) {
+    const pedem = arquivos.filter(pedeLinha);
+    if (!pedem.length)
+        return { ok: true, detalhe: 'nada pede linha: a mudança não toca core/, adapters/ nem marketplaces/ fora de teste e CI', linhas: [] };
+    const nova = [...versoes(depois)].filter(v => !versoes(antes).has(v));
+    if (nova.length)
+        return { ok: true, detalhe: `versão nova no CHANGELOG: ${nova.join(', ')}`, linhas: [] };
+    const secao = linhasDaSecao(depois);
+    if (secao === null)
+        return { ok: false, motivo: 'changelog.secao-ausente', detalhe: `o CHANGELOG não tem a seção "${exports.SECAO_NAO_PUBLICADO}"` };
+    const naBase = new Map();
+    for (const l of linhasDaSecao(antes) ?? [])
+        naBase.set(l, (naBase.get(l) ?? 0) + 1);
+    const novas = [];
+    for (const l of secao) {
+        const n = naBase.get(l) ?? 0;
+        if (n > 0)
+            naBase.set(l, n - 1);
+        else
+            novas.push(l);
+    }
+    if (novas.length)
+        return { ok: true, detalhe: `${novas.length} linha(s) nova(s) em "${exports.SECAO_NAO_PUBLICADO}"`, linhas: novas };
+    return { ok: false, motivo: 'changelog.linha-ausente',
+        detalhe: `a mudança toca ${pedem.length} arquivo(s) do produto (${pedem.slice(0, 3).join(', ')}${pedem.length > 3 ? ', ...' : ''}) ` +
+            `e não acrescenta linha em "${exports.SECAO_NAO_PUBLICADO}"` };
+}