@fontdata/ai-harness 3.1.0 → 3.1.2

package/.claude-plugin/plugin.json

@@ -1,8 +1,8 @@
 {
   "name": "fontdata",
-  "version": "3.1.0",
+  "version": "3.1.2",
   "mcpServers": {
-    "banco_dados": { "command": "npx", "args": ["-y", "@fontdata/ai-harness@3.1.0", "banco-dados-mcp"] }
+    "banco_dados": { "command": "npx", "args": ["-y", "@fontdata/ai-harness@3.1.2", "banco-dados-mcp"] }
   },
   "description": "Harness de engenharia com IA da Fontdata para Claude Code",
   "author": { "name": "Fontdata" },

package/dist/banco-dados/ferramentas.js

@@ -83,14 +83,23 @@ function paraJson(dados) {
 function plural(n, singular, plural) {
     return `${n} ${n === 1 ? singular : plural}`;
 }
-function rodapeLgpd({ colunasMascaradas, valoresEmTexto }) {
+const MOTIVOS = {
+    nome: 'pelo nome',
+    projeto: 'pela regra do projeto',
+    sql: 'porque o SQL cita',
+};
+/** Diz, para cada coluna, a categoria e o motivo, para o usuário achar um falso positivo e liberá-lo no projeto. */
+function rodapeLgpd({ colunasMascaradas, valoresEmTexto, detectados }) {
     const partes = [];
     if (colunasMascaradas.length > 0) {
-        const lista = colunasMascaradas.map((c) => `${c.coluna} → ${c.categoria}`).join(', ');
+        const lista = colunasMascaradas
+            .map((c) => `${c.coluna} → ${c.categoria} ${MOTIVOS[c.motivo]}${c.citada ? ` ${c.citada}` : ''}`)
+            .join(', ');
         partes.push(`${plural(colunasMascaradas.length, 'coluna', 'colunas')} (${lista})`);
     }
     if (valoresEmTexto > 0) {
-        partes.push(plural(valoresEmTexto, 'valor detectado pelo conteúdo', 'valores detectados pelo conteúdo'));
+        const lista = detectados.map((d) => `${d.coluna} → ${d.categorias.join('/')}`).join(', ');
+        partes.push(`${plural(valoresEmTexto, 'valor detectado pelo conteúdo', 'valores detectados pelo conteúdo')} (${lista})`);
     }
     return partes.length === 0 ? '' : `\n\nMascaramento LGPD: ${partes.join(' e ')}.`;
 }

package/dist/banco-dados/lgpd/aplicar.js

@@ -1,6 +1,19 @@
-import { identificadoresDoSql } from '../somente-leitura.js';
+import { identificadoresDoSql, tokenizar } from '../somente-leitura.js';
 import { classificarColuna, classificarNumero, encontrarNoTexto } from './detectar.js';
 import { mascararValor, OCULTO } from './mascarar.js';
+/** Categorias com formato próprio: uma flag (`'S'`, `true`, `0`) numa coluna dessas não carrega o dado pessoal. */
+const CATEGORIAS_DE_FORMATO = new Set(['cpf', 'cnpj', 'documento', 'email', 'telefone', 'cep', 'cartao', 'ip']);
+/** Palavras que encerram a lista de itens do `SELECT` quando aparecem fora de parênteses. */
+const FIM_DOS_ITENS = new Set(['from', 'where', 'group', 'having', 'order', 'limit', 'offset', 'window', 'fetch', 'for']);
+const INTEIRO_EM_TEXTO = /^\d+$/;
+const NUMERO_EM_TEXTO = /^-?\d+(\.\d+)?$/;
+function novoContador() {
+    return { valores: 0, categorias: new Set() };
+}
+function contar(contador, categoria) {
+    contador.valores += 1;
+    contador.categorias.add(categoria);
+}
 function lerRegras(entradas) {
     return entradas
         .map((entrada) => entrada.trim().toLowerCase().split('.'))
@@ -21,20 +34,109 @@ function identificadores(sql, dialeto) {
         return Array.from(sql.matchAll(/[\p{L}_][\p{L}\p{N}_$]*/gu), (m) => m[0].toLowerCase());
     }
 }
-function colunaPessoalCitada(opcoes, mascarar) {
+function ehContagem(tokens) {
+    if (tokens[0]?.tipo !== 'palavra' || tokens[0].valor !== 'count' || tokens[1]?.valor !== '(')
+        return false;
+    let profundidade = 0;
+    let fim = -1;
+    for (let i = 1; i < tokens.length; i++) {
+        if (tokens[i].valor === '(')
+            profundidade += 1;
+        else if (tokens[i].valor === ')' && --profundidade === 0) {
+            fim = i;
+            break;
+        }
+    }
+    if (fim === -1)
+        return false;
+    const resto = tokens.slice(fim + 1);
+    const apelido = (t) => t?.tipo === 'palavra' || t?.tipo === 'identificador-citado';
+    if (resto.length === 0)
+        return true;
+    if (resto.length === 1)
+        return apelido(resto[0]);
+    return resto.length === 2 && resto[0].tipo === 'palavra' && resto[0].valor === 'as' && apelido(resto[1]);
+}
+/**
+ * Identificadores de cada item do `SELECT`, na ordem das colunas. Só quando o SQL tem um único `SELECT` (sem `WITH`,
+ * `UNION`, subconsulta nem `*`) e o número de itens bate com o de colunas; nos demais casos, `null`, e vale o SQL
+ * inteiro, porque um apelido de subconsulta ou CTE esconderia a coluna pessoal.
+ */
+function itensDoSelect(sql, dialeto, colunas) {
+    let tokens;
+    try {
+        tokens = tokenizar(sql, dialeto).filter((t) => t.tipo !== 'comentario');
+    }
+    catch {
+        return null;
+    }
+    const palavras = tokens.filter((t) => t.tipo === 'palavra').map((t) => t.valor);
+    if (tokens[0]?.tipo !== 'palavra' || tokens[0].valor !== 'select')
+        return null;
+    if (palavras.filter((p) => p === 'select').length !== 1)
+        return null;
+    if (palavras.some((p) => p === 'with' || p === 'union' || p === 'intersect' || p === 'except'))
+        return null;
+    const itens = [[]];
+    let profundidade = 0;
+    let anterior = 'select';
+    for (const t of tokens.slice(1)) {
+        if (t.tipo === 'palavra' && profundidade === 0 && FIM_DOS_ITENS.has(t.valor))
+            break;
+        if (t.tipo === 'simbolo') {
+            if (t.valor === '(')
+                profundidade += 1;
+            else if (t.valor === ')')
+                profundidade -= 1;
+            else if (t.valor === '*' && ['select', 'distinct', 'all', ',', '.'].includes(anterior))
+                return null;
+            if (t.valor === ',' && profundidade === 0) {
+                itens.push([]);
+                anterior = t.valor;
+                continue;
+            }
+        }
+        itens.at(-1).push(t);
+        anterior = t.valor;
+    }
+    if (itens.length !== colunas)
+        return null;
+    return itens.map((item) => ({
+        ids: item.filter((t) => t.tipo === 'palavra' || t.tipo === 'identificador-citado').map((t) => t.valor),
+        contagem: ehContagem(item),
+    }));
+}
+function colunaPessoalCitada(ids, mascarar) {
     const extras = new Set(mascarar.map((r) => r.coluna));
-    for (const id of identificadores(opcoes.sql, opcoes.dialeto)) {
+    for (const id of ids) {
         const categoria = classificarColuna(id);
         if (categoria)
-            return categoria;
+            return { categoria, identificador: id };
         if (extras.has(id))
-            return 'mascarar_colunas';
+            return { categoria: 'mascarar_colunas', identificador: id };
     }
     return null;
 }
 function ehBinario(valor) {
     return valor instanceof Uint8Array || (typeof Buffer !== 'undefined' && Buffer.isBuffer(valor));
 }
+function ehFlag(valor) {
+    if (typeof valor === 'boolean')
+        return true;
+    if (typeof valor === 'string')
+        return valor.trim().length <= 1;
+    if (typeof valor === 'number')
+        return Number.isInteger(valor) && valor >= 0 && valor <= 9;
+    if (typeof valor === 'bigint')
+        return valor >= 0n && valor <= 9n;
+    return false;
+}
+/** Valor que, numa coluna classificada pelo nome, segue só para a detecção pelo conteúdo. */
+function dispensaMascaraDoNome(valor, categoria) {
+    if (!CATEGORIAS_DE_FORMATO.has(categoria))
+        return false;
+    return ehFlag(valor) || (categoria === 'email' && (typeof valor === 'number' || typeof valor === 'bigint'));
+}
 function mascararStringLivre(texto, contador) {
     const inicio = texto.trimStart()[0];
     if (inicio === '{' || inicio === '[') {
@@ -56,22 +158,23 @@ function mascararStringLivre(texto, contador) {
     for (const t of trechos) {
         saida += texto.slice(posicao, t.inicio) + String(mascararValor(texto.slice(t.inicio, t.fim), t.categoria));
         posicao = t.fim;
+        contar(contador, t.categoria);
     }
-    contador.valores += trechos.length;
     return saida + texto.slice(posicao);
 }
 function mascararPorValor(valor, testarNumero, contador) {
     if (typeof valor === 'string')
         return mascararStringLivre(valor, contador);
     if (typeof valor === 'number' || typeof valor === 'bigint') {
-        if (testarNumero && classificarNumero(valor) !== null) {
-            contador.valores += 1;
+        const categoria = testarNumero ? classificarNumero(valor) : null;
+        if (categoria !== null) {
+            contar(contador, categoria);
             return OCULTO;
         }
         return valor;
     }
     if (ehBinario(valor)) {
-        contador.valores += 1;
+        contar(contador, 'binario');
         return OCULTO;
     }
     if (valor instanceof Date)
@@ -89,18 +192,32 @@ function mascararEstrutura(valor, contador) {
     const saida = {};
     for (const [chave, item] of Object.entries(valor)) {
         const categoria = classificarColuna(chave);
-        if (categoria === null) {
+        if (categoria === null || dispensaMascaraDoNome(item, categoria)) {
             saida[chave] = mascararPorValor(item, true, contador);
         }
         else {
             const mascarado = mascararValor(item, categoria);
             if (mascarado !== item)
-                contador.valores += 1;
+                contar(contador, categoria);
             saida[chave] = mascarado;
         }
     }
     return saida;
 }
+/**
+ * Texto calculado que é um número (o PostgreSQL devolve `count`, `sum` e `numeric` como texto) é testado como
+ * número, como na D-04: o inteiro também passa pelo CPF de 9 e 10 dígitos que o `CAST(cpf AS bigint)` produz.
+ */
+function mascararNumeroEmTexto(texto, contador) {
+    if (INTEIRO_EM_TEXTO.test(texto) && texto.length <= 19) {
+        const categoria = classificarNumero(BigInt(texto));
+        if (categoria !== null) {
+            contar(contador, categoria);
+            return OCULTO;
+        }
+    }
+    return mascararStringLivre(texto, contador);
+}
 function tratamentoDaColuna(nome, origem, mascarar, liberar) {
     if (casa(mascarar, nome, origem))
         return { tipo: 'ocultar', categoria: 'mascarar_colunas' };
@@ -114,36 +231,57 @@ function tratamentoDaColuna(nome, origem, mascarar, liberar) {
 }
 /**
  * Mascara os dados pessoais de um resultado pela origem da coluna, pelo nome, pelas regras do projeto e pelo
- * valor. Não altera o resultado recebido; com `ativo: false`, devolve-o sem mudança.
+ * valor, célula a célula. Não altera o resultado recebido; com `ativo: false`, devolve-o sem mudança.
  */
 export function mascararResultado(resultado, opcoes) {
     if (!opcoes.ativo)
-        return { resultado, colunasMascaradas: [], valoresEmTexto: 0 };
+        return { resultado, colunasMascaradas: [], valoresEmTexto: 0, detectados: [] };
     const mascarar = lerRegras(opcoes.regras.mascarar_colunas);
     const liberar = lerRegras(opcoes.regras.liberar_colunas);
     const tratamentos = resultado.colunas.map((nome, i) => tratamentoDaColuna(nome, resultado.origens === undefined ? undefined : resultado.origens[i], mascarar, liberar));
-    let citada;
-    const citacao = () => {
-        if (citada === undefined)
-            citada = colunaPessoalCitada(opcoes, mascarar);
-        return citada;
+    const citacoes = new Map();
+    let itens;
+    const item = (i) => {
+        if (itens === undefined)
+            itens = itensDoSelect(opcoes.sql, opcoes.dialeto, resultado.colunas.length);
+        return itens ? itens[i] : null;
+    };
+    const citacao = (i) => {
+        if (!citacoes.has(i)) {
+            citacoes.set(i, colunaPessoalCitada(item(i)?.ids ?? identificadores(opcoes.sql, opcoes.dialeto), mascarar));
+        }
+        return citacoes.get(i);
     };
     const marcadas = new Map();
-    const contador = { valores: 0 };
+    const contadores = resultado.colunas.map(() => novoContador());
     const linhas = resultado.linhas.map((linha) => linha.map((valor, i) => {
         const t = tratamentos[i] ?? { tipo: 'valor', calculada: false, numero: true };
+        const contador = contadores[i] ?? novoContador();
         if (t.tipo === 'ocultar') {
-            marcadas.set(i, t.categoria);
+            marcadas.set(i, { coluna: resultado.colunas[i] ?? String(i), categoria: t.categoria, motivo: 'projeto' });
             return valor === null || valor === undefined ? valor : OCULTO;
         }
         if (t.tipo === 'categoria') {
-            marcadas.set(i, t.categoria);
-            return mascararValor(valor, t.categoria);
+            if (dispensaMascaraDoNome(valor, t.categoria))
+                return mascararPorValor(valor, true, contador);
+            const mascarado = mascararValor(valor, t.categoria);
+            if (mascarado !== valor) {
+                marcadas.set(i, { coluna: resultado.colunas[i] ?? String(i), categoria: t.categoria, motivo: 'nome' });
+            }
+            return mascarado;
         }
         if (t.calculada && typeof valor === 'string') {
-            const categoria = citacao();
-            if (categoria !== null) {
-                marcadas.set(i, categoria);
+            const citada = citacao(i);
+            // Um número só escapa da citação quando é contagem: `sum(salario)` por pessoa ou `substr(cpf, 1, 9)` não.
+            if (NUMERO_EM_TEXTO.test(valor) && (citada === null || item(i)?.contagem))
+                return mascararNumeroEmTexto(valor, contador);
+            if (citada !== null) {
+                marcadas.set(i, {
+                    coluna: resultado.colunas[i] ?? String(i),
+                    categoria: citada.categoria,
+                    motivo: 'sql',
+                    citada: citada.identificador,
+                });
                 return OCULTO;
             }
         }
@@ -152,10 +290,10 @@ export function mascararResultado(resultado, opcoes) {
     const copia = { ...resultado, colunas: [...resultado.colunas], linhas };
     if (resultado.origens !== undefined)
         copia.origens = resultado.origens.map((o) => (o ? { ...o } : o));
-    const colunasMascaradas = [...marcadas.keys()]
-        .sort((a, b) => a - b)
-        .map((i) => ({ coluna: resultado.colunas[i] ?? String(i), categoria: marcadas.get(i) }));
-    return { resultado: copia, colunasMascaradas, valoresEmTexto: contador.valores };
+    const colunasMascaradas = [...marcadas.keys()].sort((a, b) => a - b).map((i) => marcadas.get(i));
+    const detectados = contadores.flatMap((c, i) => c.valores === 0 ? [] : [{ coluna: resultado.colunas[i] ?? String(i), categorias: [...c.categorias] }]);
+    const valoresEmTexto = contadores.reduce((total, c) => total + c.valores, 0);
+    return { resultado: copia, colunasMascaradas, valoresEmTexto, detectados };
 }
 /** Categoria com que a coluna `tabela.coluna` sai mascarada pelo nome ou pelas regras do projeto, ou `null`. */
 export function categoriaDaColuna(tabela, coluna, regras) {
@@ -164,5 +302,5 @@ export function categoriaDaColuna(tabela, coluna, regras) {
 }
 /** Aplica a detecção por valor a um texto solto, como a mensagem de erro do banco. */
 export function mascararTexto(texto) {
-    return mascararStringLivre(texto, { valores: 0 });
+    return mascararStringLivre(texto, novoContador());
 }

package/dist/banco-dados/lgpd/detectar.js

@@ -8,7 +8,7 @@ const PARTES_ISOLADAS = [
     ['cep', ['cep', 'zip', 'postal']],
     ['nascimento', ['nascimento', 'nasc', 'birth', 'birthday']],
     ['nome', ['sobrenome']],
-    ['financeiro', ['salario', 'renda', 'salary', 'income', 'agencia', 'iban', 'pix']],
+    ['financeiro', ['salario', 'renda', 'salary', 'income', 'iban', 'pix']],
     ['cartao', ['cartao', 'card', 'cvv', 'cvc']],
     ['ip', ['ip']],
     ['segredo', ['senha', 'password', 'passwd', 'pwd', 'hash', 'token', 'secret', 'apikey']],
@@ -35,6 +35,10 @@ const COMBINACOES = [
     ['nome', [['first', 'last', 'full'], ['name']]],
     ['nome', [['nome', 'name'], PARTES_DE_PESSOA]],
 ];
+/** Com uma destas partes, `pis` é o tributo (`valor_pis`, `retencao_pis_cofins`), não o número PIS do trabalhador. */
+const PARTES_DE_TRIBUTO = new Set([
+    'valor', 'vl', 'vlr', 'percentual', 'perc', 'aliquota', 'aliq', 'bc', 'base', 'retencao', 'ret', 'cst', 'cofins',
+]);
 const TERMOS_FORTES = [
     ['cpf', 'cpf'],
     ['cnpj', 'cnpj'],
@@ -67,6 +71,8 @@ export function partesDoNome(nome) {
 export function classificarColuna(nome) {
     const partes = partesDoNome(nome);
     const tem = new Set(partes);
+    if (partes.some((p) => PARTES_DE_TRIBUTO.has(p)))
+        tem.delete('pis');
     for (const [categoria, listas] of COMBINACOES) {
         if (listas.every((lista) => lista.some((p) => tem.has(p))))
             return categoria;
@@ -90,8 +96,9 @@ function soDigitos(texto) {
 }
 function digitoVerificador(digitos, pesos) {
     let soma = 0;
+    // No CNPJ alfanumérico, cada caractere vale o código ASCII menos 48; nos dígitos, isso é o próprio dígito.
     for (let i = 0; i < pesos.length; i++)
-        soma += Number(digitos[i]) * (pesos[i] ?? 0);
+        soma += ((digitos.charCodeAt(i) || 48) - 48) * (pesos[i] ?? 0);
     const resto = soma % 11;
     return resto < 2 ? 0 : 11 - resto;
 }
@@ -102,9 +109,10 @@ export function cpfValido(cpf) {
     return (digitoVerificador(d, [10, 9, 8, 7, 6, 5, 4, 3, 2]) === Number(d[9]) &&
         digitoVerificador(d, [11, 10, 9, 8, 7, 6, 5, 4, 3, 2]) === Number(d[10]));
 }
+/** Aceita também o CNPJ alfanumérico: 12 caracteres `[0-9A-Z]` e 2 dígitos verificadores. */
 export function cnpjValido(cnpj) {
-    const d = soDigitos(cnpj);
-    if (d.length !== 14 || DIGITOS_REPETIDOS.test(d))
+    const d = cnpj.toUpperCase().replace(/[^0-9A-Z]/g, '');
+    if (!/^[0-9A-Z]{12}\d{2}$/.test(d) || DIGITOS_REPETIDOS.test(d))
         return false;
     return (digitoVerificador(d, [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]) === Number(d[12]) &&
         digitoVerificador(d, [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]) === Number(d[13]));
@@ -131,6 +139,7 @@ const MAX_DIGITOS = 19;
 const CPF_FORMATADO = /^\d{3}\.\d{3}\.\d{3}-\d{2}$/;
 const CNPJ_FORMATADO = /^\d{2}\.\d{3}\.\d{3}\/\d{4}-\d{2}$/;
 const EMAIL = /[\p{L}\p{M}\p{N}._%+-]+@[\p{L}\p{M}\p{N}-]+(?:\.[\p{L}\p{M}\p{N}-]+)*\.[\p{L}\p{M}]{2,}/gu;
+const CNPJ_ALFANUMERICO = /(?<![\p{L}\p{N}])[0-9A-Z]{2}\.?[0-9A-Z]{3}\.?[0-9A-Z]{3}\/?[0-9A-Z]{4}-?\d{2}(?![\p{L}\p{N}])/gu;
 const TELEFONE = /(?<![\d+])(?:\+55\s?)?(?:\(\d{2}\)\s?|\d{2}[\s-])9?\d{4}[\s-]?\d{4}(?!\d)/g;
 /** `seq` é um trecho de grupos inteiros com no máximo `MAX_DIGITOS` dígitos. */
 function classificarSequencia(seq) {
@@ -185,6 +194,10 @@ export function encontrarNoTexto(texto) {
         ...trechosDe(texto, EMAIL, 'email'),
         ...trechosDe(texto, TELEFONE, 'telefone'),
         ...trechosDeDigitos(texto),
+        ...trechosDe(texto, CNPJ_ALFANUMERICO, 'cnpj').filter((t) => {
+            const trecho = texto.slice(t.inicio, t.fim);
+            return /[A-Z]/.test(trecho) && cnpjValido(trecho);
+        }),
     ].sort((a, b) => prioridade(a.categoria) - prioridade(b.categoria) || b.fim - b.inicio - (a.fim - a.inicio) || a.inicio - b.inicio);
     const escolhidos = [];
     for (const t of candidatos) {

package/dist/banco-dados/lgpd/mascarar.js

@@ -1,8 +1,8 @@
 export const OCULTO = '[OCULTO]';
 const CONECTIVOS = new Set(['da', 'de', 'do', 'das', 'dos', 'e']);
-function manterIntervalo(texto, inicio, fim) {
+function manterIntervalo(texto, inicio, fim, caractere = /\d/g) {
     let posicao = 0;
-    return texto.replace(/\d/g, (digito) => {
+    return texto.replace(caractere, (digito) => {
         posicao += 1;
         return posicao >= inicio && posicao <= fim ? digito : '*';
     });
@@ -13,9 +13,9 @@ function mascararCpf(texto) {
     return manterIntervalo(texto, 4, 9);
 }
 function mascararCnpj(texto) {
-    if (!/^(\d{2}\.\d{3}\.\d{3}\/\d{4}-\d{2}|\d{14})$/.test(texto))
+    if (!/^([0-9A-Z]{2}\.[0-9A-Z]{3}\.[0-9A-Z]{3}\/[0-9A-Z]{4}-\d{2}|[0-9A-Z]{12}\d{2})$/.test(texto))
         return OCULTO;
-    return manterIntervalo(texto, 3, 12);
+    return manterIntervalo(texto, 3, 12, /[0-9A-Z]/g);
 }
 function mascararDocumento(texto) {
     if (!/^[A-Za-z0-9./\s-]+$/.test(texto))

package/dist/cli.js

@@ -3,6 +3,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { allCommands, loadCatalog } from './catalog.js';
+import { acharRaiz } from './raiz.js';
 import { runCommand, runnableIds, suggestIds } from './run.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 /** Comandos renomeados depois da 2.7.0: o nome antigo aponta o novo em vez de cair em "Comando desconhecido". */
@@ -127,7 +128,7 @@ async function main() {
     }
     if (cmd === 'doctor') {
         const { formatFindings, runDoctor } = await import('./doctor/checks.js');
-        const root = resolve(process.cwd(), argv[1] ?? '.');
+        const root = argv[1] === undefined ? acharRaiz() : resolve(process.cwd(), argv[1]);
         if (!existsSync(root))
             throw new Error(`Pasta não encontrada: ${root}`);
         const findings = runDoctor(root);

package/dist/comentarios/command.js

@@ -6,6 +6,7 @@ import { suggestFlag } from '../install/flags.js';
 import { hashContent } from '../install/lock.js';
 import { executePlan, packageInfo } from '../install/plan.js';
 import { mergeSettings } from '../install/settings.js';
+import { acharRaiz } from '../raiz.js';
 import { COMMENTS_BASELINE_PATH, COMMENTS_HOOK_PATH, COMMENTS_RULE_PATH, commentsHooksConfig, ensureCommentsBaseline } from './instalar.js';
 export { COMMENTS_HOOK_PATH } from './instalar.js';
 const FLAGS = ['--yes', '-y', '--sim'];
@@ -27,7 +28,7 @@ export function runCommentsCommand(argv) {
             throw new Error(`Flag desconhecida: ${token}.${suggestion ? ` Você quis dizer ${suggestion}?` : ''}`);
         }
     }
-    const root = resolve(process.cwd(), path ?? '.');
+    const root = path === undefined ? acharRaiz() : resolve(process.cwd(), path);
     if (!existsSync(root))
         throw new Error(`Pasta não encontrada: ${root}`);
     const rule = readFileSync(join(templatesDir, 'rules', 'comentarios.md'));

package/dist/memoria/indice.js

@@ -3,6 +3,7 @@ import { EOL } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { ARTIFACT_TYPES, readArtifact, WORKS_DIR } from '../contratos/artefatos.js';
 import { suggestFlag } from '../install/flags.js';
+import { acharRaiz } from '../raiz.js';
 export const INDEX_PATH = join('.ai-harness', 'memoria', 'indice.json');
 export const INDEX_VERSION = 1;
 const BACKSLASH = String.fromCharCode(92);
@@ -159,7 +160,7 @@ export function runMemoryCommand(argv) {
         else
             bugId = value;
     }
-    const root = resolve(process.cwd(), path ?? '.');
+    const root = path === undefined ? acharRaiz() : resolve(process.cwd(), path);
     if (!existsSync(root))
         throw new Error(`Pasta não encontrada: ${root}`);
     const index = buildIndex(root);

package/dist/raiz.js

@@ -0,0 +1,21 @@
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+/** Sobe até o diretório mais próximo que tenha o marcador, ou devolve undefined. */
+function subirAte(inicio, marcador) {
+    for (let pasta = inicio;; pasta = dirname(pasta)) {
+        if (existsSync(join(pasta, marcador)))
+            return pasta;
+        if (dirname(pasta) === pasta)
+            return undefined;
+    }
+}
+/**
+ * Raiz do projeto para os comandos rodados sem caminho: o Bash dos agentes herda o `cd` de comandos anteriores, então
+ * o diretório atual pode ser uma subpasta. Vale o `.ai-harness/` mais próximo, depois o `.git` (arquivo em submódulo e
+ * worktree); sem nenhum, o próprio diretório. `CLAUDE_PROJECT_DIR` fica de fora: não é garantida no Bash, e a suíte
+ * roda dentro do Claude Code.
+ */
+export function acharRaiz(inicio = process.cwd()) {
+    const pasta = resolve(inicio);
+    return subirAte(pasta, '.ai-harness') ?? subirAte(pasta, '.git') ?? pasta;
+}

package/dist/rastro/command.js

@@ -2,6 +2,7 @@ import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { templatesDir } from '../catalog.js';
 import { suggestFlag } from '../install/flags.js';
+import { acharRaiz } from '../raiz.js';
 /** O CLI grava pela mesma biblioteca dos hooks, para as duas formas produzirem o mesmo formato. */
 export async function loadRastroLib() {
     return (await import(pathToFileURL(join(templatesDir, 'hooks', 'lib', 'rastro.mjs')).href));
@@ -41,6 +42,6 @@ export async function runEventCommand(argv) {
             }
         }
     }
-    (await loadRastroLib()).recordEvent(process.cwd(), fields);
+    (await loadRastroLib()).recordEvent(acharRaiz(), fields);
     return 0;
 }

package/dist/trabalhos/conflitos.js

@@ -3,6 +3,7 @@ import { join } from 'node:path';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { readArtifact } from '../contratos/artefatos.js';
 import { suggestFlag } from '../install/flags.js';
+import { acharRaiz } from '../raiz.js';
 import { loadRastroLib } from '../rastro/command.js';
 const FINISHED = new Set(['concluido', 'cancelado']);
 const normalize = (path) => path.trim().replace(/^\.\//, '').replace(/\/+$/, '');
@@ -84,7 +85,7 @@ export async function waitForFreeFiles(root, workId, options) {
 }
 const FLAGS = ['--aguardar', '--intervalo'];
 /** `ai-harness conflitos <id> [--aguardar] [--intervalo <segundos>]` — sai com 1 quando há conflito sem --aguardar. */
-export async function runConflictsCommand(argv, root = process.cwd()) {
+export async function runConflictsCommand(argv, root = acharRaiz()) {
     const [workId, ...rest] = argv;
     if (!workId || workId.startsWith('-')) {
         throw new Error('Informe o id do trabalho. Ex.: npx @fontdata/ai-harness conflitos 2026-09-18-login --aguardar');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fontdata/ai-harness",
-  "version": "3.1.0",
+  "version": "3.1.2",
   "description": "Harness de engenharia com IA da Fontdata para Claude Code: roda os slash commands direto na pasta do projeto via npx, sem instalar nada — ou instala-os em .claude/commands.",
   "type": "module",
   "bin": {