@fontdata/ai-harness 3.0.0 → 3.1.1

package/.claude-plugin/plugin.json

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

package/README.md

@@ -129,15 +129,16 @@ da conexão e o nome da variável de ambiente (`dsn_env`), e cada dev guarda o D
 `.claude/settings.local.json` (fora do git), no `.env` ou no ambiente:
 
 ```bash
-npx @fontdata/ai-harness banco-dados adicionar erp --projeto   # pergunta os dados, testa e grava ERP_DATABASE_URL
+npx @fontdata/ai-harness banco-dados adicionar erp   # na raiz do projeto: pergunta os dados, testa e grava ERP_DATABASE_URL
 npx @fontdata/ai-harness banco-dados testar
 ```
 
-O `adicionar --projeto` grava `{ "nome": "erp", "dsn_env": "ERP_DATABASE_URL" }` em `banco_dados.conexoes` e a variável
-no `.claude/settings.local.json`. Faça commit do `config.json`; cada colega roda o mesmo comando, que grava só a
-variável. `"producao": true` na entrada vale para a equipe toda. Quem prefere um cadastro por máquina
-(`~/.config/ai-harness/conexoes.json`) usa `banco-dados adicionar erp-dev` sem `--projeto` e `banco-dados usar erp-dev` no
-projeto.
+O `adicionar` grava `{ "nome": "erp", "dsn_env": "ERP_DATABASE_URL" }` em `banco_dados.conexoes` e a variável no
+`.claude/settings.local.json`; fora da raiz de um projeto (sem `.git` nem `.ai-harness/config.json`), ele recusa sem
+gravar nada. Faça commit do `config.json`; cada colega roda o mesmo comando, que grava só a variável.
+`"producao": true` na entrada vale para a equipe toda, e `banco-dados remover erp` tira a conexão do projeto. Quem
+prefere um cadastro por máquina (`~/.config/ai-harness/conexoes.json`) usa `banco-dados adicionar erp-dev --global` e
+`banco-dados usar erp-dev` no projeto.
 
 O servidor MCP `banco_dados` entrega ao Claude `listar_conexoes`, `listar_tabelas`, `descrever_tabela` e
 `consultar`, tudo somente leitura. Ele vem no plugin; sem plugin, o `init` e o `update` o registram no `.mcp.json`

package/dist/banco-dados/ambiente.js

@@ -81,12 +81,27 @@ export function gravarVariavelSettingsLocal(raiz, nome, valor) {
     const envAtual = ehObjeto(dados.env) ? dados.env : {};
     if (envAtual[nome] === valor)
         return { changed: false };
-    const novo = { ...dados, env: { ...envAtual, [nome]: valor } };
     const modo = leitura.existe ? statSync(caminho).mode & 0o777 : 0o600;
     mkdirSync(dirname(caminho), { recursive: true });
+    gravarAtomico(caminho, { ...dados, env: { ...envAtual, [nome]: valor } }, modo);
+    return { changed: true };
+}
+/** Tira a variável do env do settings.local.json com a mesma gravação atômica; arquivo ou chave ausente não escreve. */
+export function removerVariavelSettingsLocal(raiz, nome) {
+    const caminho = join(raiz, SETTINGS_LOCAL_PATH);
+    const leitura = lerSettings(caminho);
+    if ('erro' in leitura)
+        throw new Error(leitura.erro);
+    if (!leitura.existe || !ehObjeto(leitura.dados.env) || !Object.hasOwn(leitura.dados.env, nome))
+        return { changed: false };
+    const { [nome]: _removida, ...envRestante } = leitura.dados.env;
+    gravarAtomico(caminho, { ...leitura.dados, env: envRestante }, statSync(caminho).mode & 0o777);
+    return { changed: true };
+}
+function gravarAtomico(caminho, dados, modo) {
     const temporario = `${caminho}.${process.pid}.${Date.now()}.tmp`;
     try {
-        writeFileSync(temporario, `${JSON.stringify(novo, null, 2)}\n`, { mode: modo });
+        writeFileSync(temporario, `${JSON.stringify(dados, null, 2)}\n`, { mode: modo });
         chmodSync(temporario, modo);
         renameSync(temporario, caminho);
     }
@@ -94,5 +109,4 @@ export function gravarVariavelSettingsLocal(raiz, nome, valor) {
         rmSync(temporario, { force: true });
         throw erro;
     }
-    return { changed: true };
 }

package/dist/banco-dados/command.js

@@ -2,24 +2,28 @@ import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { EOL } from 'node:os';
 import { join, resolve } from 'node:path';
 import * as p from '@clack/prompts';
-import { comSecaoBanco, CONFIG_PATH, gravarConexaoProjeto, readConfig, REGRA_DSN_ENV, REGRA_NOME_CONEXAO, secaoBanco, validarConfigParaEscrita, writeDefaultConfig, } from '../config/config.js';
+import { comSecaoBanco, CONFIG_PATH, gravarConexaoProjeto, readConfig, removerConexaoProjeto, REGRA_DSN_ENV, REGRA_NOME_CONEXAO, secaoBanco, validarConfigParaEscrita, writeDefaultConfig, } from '../config/config.js';
 import { suggestFlag } from '../install/flags.js';
 import { caminhoCadastro, lerCadastro, ocultarSenha, removerConexao, resumirConexao, salvarConexao, TIPOS_BANCO, } from './cadastro.js';
-import { gravarVariavelSettingsLocal, lerEnvSettingsLocal, lerVariavel, SETTINGS_LOCAL_PATH, validarSettingsLocal } from './ambiente.js';
+import { gravarVariavelSettingsLocal, lerEnvSettingsLocal, lerVariavel, removerVariavelSettingsLocal, SETTINGS_LOCAL_PATH, validarSettingsLocal, } from './ambiente.js';
 import { interpretarDsn, resolverConexoes } from './conexao.js';
 import { criarDriver as criarDriverPadrao } from './drivers/index.js';
 const AJUDA = [
     'Uso: ai-harness banco-dados <subcomando>',
     '',
-    '  adicionar <nome> [--dsn <dsn>] [--producao] [--sem-testar] [--substituir]',
-    '                     cadastra a conexão nesta máquina (sem --dsn, pergunta os dados)',
-    '  adicionar <nome> --projeto [--env <VAR>] [--dsn <dsn>] [--producao] [--sem-testar] [--substituir]',
-    '                     grava o DSN na variável <NOME>_DATABASE_URL (ou --env) do .claude/settings.local.json',
+    '  adicionar <nome> [--env <VAR>] [--dsn <dsn>] [--producao] [--sem-testar] [--substituir]',
+    '                     grava no projeto: o DSN na variável <NOME>_DATABASE_URL (ou --env) do .claude/settings.local.json',
     '                     e a conexão { nome, dsn_env } em banco_dados.conexoes do .ai-harness/config.json',
+    '                     (sem --dsn, pergunta os dados)',
+    '  adicionar <nome> --global [--dsn <dsn>] [--producao] [--sem-testar] [--substituir]',
+    '                     cadastra a conexão nesta máquina',
     '  listar             mostra as conexões cadastradas e as do projeto, sem a senha',
     '  testar [nome]      testa a conexão pedida ou todas as do projeto',
-    '  usar <nome...>     grava banco_dados.conexoes no .ai-harness/config.json (mantém as entradas { nome, dsn_env })',
-    '  remover <nome>     apaga a conexão do cadastro',
+    '  usar <nome...>     grava banco_dados.conexoes no .ai-harness/config.json, para conexões do cadastro global',
+    '                     (mantém as entradas { nome, dsn_env })',
+    '  remover <nome> [--global]',
+    '                     tira a conexão do projeto e a variável dela do .claude/settings.local.json;',
+    '                     com --global, apaga a conexão do cadastro desta máquina',
 ].join(EOL);
 const PORTA_PADRAO = { postgres: '5432', mariadb: '3306' };
 const ESQUEMA = { postgres: 'postgres', mariadb: 'mysql' };
@@ -118,14 +122,15 @@ function conexaoDoDsn(dsn, cwd, producao) {
     return conexao;
 }
 async function adicionar(ctx, argv) {
-    const { posicionais, marcadas, valores } = lerArgumentos(argv, ['--producao', '--sem-testar', '--substituir', '--projeto'], ['--dsn', '--env']);
+    const { posicionais, marcadas, valores } = lerArgumentos(argv, ['--producao', '--sem-testar', '--substituir', '--global'], ['--dsn', '--env']);
     const [nome, ...sobra] = posicionais;
-    if (!nome || sobra.length > 0)
-        throw new Error('Uso: ai-harness banco-dados adicionar <nome> [--projeto [--env <VAR>]] [--dsn <dsn>] [--producao] [--sem-testar] [--substituir]');
-    if (marcadas.has('--projeto'))
+    if (!nome || sobra.length > 0) {
+        throw new Error('Uso: ai-harness banco-dados adicionar <nome> [--global | --env <VAR>] [--dsn <dsn>] [--producao] [--sem-testar] [--substituir]');
+    }
+    if (!marcadas.has('--global'))
         return adicionarNoProjeto(ctx, nome, marcadas, valores);
     if (valores['--env'] !== undefined)
-        throw new Error('--env só vale com --projeto.');
+        throw new Error('--env não vale com --global.');
     const substituir = marcadas.has('--substituir');
     if (!substituir && nome in lerCadastro(ctx.cadastro).conexoes) {
         ctx.erro(`A conexão ${nome} já existe em ${ctx.cadastro}. Use --substituir para trocá-la.`);
@@ -169,6 +174,10 @@ function variavelPadrao(nome) {
     return `${nome.toUpperCase().replace(/-/g, '_')}_DATABASE_URL`;
 }
 async function adicionarNoProjeto(ctx, nome, marcadas, valores) {
+    if (!existsSync(join(ctx.cwd, '.git')) && !existsSync(join(ctx.cwd, CONFIG_PATH))) {
+        ctx.erro(`Nenhum projeto em ${ctx.cwd} (sem .git nem ${CONFIG_PATH}). Rode na raiz do projeto ou use --global para cadastrar nesta máquina.`);
+        return 1;
+    }
     const substituir = marcadas.has('--substituir');
     if (!REGRA_NOME_CONEXAO.test(nome)) {
         ctx.erro(`Nome de conexão inválido: ${JSON.stringify(nome)}; use só minúsculas, dígitos, - e _, começando por minúscula ou dígito.`);
@@ -260,7 +269,7 @@ function listar(ctx, argv) {
     const doProjeto = config.banco_dados.conexoes.flatMap((nome) => config.banco_dados.projeto[nome] ?? []);
     const nomes = Object.keys(conexoes).sort();
     if (nomes.length === 0 && doProjeto.length === 0) {
-        ctx.log(`Nenhuma conexão cadastrada em ${ctx.cadastro}. Cadastre com: npx @fontdata/ai-harness banco-dados adicionar <nome>`);
+        ctx.log('Nenhuma conexão. Na raiz do projeto, rode: npx @fontdata/ai-harness banco-dados adicionar <nome>');
         return 0;
     }
     for (const nome of nomes) {
@@ -313,7 +322,7 @@ async function testar(ctx, argv) {
             for (const problema of resolvidas.problemas)
                 ctx.erro(problema);
         for (const faltando of resolvidas.faltando.filter((item) => nome === undefined || item === nome)) {
-            ctx.erro(`Conexão ${faltando} não encontrada nesta máquina; rode banco-dados adicionar ${faltando}.`);
+            ctx.erro(`Conexão ${faltando} não encontrada nesta máquina; rode banco-dados adicionar ${faltando} --global.`);
             ok = false;
         }
         for (const ausente of resolvidas.variaveisAusentes.filter(pedida)) {
@@ -327,7 +336,7 @@ async function testar(ctx, argv) {
         }
         alvos = resolvidas.conexoes.filter(pedida);
         if (alvos.length === 0 && ok) {
-            ctx.erro('Nenhuma conexão de banco configurada neste projeto; rode npx @fontdata/ai-harness banco-dados usar <nome>.');
+            ctx.erro('Nenhuma conexão de banco configurada neste projeto; rode npx @fontdata/ai-harness banco-dados adicionar <nome>.');
             return 1;
         }
     }
@@ -371,15 +380,17 @@ function usar(ctx, argv) {
     const { conexoes } = lerCadastro(ctx.cadastro);
     const ausentes = unicos.filter((nome) => !(nome in conexoes) && !objetos.has(nome));
     if (ausentes.length > 0) {
-        ctx.erro(`Aviso: sem cadastro nesta máquina para ${ausentes.join(', ')}; rode banco-dados adicionar <nome> para cada uma.`);
+        ctx.erro(`Aviso: sem cadastro nesta máquina para ${ausentes.join(', ')}; rode banco-dados adicionar <nome> --global para cada uma.`);
     }
     return 0;
 }
 function remover(ctx, argv) {
-    const { posicionais } = lerArgumentos(argv, []);
+    const { posicionais, marcadas } = lerArgumentos(argv, ['--global']);
     const [nome, ...sobra] = posicionais;
     if (!nome || sobra.length > 0)
-        throw new Error('Uso: ai-harness banco-dados remover <nome>');
+        throw new Error('Uso: ai-harness banco-dados remover <nome> [--global]');
+    if (!marcadas.has('--global'))
+        return removerDoProjeto(ctx, nome);
     if (!removerConexao(nome, ctx.cadastro)) {
         ctx.erro(`Conexão ${nome} não existe em ${ctx.cadastro}.`);
         return 1;
@@ -387,7 +398,34 @@ function remover(ctx, argv) {
     ctx.log(`Conexão ${nome} removida de ${ctx.cadastro}.`);
     return 0;
 }
-/** `ai-harness banco-dados <subcomando>`: cadastro de conexões da máquina e escolha das conexões do projeto. */
+function removerDoProjeto(ctx, nome) {
+    validarSettingsLocal(ctx.cwd);
+    validarConfigParaEscrita(ctx.cwd);
+    const removida = removerConexaoProjeto(ctx.cwd, nome);
+    if (removida === null) {
+        const noCadastro = nome in lerCadastro(ctx.cadastro).conexoes;
+        ctx.erro(`Conexão ${nome} não está em banco_dados.conexoes de ${CONFIG_PATH}.${noCadastro ? ` Para o cadastro desta máquina, use remover ${nome} --global.` : ''}`);
+        return 1;
+    }
+    ctx.log(`Conexão ${nome} removida de banco_dados.conexoes de ${CONFIG_PATH}.`);
+    const variavel = typeof removida === 'string' ? undefined : removida.dsn_env;
+    if (variavel === undefined)
+        return 0;
+    const atual = lerEnvSettingsLocal(ctx.cwd)[variavel];
+    if (atual !== undefined)
+        ctx.sensiveis.push(sensivel(atual));
+    const outra = Object.values(readConfig(ctx.cwd).config.banco_dados.projeto).find((conexao) => conexao.dsn_env === variavel);
+    if (outra)
+        ctx.log(`Variável ${variavel} mantida em ${SETTINGS_LOCAL_PATH}: a conexão ${outra.nome} também a usa.`);
+    else if (removerVariavelSettingsLocal(ctx.cwd, variavel).changed)
+        ctx.log(`Variável ${variavel} removida de ${SETTINGS_LOCAL_PATH}.`);
+    ctx.log(`Se ${variavel} estiver definida no .env ou no ambiente, ela não foi tocada.`);
+    return 0;
+}
+/**
+ * `ai-harness banco-dados <subcomando>`: conexões do projeto (padrão), cadastro global de conexões da máquina
+ * (`--global`) e escolha das conexões do cadastro que o projeto usa.
+ */
 export async function runBancoCommand(argv, opcoes = {}) {
     const saida = opcoes.saida ?? { log: (texto) => console.log(texto), erro: (texto) => console.error(texto) };
     const cadastro = opcoes.caminhoCadastro ?? caminhoCadastro();

package/dist/banco-dados/conexao.js

@@ -118,7 +118,7 @@ export function resolverConexoes(raiz, opcoes = {}) {
 }
 export function escolherConexao(resolvidas, nome) {
     if (resolvidas.length === 0) {
-        throw new Error('Nenhuma conexão de banco configurada neste projeto; rode npx @fontdata/ai-harness banco-dados usar <nome>');
+        throw new Error('Nenhuma conexão de banco configurada neste projeto; rode npx @fontdata/ai-harness banco-dados adicionar <nome> na raiz do projeto');
     }
     const escolhida = nome === undefined ? resolvidas[0] : resolvidas.find((conexao) => conexao.nome === nome);
     if (!escolhida)

package/dist/banco-dados/ferramentas.js

@@ -55,16 +55,15 @@ export const INSTRUCOES = [
     'Use estas ferramentas para ler o banco de dados do projeto; o acesso é somente leitura.',
     'Nunca peça nem repita credenciais, senhas ou DSNs no chat.',
     'As conexões vêm do cadastro da máquina ou do projeto: uma conexão do projeto é declarada em banco_dados.conexoes do .ai-harness/config.json com dsn_env (o nome da variável), e o valor da variável fica no .claude/settings.local.json, no .env ou no ambiente.',
-    'Sem conexão configurada, oriente o usuário a rodar no terminal `npx @fontdata/ai-harness banco-dados adicionar <nome>` e, no projeto, `npx @fontdata/ai-harness banco-dados usar <nome>`.',
+    'Sem conexão configurada, oriente o usuário a rodar na raiz do projeto `npx @fontdata/ai-harness banco-dados adicionar <nome>`.',
     'Se a variável de uma conexão do projeto não estiver definida, oriente a defini-la no .claude/settings.local.json, no .env ou no ambiente.',
     'Antes de consultar, rode listar_tabelas e descrever_tabela para conhecer o esquema.',
     'Em consultar, selecione só as colunas necessárias e filtre as linhas; evite SELECT *.',
     'Somente leitura: comandos que alteram dados ou esquema são recusados.',
     'Os dados pessoais (CPF, e-mail, telefone, nome e afins) vêm mascarados, e o rodapé de consultar diz o que foi mascarado. Não tente contornar o mascaramento: não concatene, fatie, converta nem compare valores para reconstruir o original. Peça só as colunas necessárias.',
 ].join('\n');
-const ORIENTACAO_USAR = 'rode npx @fontdata/ai-harness banco-dados usar <nome> no projeto';
 function orientarAdicionar(nome) {
-    return `Conexão ${nome} não encontrada nesta máquina; rode npx @fontdata/ai-harness banco-dados adicionar ${nome}`;
+    return `Conexão ${nome} não encontrada nesta máquina; rode npx @fontdata/ai-harness banco-dados adicionar ${nome} --global`;
 }
 function orientarVariavel(nome, variavel) {
     return `A variável ${variavel} da conexão ${nome} não está definida; defina-a no .claude/settings.local.json, no .env ou no ambiente`;
@@ -84,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 ')}.`;
 }
@@ -173,7 +181,7 @@ async function executar(nome, args, contexto, banco, resolvidas) {
         if (descartadas.length > 0)
             dados.descartadas = descartadas;
         if (conexoes.length + faltando.length + variaveisAusentes.length + descartadas.length === 0) {
-            dados.orientacao = `Nenhuma conexão configurada; rode npx @fontdata/ai-harness banco-dados adicionar <nome> e ${ORIENTACAO_USAR}`;
+            dados.orientacao = 'Nenhuma conexão configurada; rode npx @fontdata/ai-harness banco-dados adicionar <nome> na raiz do projeto';
         }
         if (resolvidas.problemas.length > 0)
             dados.problemas = resolvidas.problemas;

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/config/config.js

@@ -301,6 +301,30 @@ export function gravarConexaoProjeto(root, conexao, { substituir = false } = {})
     const base = raw ?? lerJsonParaEscrita(file, 'banco_dados.conexoes');
     writeFileSync(file, `${JSON.stringify(comSecaoBanco(base, { ...banco, conexoes: proximas }), null, 2)}\n`);
 }
+/**
+ * Tira de `banco_dados.conexoes` a primeira entrada com o nome (objeto, mesmo inválido, ou texto), preservando
+ * o resto do JSON, e devolve o que leu. Sem config ou sem o nome, devolve null e não escreve.
+ * JSON inválido ou `conexoes` que não é lista lança sem tocar no arquivo.
+ */
+export function removerConexaoProjeto(root, nome) {
+    const file = join(root, CONFIG_PATH);
+    if (!existsSync(file))
+        return null;
+    const raw = lerJsonParaEscrita(file, 'banco_dados.conexoes');
+    const banco = secaoBanco(raw);
+    const conexoes = banco.conexoes === undefined ? [] : banco.conexoes;
+    if (!Array.isArray(conexoes))
+        throw new Error(`banco_dados.conexoes em ${CONFIG_PATH} não é uma lista; corrija-o antes de remover a conexão ${nome}.`);
+    const posicao = conexoes.findIndex((entrada) => (isObject(entrada) ? entrada.nome : entrada) === nome);
+    if (posicao === -1)
+        return null;
+    const entrada = conexoes[posicao];
+    const proximas = conexoes.filter((_atual, i) => i !== posicao);
+    writeFileSync(file, `${JSON.stringify(comSecaoBanco(raw, { ...banco, conexoes: proximas }), null, 2)}\n`);
+    if (!isObject(entrada))
+        return nome;
+    return typeof entrada.dsn_env === 'string' ? { nome, dsn_env: entrada.dsn_env } : { nome };
+}
 /**
  * Grava só `banco_dados.registrar_mcp`, preservando o resto do JSON; sem config, cria uma com os padrões
  * e essa chave. JSON inválido é recusado sem tocar no arquivo.

package/dist/doctor/checks.js

@@ -425,7 +425,7 @@ function checkBancoProjeto(root, config, env) {
             id: 'banco-variavel-ausente',
             severidade: 'aviso',
             mensagem: `A conexão ${nome}, declarada em banco_dados.conexoes de ${join(root, CONFIG_PATH)}, lê o DSN da variável ${dsn_env}, que não está definida no ambiente, em ${SETTINGS_LOCAL_PATH} nem no .env.`,
-            correcao: `Defina ${dsn_env} com \`npx @fontdata/ai-harness banco-dados adicionar ${nome} --projeto\` ou no ambiente do terminal.`,
+            correcao: `Defina ${dsn_env} com \`npx @fontdata/ai-harness banco-dados adicionar ${nome}\` ou no ambiente do terminal.`,
         });
     }
     const envLocal = lerEnvSettingsLocal(root);
@@ -487,7 +487,7 @@ export function checkBanco(root, config, env = process.env) {
             id: 'banco-conexao-ausente',
             severidade: 'aviso',
             mensagem: `A conexão ${nome}, citada em banco_dados.conexoes de ${join(root, CONFIG_PATH)}, não está no cadastro desta máquina (${caminho}).`,
-            correcao: `Cadastre-a com \`npx @fontdata/ai-harness banco-dados adicionar ${nome}\`.`,
+            correcao: `Cadastre-a com \`npx @fontdata/ai-harness banco-dados adicionar ${nome} --global\`.`,
         });
     }
     for (const nome of doCadastro.filter((nome) => conexoes[nome]?.mascaramento === false)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fontdata/ai-harness",
-  "version": "3.0.0",
+  "version": "3.1.1",
   "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": {