@orkastery/cli 0.5.6 → 0.6.1

package/dist/dado-privado.js

@@ -0,0 +1,816 @@
+"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.PADROES_GENERICOS = exports.OMITIDO = exports.MENOR_TERMO = exports.VARIAVEL_DA_LISTA_LOCAL = exports.ARQUIVO_DA_LISTA_LOCAL = exports.ARQUIVO_DAS_EXCECOES = exports.CONTRATO_DA_VARREDURA = exports.CONTRATO_DAS_EXCECOES = void 0;
+exports.lerExcecoes = lerExcecoes;
+exports.lerListaLocal = lerListaLocal;
+exports.contextoDaVarredura = contextoDaVarredura;
+exports.varreduraComErro = varreduraComErro;
+exports.varrerArvore = varrerArvore;
+exports.varrerDiff = varrerDiff;
+exports.varrerTexto = varrerTexto;
+exports.juntarVarreduras = juntarVarreduras;
+exports.mergeBase = mergeBase;
+exports.baseDaThread = baseDaThread;
+exports.linhaDoAchado = linhaDoAchado;
+exports.textoDoEscopo = textoDoEscopo;
+exports.textoDaListaLocal = textoDaListaLocal;
+exports.relatorioDoDadoPrivado = relatorioDoDadoPrivado;
+exports.ondeDoAchado = ondeDoAchado;
+exports.fatosDaVarredura = fatosDaVarredura;
+exports.resumoNoLedger = resumoNoLedger;
+exports.barreiraDaThread = barreiraDaThread;
+/**
+ * RM-062 (F1 e F2): a barreira de dado privado do repositório público.
+ *
+ * Nada privado do dono entra no repositório: nem em linha, nem em nome de arquivo, nem no bundle de CI. A varredura
+ * procura três padrões genéricos (caminho de home, e-mail fora da lista permitida e hostname no formato de máquina) e
+ * os termos de uma lista local que mora fora do git. O relatório diz arquivo, linha, coluna e o nome do padrão, nunca
+ * o valor casado: relatório que repete o termo é um segundo vazamento (a mesma regra de `procurarSegredos`).
+ *
+ * - O que é exemplo inventado entra nas exceções versionadas (`orkastery.privado.json`), revisadas em PR (D4).
+ * - A lista local (`termos-privados.txt`) fica na pasta do usuário do `ork` e na `.orkastery/` do projeto, ou no
+ *   caminho de `ORK_TERMOS_PRIVADOS` (D5). Ausente, como no CI, os padrões genéricos continuam valendo, e a saída diz.
+ * - Exceção nunca vale para a lista local.
+ * - Nome de arquivo também é conteúdo: o caminho de um arquivo com achado no nome sai com o trecho trocado por
+ *   `[omitido]` em todo lugar onde aparece (D8).
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const util_1 = require("./util");
+const maquina_1 = require("./maquina");
+const estado_thread_1 = require("./estado-thread");
+const policies_1 = require("./policies");
+exports.CONTRATO_DAS_EXCECOES = 'ork.privado/v1';
+exports.CONTRATO_DA_VARREDURA = 'ork.privado-varredura/v1';
+/** O arquivo versionado de exceções e e-mails permitidos, na raiz do repositório. */
+exports.ARQUIVO_DAS_EXCECOES = 'orkastery.privado.json';
+/** O nome do arquivo da lista local, na pasta do usuário do `ork` e na `.orkastery/` do projeto. */
+exports.ARQUIVO_DA_LISTA_LOCAL = 'termos-privados.txt';
+/** Com ela, a lista local é só o arquivo que ela aponta. */
+exports.VARIAVEL_DA_LISTA_LOCAL = 'ORK_TERMOS_PRIVADOS';
+/** Termo mais curto que isso casaria em quase toda linha: é ignorado e contado. */
+exports.MENOR_TERMO = 3;
+exports.OMITIDO = '[omitido]';
+exports.PADROES_GENERICOS = ['home', 'email', 'hostname'];
+// ---------------------------------------------------------------------------
+// Os padrões genéricos (D9)
+// ---------------------------------------------------------------------------
+/**
+ * Caminho de home: `/home/<usuário>` e `/Users/<usuário>`, também escapado (`\/home\/x` numa regex, `\\/home\\/x` no
+ * JSON dela), `/var/home/<usuário>` e `C:\Users\<usuário>`. O usuário aceita letra com acento; o marcador `<usuário>`
+ * não casa. Colado a letra, dígito ou ponto (`https://site.com/home/pagina`, `app/home/page.tsx`, a casa falsa em
+ * `/tmp/ensaio/home/x`), é trecho de URL ou de outro caminho.
+ */
+const HOME = /(?:(?<=\/var)|(?<![\p{L}\p{N}._-]))(?:\\*\/)+(home|Users)(?:\\*\/)+([\p{L}\p{N}._-]+)|\b([A-Za-z]):\\{1,2}Users\\{1,2}([\p{L}\p{N}._-]+)/gu;
+/** Usuários de sistema e marcadores que não dizem de quem é a máquina. */
+const USUARIOS_GENERICOS = new Set(['user', 'usuario', 'usuário', 'username', 'runner', 'ubuntu', 'node', 'git']);
+/**
+ * E-mail: o endereço inteiro, com domínio de letras. O lookbehind tira o que vem logo depois de `\` (o `\n@app.get`
+ * de um JSON), de `@` e do meio de outro endereço. `/` e `:` são prefixos válidos; credenciais de URL são
+ * reconhecidas pela autoridade completa, não pelo caractere anterior.
+ */
+const EMAIL = /(?<![A-Za-z0-9._%+\-\\@])([A-Za-z0-9._%+-]+)@((?:[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?\.)+[A-Za-z]{2,63})(?![A-Za-z0-9-])/g;
+/** RFC 2606 e RFC 6761: domínios reservados para exemplo e teste. */
+const DOMINIOS_DE_EXEMPLO = ['example.com', 'example.net', 'example.org'];
+const TLDS_DE_EXEMPLO = new Set(['example', 'invalid', 'test', 'localhost']);
+/** Hostname no formato de máquina: o hostname que não segue formato nenhum é da lista local. */
+const HOSTNAMES = [
+    // Nome de máquina pessoal: `<nome>-pc`, `<nome>-laptop`, `<nome>-macbook-pro`... (os exemplos daqui usam marcador,
+    // para o comentário não casar com a própria regra).
+    /\b[a-z0-9]+(?:-[a-z0-9]+)*-(?:pc|laptop|desktop|notebook|workstation|thinkpad|macbook(?:-pro|-air)?|imac|mac-mini|mac-studio)\b/gi,
+    // Padrões de fábrica do Windows.
+    /\b(?:DESKTOP|LAPTOP)-[A-Z0-9]{6,10}\b/g,
+    /\bWIN-[A-Z0-9]{8,15}\b/g,
+    // AWS (`ip-` com os quatro números do IP), VPS (`vps-` com 8 hexadecimais, `srv` ou `vmi` com 5 dígitos ou mais) e
+    // DigitalOcean (`ubuntu-s-` com o tamanho da máquina).
+    /\bip-(?:\d{1,3}-){3}\d{1,3}\b/g,
+    /\bvps-[0-9a-f]{8}\b/gi,
+    /\b(?:srv|vmi)\d{5,}\b/gi,
+    /\bubuntu-s-\d+vcpu-\d+gb-[a-z0-9-]+\b/gi,
+    // O formato `srv` + letras + dígitos (o nome de servidor com as iniciais de alguém).
+    /\bsrv[a-z]{2,10}\d{1,4}\b/gi,
+];
+function escaparRegex(texto) {
+    return texto.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** Glob de caminho: `**` cruza pastas, `*` e `?` não. */
+function globCasa(glob, caminho) {
+    let re = '';
+    for (let i = 0; i < glob.length; i++) {
+        const c = glob[i];
+        if (c === '*' && glob[i + 1] === '*') {
+            if (glob[i + 2] === '/') {
+                re += '(?:.*/)?';
+                i += 2;
+            }
+            else {
+                re += '.*';
+                i += 1;
+            }
+        }
+        else if (c === '*')
+            re += '[^/]*';
+        else if (c === '?')
+            re += '[^/]';
+        else
+            re += escaparRegex(c);
+    }
+    return new RegExp(`^${re}$`, 'u').test(caminho);
+}
+function caminhoEquivaleACuringaGlobal(caminho) {
+    return ['arquivo.txt', 'pasta/arquivo.txt', 'pasta/interna/arquivo.txt'].every((amostra) => globCasa(caminho, amostra));
+}
+function emailDeExemplo(dominio) {
+    const d = dominio.toLowerCase();
+    if (DOMINIOS_DE_EXEMPLO.some((e) => d === e || d.endsWith(`.${e}`)))
+        return true;
+    return TLDS_DE_EXEMPLO.has(d.slice(d.lastIndexOf('.') + 1));
+}
+/** O endereço começa na autoridade de uma URL, antes do caminho, query, fragmento ou delimitador do documento. */
+function naAutoridadeDeUrl(texto, inicio) {
+    const antes = texto.slice(Math.max(0, inicio - 512), inicio);
+    const separador = antes.lastIndexOf('://');
+    if (separador < 0)
+        return false;
+    const prefixo = antes.slice(0, separador);
+    if (!/(?:^|[^a-z0-9+.-])[a-z][a-z0-9+.-]*$/i.test(prefixo))
+        return false;
+    const autoridade = antes.slice(separador + 3);
+    return !/[\s/?#"'<>\[\]{},;`()|]/u.test(autoridade);
+}
+/** Os casamentos dos padrões genéricos e da lista local num texto, antes das exceções. */
+function casamentos(texto, termos) {
+    const achados = [];
+    for (const m of texto.matchAll(HOME)) {
+        const raizDoCaminho = m[1] ?? null;
+        const usuario = (m[2] ?? m[4] ?? '').replace(/[._-]+$/, '');
+        // Pasta oculta direto na raiz das casas (`/home/.cache`) não é usuário.
+        if (!usuario || usuario.startsWith('.') || USUARIOS_GENERICOS.has(usuario.toLowerCase()))
+            continue;
+        const valor = raizDoCaminho ? `/${raizDoCaminho}/${usuario}` : `${m[3]}:\\Users\\${usuario}`;
+        achados.push({ inicio: m.index, fim: m.index + m[0].length, padrao: 'home', valor });
+    }
+    for (const m of texto.matchAll(EMAIL)) {
+        const inicio = m.index;
+        // Na autoridade de uma URL (`ssh://x=u@host/`, `git+ssh://u:1#t@host/`), o `@` separa a credencial do host.
+        if (naAutoridadeDeUrl(texto, inicio))
+            continue;
+        // `git@host` e `usuario@host:caminho` são remotos SSH, não o endereço de alguém.
+        const depois = texto.slice(inicio + m[0].length, inicio + m[0].length + 2);
+        if (m[1].toLowerCase() === 'git' || /^:[^\s]/.test(depois))
+            continue;
+        if (emailDeExemplo(m[2]))
+            continue;
+        achados.push({ inicio, fim: inicio + m[0].length, padrao: 'email', valor: m[0] });
+    }
+    for (const re of HOSTNAMES) {
+        for (const m of texto.matchAll(re)) {
+            achados.push({ inicio: m.index, fim: m.index + m[0].length, padrao: 'hostname', valor: m[0] });
+        }
+    }
+    termos.forEach((termo, i) => {
+        for (const m of texto.matchAll(termo)) {
+            achados.push({ inicio: m.index, fim: m.index + m[0].length, padrao: 'lista-local', valor: m[0], termo: i + 1 });
+        }
+    });
+    // O mesmo trecho achado por dois padrões de hostname conta uma vez.
+    const vistos = new Set();
+    return achados.filter((a) => {
+        const chave = `${a.inicio}:${a.padrao}:${a.termo ?? ''}`;
+        if (vistos.has(chave))
+            return false;
+        vistos.add(chave);
+        return true;
+    }).sort((a, b) => a.inicio - b.inicio || a.fim - b.fim);
+}
+// ---------------------------------------------------------------------------
+// As exceções versionadas (D4)
+// ---------------------------------------------------------------------------
+/** O uso das exceções numa varredura, para dizer as que não cobriram nada. */
+class UsoDasExcecoes {
+    excecoes = new Set();
+    emails = new Set();
+}
+/**
+ * Lê o `orkastery.privado.json` da raiz. Ausente, nenhuma exceção (só as regras do código). Fora do contrato, o erro
+ * com o motivo: a varredura não roda com exceção que ninguém sabe o que cobre.
+ */
+function lerExcecoes(raiz) {
+    const arquivo = path.join(raiz, exports.ARQUIVO_DAS_EXCECOES);
+    if (!fs.existsSync(arquivo))
+        return { ok: true, valor: { presente: false, emailsPermitidos: [], excecoes: [] } };
+    const fora = (motivo) => ({ ok: false, erro: `${exports.ARQUIVO_DAS_EXCECOES} fora do contrato ${exports.CONTRATO_DAS_EXCECOES}: ${motivo}` });
+    let bruto;
+    try {
+        bruto = JSON.parse(fs.readFileSync(arquivo, 'utf8'));
+    }
+    catch (e) {
+        return fora(`não é JSON (${e.message})`);
+    }
+    if (!bruto || typeof bruto !== 'object' || Array.isArray(bruto))
+        return fora('a raiz não é um objeto');
+    const objeto = bruto;
+    const estranhas = Object.keys(objeto).filter((k) => !['contrato', 'descricao', 'emailsPermitidos', 'excecoes'].includes(k));
+    if (estranhas.length)
+        return fora(`chave desconhecida: ${estranhas.join(', ')}`);
+    if (objeto.contrato !== exports.CONTRATO_DAS_EXCECOES)
+        return fora(`"contrato" tem de ser "${exports.CONTRATO_DAS_EXCECOES}"`);
+    if (objeto.descricao !== undefined && typeof objeto.descricao !== 'string')
+        return fora('"descricao" tem de ser texto');
+    const emails = objeto.emailsPermitidos ?? [];
+    if (!Array.isArray(emails))
+        return fora('"emailsPermitidos" tem de ser uma lista');
+    const emailsPermitidos = [];
+    for (const [i, e] of emails.entries()) {
+        if (!e || typeof e !== 'object' || Array.isArray(e))
+            return fora(`emailsPermitidos[${i}] não é um objeto`);
+        const x = e;
+        const outras = Object.keys(x).filter((k) => !['valor', 'motivo'].includes(k));
+        if (outras.length)
+            return fora(`emailsPermitidos[${i}] tem chave desconhecida: ${outras.join(', ')}`);
+        if (typeof x.valor !== 'string' || !/^[^\s@*]+@[^\s@*]+$/.test(x.valor)) {
+            return fora(`emailsPermitidos[${i}].valor tem de ser endereço exato, sem curinga`);
+        }
+        if (typeof x.motivo !== 'string' || !x.motivo.trim())
+            return fora(`emailsPermitidos[${i}] sem motivo`);
+        emailsPermitidos.push({ valor: x.valor, motivo: x.motivo.trim() });
+    }
+    const lista = objeto.excecoes ?? [];
+    if (!Array.isArray(lista))
+        return fora('"excecoes" tem de ser uma lista');
+    const excecoes = [];
+    for (const [i, e] of lista.entries()) {
+        if (!e || typeof e !== 'object' || Array.isArray(e))
+            return fora(`excecoes[${i}] não é um objeto`);
+        const x = e;
+        const outras = Object.keys(x).filter((k) => !['padrao', 'caminho', 'valor', 'motivo'].includes(k));
+        if (outras.length)
+            return fora(`excecoes[${i}] tem chave desconhecida: ${outras.join(', ')}`);
+        if (!exports.PADROES_GENERICOS.includes(x.padrao)) {
+            return fora(`excecoes[${i}].padrao tem de ser ${exports.PADROES_GENERICOS.join(', ')}`);
+        }
+        if (typeof x.motivo !== 'string' || !x.motivo.trim())
+            return fora(`excecoes[${i}] sem motivo`);
+        for (const campo of ['caminho', 'valor']) {
+            if (x[campo] !== undefined && (typeof x[campo] !== 'string' || !x[campo].trim())) {
+                return fora(`excecoes[${i}].${campo} tem de ser texto não vazio`);
+            }
+        }
+        if (x.valor === undefined)
+            return fora(`excecoes[${i}] sem valor`);
+        if (x.valor.includes('*'))
+            return fora(`excecoes[${i}].valor tem de ser exato, sem curinga`);
+        if (x.caminho === '**')
+            return fora(`excecoes[${i}].caminho não pode ser curinga global`);
+        if (x.caminho !== undefined && caminhoEquivaleACuringaGlobal(x.caminho)) {
+            return fora(`excecoes[${i}].caminho equivale a curinga global`);
+        }
+        excecoes.push({ padrao: x.padrao, motivo: x.motivo.trim(), valor: x.valor,
+            ...(x.caminho !== undefined ? { caminho: x.caminho } : {}) });
+    }
+    return { ok: true, valor: { presente: true, emailsPermitidos, excecoes } };
+}
+/** O casamento genérico coberto pela lista de e-mails permitidos ou por uma exceção; marca o uso. */
+function coberto(c, arquivo, excecoes, uso) {
+    if (c.padrao === 'lista-local')
+        return false;
+    if (c.padrao === 'email') {
+        const i = excecoes.emailsPermitidos.findIndex((e) => e.valor.toLowerCase() === c.valor.toLowerCase());
+        if (i >= 0) {
+            uso.emails.add(i);
+            return true;
+        }
+    }
+    const j = excecoes.excecoes.findIndex((e) => e.padrao === c.padrao
+        && (e.caminho === undefined || globCasa(e.caminho, arquivo)) && e.valor.toLowerCase() === c.valor.toLowerCase());
+    if (j >= 0) {
+        uso.excecoes.add(j);
+        return true;
+    }
+    return false;
+}
+// ---------------------------------------------------------------------------
+// A lista local (D5)
+// ---------------------------------------------------------------------------
+/** O arquivo `dentro` da raiz `raiz`, relativo a ela; `null` fora dela. */
+function relativoDentro(raiz, dentro) {
+    let real;
+    let base;
+    try {
+        real = fs.realpathSync(dentro);
+        base = fs.realpathSync(raiz);
+    }
+    catch {
+        return null;
+    }
+    const rel = path.relative(base, real);
+    return rel && !rel.startsWith('..') && !path.isAbsolute(rel) ? rel.split(path.sep).join('/') : null;
+}
+/**
+ * Lê a lista local: com `ORK_TERMOS_PRIVADOS`, só o arquivo dela; sem ela, `termos-privados.txt` da pasta do usuário
+ * do `ork` (`~/.orkastery/`) e da `.orkastery/` da raiz do estado do projeto. Um termo por linha, `#` comenta, sem
+ * diferença de caixa. `raiz` é o repositório varrido: a lista que o git versiona nele volta em `versionados`.
+ */
+function lerListaLocal(raizDoEstado, raiz = null, env = process.env) {
+    const explicita = (env[exports.VARIAVEL_DA_LISTA_LOCAL] ?? '').trim();
+    const rotuloDaPastaDoUsuario = (env.ORK_USUARIO_DIR ?? '').trim()
+        ? `ORK_USUARIO_DIR/${exports.ARQUIVO_DA_LISTA_LOCAL}`
+        : (env.ORKASTERY_HOME ?? '').trim()
+            ? `ORKASTERY_HOME/${exports.ARQUIVO_DA_LISTA_LOCAL}`
+            : `~/.orkastery/${exports.ARQUIVO_DA_LISTA_LOCAL}`;
+    const candidatos = explicita
+        ? [{ arquivo: path.resolve(explicita), rotulo: `arquivo indicado por ${exports.VARIAVEL_DA_LISTA_LOCAL}` }]
+        : [{ arquivo: path.join((0, maquina_1.pastaDoUsuario)(env), exports.ARQUIVO_DA_LISTA_LOCAL), rotulo: rotuloDaPastaDoUsuario },
+            ...(raizDoEstado ? [{ arquivo: path.join(raizDoEstado, '.orkastery', exports.ARQUIVO_DA_LISTA_LOCAL),
+                    rotulo: `.orkastery/${exports.ARQUIVO_DA_LISTA_LOCAL}` }] : [])];
+    const unicos = [...new Map(candidatos.map((c) => [c.arquivo, c])).values()];
+    const termos = [];
+    const lidos = [];
+    const versionados = [];
+    let recusada = null;
+    let ignorados = 0;
+    for (const candidato of unicos) {
+        const { arquivo, rotulo } = candidato;
+        let texto;
+        let fd = null;
+        try {
+            const antes = fs.lstatSync(arquivo);
+            if (antes.isSymbolicLink()) {
+                recusada = `${rotulo} foi recusado: link simbólico não é aceito`;
+                break;
+            }
+            if (!antes.isFile()) {
+                recusada = `${rotulo} foi recusado: não é arquivo comum`;
+                break;
+            }
+            fd = fs.openSync(arquivo, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+            const st = fs.fstatSync(fd);
+            const uid = typeof process.getuid === 'function' ? process.getuid() : null;
+            if (!st.isFile()) {
+                recusada = `${rotulo} foi recusado: não é arquivo comum`;
+                break;
+            }
+            if (uid === null || st.uid !== uid) {
+                recusada = `${rotulo} foi recusado: o dono não é o usuário atual`;
+                break;
+            }
+            if ((st.mode & 0o777) !== 0o600) {
+                recusada = `${rotulo} foi recusado: a permissão tem de ser 0600`;
+                break;
+            }
+            texto = fs.readFileSync(fd, 'utf8');
+        }
+        catch (e) {
+            const code = e.code;
+            if (code === 'ENOENT')
+                continue;
+            recusada = `${rotulo} foi recusado: não foi possível abrir com segurança`;
+            break;
+        }
+        finally {
+            if (fd !== null)
+                fs.closeSync(fd);
+        }
+        lidos.push(rotulo);
+        const rel = raiz ? relativoDentro(raiz, arquivo) : null;
+        if (rel && (0, util_1.exec)('git', ['ls-files', '--error-unmatch', '--', rel], raiz).ok)
+            versionados.push(rel);
+        for (const bruta of texto.split(/\r?\n/)) {
+            const linha = bruta.trim();
+            if (!linha || linha.startsWith('#'))
+                continue;
+            if ([...linha].length < exports.MENOR_TERMO) {
+                ignorados += 1;
+                continue;
+            }
+            const termo = linha.toLowerCase();
+            if (!termos.includes(termo))
+                termos.push(termo);
+        }
+    }
+    return { presente: lidos.length > 0, procurada: unicos.map((c) => c.rotulo), lidos, termos,
+        ignorados, versionados, recusada };
+}
+// ---------------------------------------------------------------------------
+// A varredura
+// ---------------------------------------------------------------------------
+/** O contexto de uma varredura: as exceções da raiz varrida e a lista local. */
+function contextoDaVarredura(raiz, raizDoEstado, env = process.env) {
+    const lista = lerListaLocal(raizDoEstado, raiz, env);
+    const excecoes = lerExcecoes(raiz);
+    if (!excecoes.ok)
+        return { ok: false, erro: excecoes.erro, lista };
+    if (lista.recusada)
+        return { ok: false, erro: lista.recusada, lista };
+    if (lista.versionados.length) {
+        return { ok: false, lista, erro: `a lista local de termos privados está versionada (${lista.versionados.length} arquivo(s)): ` +
+                'tire-a do git; ela nunca vai ao repositório' };
+    }
+    return { ok: true, valor: { raiz, excecoes: excecoes.valor, lista } };
+}
+/** Acumula os achados de uma varredura, com o caminho mascarado e o uso das exceções. */
+class Coletor {
+    contexto;
+    achados = [];
+    uso = new UsoDasExcecoes();
+    arquivos = 0;
+    linhas = 0;
+    nomes = 0;
+    /** Os termos da lista local como regex, compiladas uma vez por varredura. */
+    termos;
+    constructor(contexto) {
+        this.contexto = contexto;
+        this.termos = contexto.lista.termos.map((t) => new RegExp(escaparRegex(t), 'giu'));
+    }
+    /** Os casamentos que valem num texto do arquivo (o nome, uma linha ou o arquivo inteiro), depois das exceções. */
+    validos(texto, arquivo, comGenericos) {
+        return casamentos(texto, this.termos).filter((c) => c.padrao === 'lista-local'
+            || (comGenericos && !coberto(c, arquivo, this.contexto.excecoes, this.uso)));
+    }
+    /**
+     * O caminho para o relatório: cada trecho casado no nome trocado por `[omitido]` (trechos que se encostam viram um
+     * só). Varre o nome uma vez.
+     */
+    caminho(arquivo) {
+        const achados = this.validos(arquivo, arquivo, true);
+        let mostrado = '';
+        let ate = 0;
+        achados.forEach((c, i) => {
+            if (i === 0 || c.inicio > ate)
+                mostrado += arquivo.slice(ate, c.inicio) + exports.OMITIDO;
+            ate = Math.max(ate, c.fim);
+        });
+        return { mostrado: mostrado + arquivo.slice(ate), achados };
+    }
+    /** O nome do arquivo como achado. */
+    nome(arquivo) {
+        this.nomes += 1;
+        const { mostrado, achados } = this.caminho(arquivo);
+        for (const c of achados) {
+            this.achados.push({ arquivo: mostrado, linha: null, coluna: null, padrao: c.padrao, ...(c.termo ? { termo: c.termo } : {}) });
+        }
+        return mostrado;
+    }
+    /**
+     * As linhas de um arquivo: `numeradas` são pares (número da linha, texto). O arquivo de exceções não passa pelos
+     * padrões genéricos (ele lista o que é permitido), só pela lista local.
+     */
+    linhasDe(arquivo, mostrado, numeradas) {
+        const comGenericos = arquivo !== exports.ARQUIVO_DAS_EXCECOES;
+        for (const [numero, texto] of numeradas) {
+            this.linhas += 1;
+            for (const c of this.validos(texto, arquivo, comGenericos))
+                this.registrar(mostrado, numero, texto, 0, c);
+        }
+    }
+    /**
+     * O arquivo inteiro de uma vez (a árvore e os não rastreados): nenhum padrão atravessa a quebra de linha, e a
+     * linha de cada casamento sai do índice dos inícios de linha.
+     */
+    arquivoInteiro(arquivo, mostrado, texto) {
+        const inicios = [0];
+        for (let i = texto.indexOf('\n'); i >= 0; i = texto.indexOf('\n', i + 1))
+            inicios.push(i + 1);
+        // A quebra no fim do arquivo não abre linha nova.
+        this.linhas += texto.endsWith('\n') ? inicios.length - 1 : inicios.length;
+        for (const c of this.validos(texto, arquivo, arquivo !== exports.ARQUIVO_DAS_EXCECOES)) {
+            let baixo = 0;
+            let alto = inicios.length - 1;
+            while (baixo < alto) {
+                const meio = (baixo + alto + 1) >> 1;
+                if (inicios[meio] <= c.inicio)
+                    baixo = meio;
+                else
+                    alto = meio - 1;
+            }
+            this.registrar(mostrado, baixo + 1, texto, inicios[baixo], c);
+        }
+    }
+    registrar(mostrado, linha, texto, inicioDaLinha, c) {
+        const coluna = [...texto.slice(inicioDaLinha, c.inicio)].length + 1;
+        this.achados.push({ arquivo: mostrado, linha, coluna, padrao: c.padrao, ...(c.termo ? { termo: c.termo } : {}) });
+    }
+    resultado(escopo, erro = null) {
+        const { excecoes, lista } = this.contexto;
+        const semUso = [
+            ...excecoes.excecoes.flatMap((e, i) => this.uso.excecoes.has(i) ? []
+                : [`excecoes[${i}] ${e.padrao}`]),
+            ...excecoes.emailsPermitidos.flatMap((_e, i) => this.uso.emails.has(i) ? [] : [`emailsPermitidos[${i}] email`]),
+        ];
+        return {
+            schema: exports.CONTRATO_DA_VARREDURA, escopo, arquivos: this.arquivos, linhas: this.linhas, nomes: this.nomes,
+            listaLocal: resumoDaLista(lista),
+            excecoes: { arquivo: excecoes.presente ? exports.ARQUIVO_DAS_EXCECOES : null, total: excecoes.excecoes.length,
+                emailsPermitidos: excecoes.emailsPermitidos.length, semUso },
+            achados: this.achados, erro,
+        };
+    }
+}
+function resumoDaLista(lista) {
+    return { presente: lista.presente, procurada: lista.procurada, lidos: lista.lidos, termos: lista.termos.length,
+        ignorados: lista.ignorados };
+}
+/** A varredura que não rodou: o motivo, sem achado. */
+function varreduraComErro(erro, lista, escopo = []) {
+    return { schema: exports.CONTRATO_DA_VARREDURA, escopo, arquivos: 0, linhas: 0, nomes: 0, listaLocal: resumoDaLista(lista),
+        excecoes: { arquivo: null, total: 0, emailsPermitidos: 0, semUso: [] }, achados: [], erro };
+}
+/**
+ * O conteúdo de um arquivo do repositório como texto, inclusive quando contém bytes nulos ou UTF-8 inválido. O link
+ * simbólico é o alvo dele: o caminho para onde aponta também é conteúdo, e o link nunca é seguido.
+ */
+function conteudo(raiz, arquivo) {
+    const absoluto = path.join(raiz, arquivo);
+    let st;
+    try {
+        st = fs.lstatSync(absoluto);
+    }
+    catch {
+        return null;
+    }
+    if (st.isSymbolicLink())
+        return fs.readlinkSync(absoluto);
+    if (!st.isFile())
+        return null;
+    return fs.readFileSync(absoluto).toString('utf8');
+}
+function listaZ(saida) {
+    return saida.split('\0').filter(Boolean);
+}
+/** F1: os nomes e o conteúdo dos arquivos versionados (`git ls-files`) da raiz. */
+function varrerArvore(contexto) {
+    const coletor = new Coletor(contexto);
+    const escopo = [{ tipo: 'arvore' }];
+    const r = (0, util_1.exec)('git', ['-c', 'core.quotePath=false', 'ls-files', '-z'], contexto.raiz);
+    if (!r.ok)
+        return coletor.resultado(escopo, `git ls-files não respondeu em ${contexto.raiz}: ${r.stderr.trim() || r.code}`);
+    for (const arquivo of listaZ(r.stdout)) {
+        const mostrado = coletor.nome(arquivo);
+        const texto = conteudo(contexto.raiz, arquivo);
+        if (texto === null)
+            continue;
+        coletor.arquivos += 1;
+        coletor.arquivoInteiro(arquivo, mostrado, texto);
+    }
+    return coletor.resultado(escopo);
+}
+/** O caminho do cabeçalho `+++ b/<caminho>` do diff, também entre aspas (o git as põe no nome com tab ou aspas). */
+function caminhoDoCabecalho(resto) {
+    if (resto === '/dev/null')
+        return null;
+    if (resto.startsWith('"') && resto.endsWith('"')) {
+        try {
+            resto = JSON.parse(resto.replace(/\\([0-7]{3})/g, (_, o) => `\\u${Number.parseInt(o, 8).toString(16).padStart(4, '0')}`));
+        }
+        catch {
+            return null;
+        }
+    }
+    return resto.replace(/^b\//, '');
+}
+/** As linhas acrescentadas de um `git diff --unified=0`, por arquivo, com o número da linha nova. */
+function linhasAcrescentadas(saida) {
+    const porArquivo = new Map();
+    let arquivo = null;
+    let cabecalho = false;
+    let nova = 0;
+    for (const l of saida.split('\n')) {
+        if (l.startsWith('diff --git ')) {
+            cabecalho = true;
+            arquivo = null;
+            continue;
+        }
+        // O `+++` só é o nome do arquivo no cabeçalho; dentro do hunk, é uma linha acrescentada que começa por "++".
+        if (cabecalho && l.startsWith('+++ ')) {
+            arquivo = caminhoDoCabecalho(l.slice(4));
+            continue;
+        }
+        const h = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(l);
+        if (h) {
+            nova = Number(h[1]);
+            cabecalho = false;
+            continue;
+        }
+        if (!cabecalho && arquivo && l.startsWith('+')) {
+            if (!porArquivo.has(arquivo))
+                porArquivo.set(arquivo, []);
+            porArquivo.get(arquivo).push([nova, l.slice(1)]);
+            nova += 1;
+        }
+    }
+    return porArquivo;
+}
+/**
+ * F2: o diff da thread contra `base`: as linhas acrescentadas da árvore de trabalho (o que já foi commitado e o que
+ * ainda não foi), os arquivos não rastreados inteiros e os nomes dos arquivos acrescentados e dos não rastreados. O
+ * nome que já estava na base é da árvore, que o CI varre. `ignorar` tira caminhos (o bundle que o `ci prepare`
+ * troca e varre pelo texto novo).
+ */
+function varrerDiff(contexto, base, opcoes = {}) {
+    const coletor = new Coletor(contexto);
+    const escopo = [{ tipo: 'diff', base: base.sha, ref: base.ref }];
+    const ignorar = new Set(opcoes.ignorar ?? []);
+    const git = (args) => (0, util_1.exec)('git', ['-c', 'core.quotePath=false', ...args], contexto.raiz);
+    const diff = git(['diff', '--no-color', '--no-ext-diff', '--no-textconv', '--text', '--unified=0', '--no-renames', base.sha, '--']);
+    const novos = git(['diff', '--name-only', '-z', '--no-renames', '--diff-filter=A', base.sha, '--']);
+    const soltos = git(['ls-files', '--others', '--exclude-standard', '-z']);
+    const falhou = [diff, novos, soltos].find((r) => !r.ok);
+    if (falhou)
+        return coletor.resultado(escopo, `git não respondeu ao ler o diff contra ${base.sha.slice(0, 12)}: ${falhou.stderr.trim() || falhou.code}`);
+    const mostrados = new Map();
+    const mostrar = (arquivo, comNome) => {
+        if (!mostrados.has(arquivo))
+            mostrados.set(arquivo, comNome ? coletor.nome(arquivo) : coletor.caminho(arquivo).mostrado);
+        return mostrados.get(arquivo);
+    };
+    const naoRastreados = listaZ(soltos.stdout).filter((a) => !ignorar.has(a));
+    for (const arquivo of [...listaZ(novos.stdout).filter((a) => !ignorar.has(a)), ...naoRastreados])
+        mostrar(arquivo, true);
+    for (const [arquivo, linhas] of linhasAcrescentadas(diff.stdout)) {
+        if (ignorar.has(arquivo))
+            continue;
+        coletor.arquivos += 1;
+        coletor.linhasDe(arquivo, mostrar(arquivo, false), linhas);
+    }
+    for (const arquivo of naoRastreados) {
+        const texto = conteudo(contexto.raiz, arquivo);
+        if (texto === null)
+            continue;
+        coletor.arquivos += 1;
+        coletor.arquivoInteiro(arquivo, mostrar(arquivo, true), texto);
+    }
+    return coletor.resultado(escopo);
+}
+/** Um texto que ainda não está no disco (o bundle do `ci prepare`), varrido como o arquivo `nome`. */
+function varrerTexto(contexto, nome, texto) {
+    const coletor = new Coletor(contexto);
+    coletor.arquivos += 1;
+    coletor.arquivoInteiro(nome, coletor.caminho(nome).mostrado, texto);
+    return coletor.resultado([{ tipo: 'texto', nome }]);
+}
+/** Duas varreduras do mesmo contexto numa só (o diff e o bundle do `ci prepare`). Exceção sem uso é a de nenhuma. */
+function juntarVarreduras(a, b) {
+    const semUsoEmB = new Set(b.excecoes.semUso);
+    return { ...a, escopo: [...a.escopo, ...b.escopo], arquivos: a.arquivos + b.arquivos, linhas: a.linhas + b.linhas,
+        nomes: a.nomes + b.nomes, excecoes: { ...a.excecoes, semUso: a.excecoes.semUso.filter((s) => semUsoEmB.has(s)) },
+        achados: [...a.achados, ...b.achados], erro: a.erro ?? b.erro };
+}
+const SHA = /^[0-9a-f]{40,64}$/;
+/** A merge-base de HEAD com `ref` (nome de branch ou de ref remota), ou `null` sem ela. */
+function mergeBase(cwd, ref) {
+    if (!(0, util_1.exec)('git', ['rev-parse', '--verify', '--quiet', `${ref}^{commit}`], cwd).ok)
+        return null;
+    const r = (0, util_1.exec)('git', ['merge-base', 'HEAD', ref], cwd);
+    const sha = r.stdout.trim();
+    return r.ok && SHA.test(sha) ? { sha, ref } : null;
+}
+/**
+ * A base do diff da thread (D7): a merge-base de HEAD com `origin/<base>`, senão com a base local, senão o commit
+ * carimbado na thread, se for ancestral de HEAD. `null` sem nenhuma: quem chama varre a árvore inteira e diz.
+ */
+function baseDaThread(cwd, baseBranch, carimbada) {
+    for (const ref of [`origin/${baseBranch}`, baseBranch]) {
+        const qualificada = ref.startsWith('origin/') ? `refs/remotes/${ref}` : `refs/heads/${ref}`;
+        if (!(0, util_1.exec)('git', ['rev-parse', '--verify', '--quiet', qualificada], cwd).ok)
+            continue;
+        const base = mergeBase(cwd, qualificada);
+        if (base)
+            return { sha: base.sha, ref };
+    }
+    if (carimbada && SHA.test(carimbada) && (0, util_1.exec)('git', ['merge-base', '--is-ancestor', carimbada, 'HEAD'], cwd).ok) {
+        return { sha: carimbada, ref: null };
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// O relatório (D8)
+// ---------------------------------------------------------------------------
+/** `arquivo:linha:coluna  padrão`, ou `arquivo  nome do arquivo: padrão`; o termo da lista sai pelo número. */
+function linhaDoAchado(a) {
+    const padrao = a.padrao === 'lista-local' ? `lista-local (termo ${a.termo})` : a.padrao;
+    return a.linha === null ? `${a.arquivo}  nome do arquivo: ${padrao}` : `${a.arquivo}:${a.linha}:${a.coluna}  ${padrao}`;
+}
+/** O escopo em uma frase. */
+function textoDoEscopo(v) {
+    const partes = v.escopo.map((e) => e.tipo === 'arvore' ? 'árvore versionada'
+        : e.tipo === 'diff' ? `diff contra ${e.base.slice(0, 12)} (${e.ref ? `merge-base com ${e.ref}` : 'base carimbada da thread'})`
+            : `texto de ${e.nome}`);
+    return `${partes.join(' e ') || 'nada'}: ${v.arquivos} arquivo(s), ${v.linhas} linha(s), ${v.nomes} nome(s)`;
+}
+/** A lista local em uma frase, sem termo: ausente (e onde foi procurada) ou quantos termos de onde. */
+function textoDaListaLocal(v) {
+    const l = v.listaLocal;
+    const ignorados = l.ignorados ? `; ${l.ignorados} termo(s) curto(s) demais ignorado(s)` : '';
+    return l.presente
+        ? `${l.termos} termo(s) de ${l.lidos.join(' e ')}${ignorados}`
+        : `ausente (procurada em ${l.procurada.join(' e ')}); só os padrões genéricos (${exports.PADROES_GENERICOS.join(', ')})`;
+}
+/** O relatório da varredura, sem valor casado nem termo. */
+function relatorioDoDadoPrivado(v) {
+    const linhas = [`Varredura de dado privado: ${textoDoEscopo(v)}`, `  lista local  ${textoDaListaLocal(v)}`];
+    linhas.push(`  exceções     ${v.excecoes.arquivo
+        ? `${v.excecoes.arquivo}: ${v.excecoes.total} exceção(ões) e ${v.excecoes.emailsPermitidos} e-mail(s) permitido(s)`
+        : `sem ${exports.ARQUIVO_DAS_EXCECOES}: só as regras do código`}`);
+    if (v.erro) {
+        linhas.push(`  erro         ${v.erro}`);
+        return linhas;
+    }
+    // Exceção sem uso só diz alguma coisa na árvore inteira; no diff, ela cobre o que a thread não mexeu.
+    if (v.escopo.some((e) => e.tipo === 'arvore')) {
+        for (const s of v.excecoes.semUso)
+            linhas.push(`  aviso        exceção sem uso, revise no PR: ${s}`);
+    }
+    linhas.push(`  achados      ${v.achados.length}${v.achados.length ? ' (o valor casado nunca é impresso)' : ''}`);
+    for (const a of v.achados)
+        linhas.push(`    ${linhaDoAchado(a)}`);
+    return linhas;
+}
+// ---------------------------------------------------------------------------
+// A barreira da thread (F2): a policy `dado_privado` no `ork verify` e no `ork ci prepare`
+// ---------------------------------------------------------------------------
+/** Até quantos `arquivo:linha` vão ao detalhe da policy e ao ledger. */
+const ONDE_NO_DETALHE = 10;
+const ONDE_NO_LEDGER = 50;
+/** O `arquivo:linha` de um achado, ou `arquivo (nome)`; o caminho já vem mascarado. */
+function ondeDoAchado(a) {
+    return a.linha === null ? `${a.arquivo} (nome)` : `${a.arquivo}:${a.linha}`;
+}
+function padroesAchados(v) {
+    return [...new Set(v.achados.map((a) => a.padrao))];
+}
+/** Os fatos da varredura para a policy, sem valor casado nem termo. */
+function fatosDaVarredura(v) {
+    return { achados: v.achados.length, padroes: padroesAchados(v), onde: v.achados.slice(0, ONDE_NO_DETALHE).map(ondeDoAchado),
+        listaLocal: v.listaLocal.presente, escopo: textoDoEscopo(v), erro: v.erro };
+}
+/** O que vai ao ledger: escopo, contagens, padrões e onde; nunca o valor casado nem o termo. */
+function resumoNoLedger(b) {
+    const v = b.varredura;
+    return { policy: b.severidade, escopo: v.escopo, arquivos: v.arquivos, linhas: v.linhas, nomes: v.nomes,
+        listaLocal: { presente: v.listaLocal.presente, termos: v.listaLocal.termos }, achados: v.achados.length,
+        padroes: padroesAchados(v), onde: v.achados.slice(0, ONDE_NO_LEDGER).map(ondeDoAchado), erro: v.erro };
+}
+function estadoDoProjeto(raiz) {
+    try {
+        return (0, estado_thread_1.raizDoEstado)(raiz);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * RM-062 (F2): a barreira no diretório de trabalho da thread. Com `policies.dado_privado` declarada fora de `off`,
+ * varre o diff da thread contra a base (D7; sem base, a árvore inteira), mais o que `extra` varrer (o bundle do `ci
+ * prepare`), e avalia a policy no gate. Fora do manifesto, `null`: nada roda.
+ */
+function barreiraDaThread(carregado, thread, cwd, gate, opcoes = {}) {
+    const severidade = (0, policies_1.severidadeDeclarada)(carregado.manifesto, 'dado_privado');
+    if (severidade === null || severidade === 'off')
+        return null;
+    const c = contextoDaVarredura(cwd, estadoDoProjeto(carregado.raiz), opcoes.env);
+    let varredura;
+    if (!c.ok)
+        varredura = varreduraComErro(c.erro, c.lista);
+    else {
+        const base = baseDaThread(cwd, carregado.manifesto.worktree.base_branch, thread.base?.commit);
+        varredura = base ? varrerDiff(c.valor, base, { ignorar: opcoes.ignorar }) : varrerArvore(c.valor);
+        if (opcoes.extra)
+            varredura = juntarVarreduras(varredura, opcoes.extra(c.valor));
+    }
+    const violacoes = (0, policies_1.avaliarPolicies)(carregado.manifesto, { gate, threadId: thread.id, modo: thread.modo,
+        dadoPrivado: fatosDaVarredura(varredura) });
+    return { severidade, varredura, violacoes };
+}