@fontdata/ai-harness 2.7.0 → 3.1.0

package/dist/config/config.js

@@ -16,13 +16,53 @@ export const TIPOS_CONEXAO_PROJETO = ['postgres', 'mariadb', 'sqlite'];
 function isObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+/** Seção do banco no config; até a 2.7.0 ela se chamava `banco`. */
+export const BANCO_CHAVE = 'banco_dados';
+export const BANCO_CHAVE_LEGADA = 'banco';
+/** Só a seção com o nome antigo existe: ela vale e o update a renomeia. */
+function soSecaoLegada(raw) {
+    return !(BANCO_CHAVE in raw) && BANCO_CHAVE_LEGADA in raw;
+}
+/** A seção do banco no JSON bruto: `banco_dados`, ou a `banco` antiga quando só ela existe. */
+export function secaoBanco(raw) {
+    const secao = soSecaoLegada(raw) ? raw[BANCO_CHAVE_LEGADA] : raw[BANCO_CHAVE];
+    return isObject(secao) ? secao : {};
+}
+/** O JSON com a seção do banco gravada como `banco_dados`; a `banco` antiga é trocada na mesma posição. */
+export function comSecaoBanco(raw, secao) {
+    if (!soSecaoLegada(raw))
+        return { ...raw, [BANCO_CHAVE]: secao };
+    return Object.fromEntries(Object.entries(raw).map(([chave, valor]) => (chave === BANCO_CHAVE_LEGADA ? [BANCO_CHAVE, secao] : [chave, valor])));
+}
+function lerJsonBruto(root) {
+    try {
+        const parsed = JSON.parse(readFileSync(join(root, CONFIG_PATH), 'utf8'));
+        return isObject(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** O config ainda tem a seção do banco com o nome antigo (`banco`), que o update renomeia. */
+export function temSecaoBancoLegada(root) {
+    const raw = lerJsonBruto(root);
+    return raw !== undefined && soSecaoLegada(raw);
+}
+/** Renomeia a seção `banco` para `banco_dados`, preservando o resto do JSON; devolve se mudou. */
+export function migrarSecaoBanco(root) {
+    const raw = lerJsonBruto(root);
+    if (!raw || !soSecaoLegada(raw))
+        return false;
+    writeFileSync(join(root, CONFIG_PATH), `${JSON.stringify(comSecaoBanco(raw, secaoBanco(raw)), null, 2)}\n`);
+    return true;
+}
 export function defaultConfig() {
     return {
         config_versao: CONFIG_VERSION,
         hooks: { ...DEFAULT_HOOK_MODES },
         rastro: { versionar: false },
         bloqueios: { dias_para_aviso: 7 },
-        banco: {
+        banco_dados: {
             conexoes: [],
             producao: 'bloqueio',
             limite_linhas: 200,
@@ -41,23 +81,23 @@ const SO_NO_CADASTRO = 'O mascaramento LGPD só pode ser desligado no cadastro d
 const REGRA_DE_COLUNA = /^[^.\s]+(\.[^.\s]+){0,2}$/;
 function lerLgpd(raw, lgpd, problems) {
     if (!isObject(raw)) {
-        problems.push(`banco.lgpd deve ser um objeto com mascarar_colunas e liberar_colunas em ${CONFIG_PATH}.`);
+        problems.push(`banco_dados.lgpd deve ser um objeto com mascarar_colunas e liberar_colunas em ${CONFIG_PATH}.`);
         return;
     }
     if ('desligar' in raw)
-        problems.push(`${SO_NO_CADASTRO}; banco.lgpd.desligar em ${CONFIG_PATH} foi ignorado.`);
+        problems.push(`${SO_NO_CADASTRO}; banco_dados.lgpd.desligar em ${CONFIG_PATH} foi ignorado.`);
     for (const chave of ['mascarar_colunas', 'liberar_colunas']) {
         if (!(chave in raw))
             continue;
         const lista = raw[chave];
         if (!Array.isArray(lista)) {
-            problems.push(`banco.lgpd.${chave} deve ser uma lista de colunas em ${CONFIG_PATH}.`);
+            problems.push(`banco_dados.lgpd.${chave} deve ser uma lista de colunas em ${CONFIG_PATH}.`);
             continue;
         }
         lgpd[chave] = lista.filter((regra) => {
             if (typeof regra === 'string' && REGRA_DE_COLUNA.test(regra))
                 return true;
-            problems.push(`Entrada ${JSON.stringify(regra)} ignorada em banco.lgpd.${chave} de ${CONFIG_PATH}; use coluna, tabela.coluna ou schema.tabela.coluna.`);
+            problems.push(`Entrada ${JSON.stringify(regra)} ignorada em banco_dados.lgpd.${chave} de ${CONFIG_PATH}; use coluna, tabela.coluna ou schema.tabela.coluna.`);
             return false;
         });
     }
@@ -83,7 +123,7 @@ function motivoConexaoInvalida(entrada) {
 function lerConexoes(conexoes, banco, problems) {
     banco.declarado = !(Array.isArray(conexoes) && conexoes.length === 0);
     if (!Array.isArray(conexoes)) {
-        problems.push(`banco.conexoes deve ser uma lista de nomes ou de objetos { nome, dsn_env } em ${CONFIG_PATH}.`);
+        problems.push(`banco_dados.conexoes deve ser uma lista de nomes ou de objetos { nome, dsn_env } em ${CONFIG_PATH}.`);
         return;
     }
     for (const entrada of conexoes) {
@@ -94,17 +134,17 @@ function lerConexoes(conexoes, banco, problems) {
         else if (isObject(entrada)) {
             const motivo = motivoConexaoInvalida(entrada);
             if (motivo) {
-                problems.push(`Entrada ${citada} descartada em banco.conexoes de ${CONFIG_PATH}: ${motivo}.`);
+                problems.push(`Entrada ${citada} descartada em banco_dados.conexoes de ${CONFIG_PATH}: ${motivo}.`);
                 continue;
             }
             nome = entrada.nome;
         }
         else {
-            problems.push(`Entrada ${citada} descartada em banco.conexoes de ${CONFIG_PATH}; use um nome (texto não vazio) ou um objeto { nome, dsn_env }.`);
+            problems.push(`Entrada ${citada} descartada em banco_dados.conexoes de ${CONFIG_PATH}; use um nome (texto não vazio) ou um objeto { nome, dsn_env }.`);
             continue;
         }
         if (banco.conexoes.includes(nome)) {
-            problems.push(`Entrada ${citada} descartada em banco.conexoes de ${CONFIG_PATH}: o nome "${nome}" já foi declarado antes.`);
+            problems.push(`Entrada ${citada} descartada em banco_dados.conexoes de ${CONFIG_PATH}: o nome "${nome}" já foi declarado antes.`);
             continue;
         }
         banco.conexoes.push(nome);
@@ -112,8 +152,8 @@ function lerConexoes(conexoes, banco, problems) {
             continue;
         for (const chave of Object.keys(entrada).filter((chave) => !CHAVES_CONEXAO_PROJETO.includes(chave))) {
             problems.push(chave === 'mascaramento'
-                ? `${SO_NO_CADASTRO}; mascaramento da entrada ${citada} em banco.conexoes de ${CONFIG_PATH} foi ignorado.`
-                : `Chave desconhecida ${chave} ignorada na entrada ${citada} de banco.conexoes em ${CONFIG_PATH}.`);
+                ? `${SO_NO_CADASTRO}; mascaramento da entrada ${citada} em banco_dados.conexoes de ${CONFIG_PATH} foi ignorado.`
+                : `Chave desconhecida ${chave} ignorada na entrada ${citada} de banco_dados.conexoes em ${CONFIG_PATH}.`);
         }
         banco.projeto[nome] = {
             nome,
@@ -130,28 +170,28 @@ function lerBanco(raw, banco, problems) {
         if (MODOS_PRODUCAO.includes(raw.producao))
             banco.producao = raw.producao;
         else
-            problems.push(`Modo "${String(raw.producao)}" inválido para banco.producao em ${CONFIG_PATH}; use aviso ou bloqueio.`);
+            problems.push(`Modo "${String(raw.producao)}" inválido para banco_dados.producao em ${CONFIG_PATH}; use aviso ou bloqueio.`);
     }
     if ('limite_linhas' in raw) {
         if (inteiroEntre(raw.limite_linhas, 1, 5000))
             banco.limite_linhas = raw.limite_linhas;
         else
-            problems.push(`banco.limite_linhas deve ser um inteiro de 1 a 5000 em ${CONFIG_PATH}.`);
+            problems.push(`banco_dados.limite_linhas deve ser um inteiro de 1 a 5000 em ${CONFIG_PATH}.`);
     }
     if ('timeout_segundos' in raw) {
         if (inteiroEntre(raw.timeout_segundos, 1, 600))
             banco.timeout_segundos = raw.timeout_segundos;
         else
-            problems.push(`banco.timeout_segundos deve ser um inteiro de 1 a 600 em ${CONFIG_PATH}.`);
+            problems.push(`banco_dados.timeout_segundos deve ser um inteiro de 1 a 600 em ${CONFIG_PATH}.`);
     }
     if ('registrar_mcp' in raw) {
         if (typeof raw.registrar_mcp === 'boolean')
             banco.registrar_mcp = raw.registrar_mcp;
         else
-            problems.push(`banco.registrar_mcp deve ser true ou false em ${CONFIG_PATH}.`);
+            problems.push(`banco_dados.registrar_mcp deve ser true ou false em ${CONFIG_PATH}.`);
     }
     if ('mascaramento' in raw)
-        problems.push(`${SO_NO_CADASTRO}; banco.mascaramento em ${CONFIG_PATH} foi ignorado.`);
+        problems.push(`${SO_NO_CADASTRO}; banco_dados.mascaramento em ${CONFIG_PATH} foi ignorado.`);
     if ('lgpd' in raw)
         lerLgpd(raw.lgpd, banco.lgpd, problems);
 }
@@ -192,17 +232,24 @@ export function readConfig(root) {
         else
             problems.push(`bloqueios.dias_para_aviso deve ser um inteiro positivo em ${CONFIG_PATH}.`);
     }
-    if (isObject(raw.banco))
-        lerBanco(raw.banco, config.banco, problems);
+    const secao = soSecaoLegada(raw) ? raw[BANCO_CHAVE_LEGADA] : raw[BANCO_CHAVE];
+    if (isObject(secao))
+        lerBanco(secao, config.banco_dados, problems);
+    if (soSecaoLegada(raw)) {
+        problems.push(`A seção banco de ${CONFIG_PATH} agora se chama banco_dados; rode npx @fontdata/ai-harness update --yes para renomeá-la.`);
+    }
+    else if (BANCO_CHAVE_LEGADA in raw) {
+        problems.push(`A seção banco de ${CONFIG_PATH} foi ignorada: vale a banco_dados. Apague a banco.`);
+    }
     return { config, problems };
 }
-/** Cria a config com os padrões, sem a seção banco; retorna false se já existia (nunca sobrescreve). */
+/** Cria a config com os padrões, sem a seção banco_dados; retorna false se já existia (nunca sobrescreve). */
 export function writeDefaultConfig(root) {
     const file = join(root, CONFIG_PATH);
     if (existsSync(file))
         return false;
     mkdirSync(dirname(file), { recursive: true });
-    const { banco: _banco, ...gravada } = defaultConfig();
+    const { banco_dados: _banco, ...gravada } = defaultConfig();
     writeFileSync(file, `${JSON.stringify(gravada, null, 2)}\n`);
     return true;
 }
@@ -222,10 +269,10 @@ function lerJsonParaEscrita(file, chave) {
 export function validarConfigParaEscrita(root) {
     const file = join(root, CONFIG_PATH);
     if (existsSync(file))
-        lerJsonParaEscrita(file, 'banco.conexoes');
+        lerJsonParaEscrita(file, 'banco_dados.conexoes');
 }
 /**
- * Grava a conexão em `banco.conexoes`, preservando o resto do JSON; sem config, cria uma com os padrões.
+ * Grava a conexão em `banco_dados.conexoes`, preservando o resto do JSON; sem config, cria uma com os padrões.
  * Se o nome já existir (objeto ou string), lança, ou troca a entrada na mesma posição com `substituir`.
  * JSON inválido é recusado sem tocar no arquivo.
  */
@@ -234,14 +281,14 @@ export function gravarConexaoProjeto(root, conexao, { substituir = false } = {})
     if (motivo)
         throw new Error(`Conexão ${JSON.stringify(conexao.nome)} inválida: ${motivo}.`);
     const file = join(root, CONFIG_PATH);
-    const raw = existsSync(file) ? lerJsonParaEscrita(file, 'banco.conexoes') : undefined;
-    const banco = raw && isObject(raw.banco) ? raw.banco : {};
+    const raw = existsSync(file) ? lerJsonParaEscrita(file, 'banco_dados.conexoes') : undefined;
+    const banco = raw ? secaoBanco(raw) : {};
     const conexoes = banco.conexoes === undefined ? [] : banco.conexoes;
     if (!Array.isArray(conexoes))
-        throw new Error(`banco.conexoes em ${CONFIG_PATH} não é uma lista; corrija-o antes de gravar a conexão ${conexao.nome}.`);
+        throw new Error(`banco_dados.conexoes em ${CONFIG_PATH} não é uma lista; corrija-o antes de gravar a conexão ${conexao.nome}.`);
     const posicao = conexoes.findIndex((entrada) => (isObject(entrada) ? entrada.nome : entrada) === conexao.nome);
     if (posicao !== -1 && !substituir)
-        throw new Error(`A conexão ${conexao.nome} já está em banco.conexoes de ${CONFIG_PATH}.`);
+        throw new Error(`A conexão ${conexao.nome} já está em banco_dados.conexoes de ${CONFIG_PATH}.`);
     const entrada = {
         nome: conexao.nome,
         dsn_env: conexao.dsn_env,
@@ -251,28 +298,52 @@ export function gravarConexaoProjeto(root, conexao, { substituir = false } = {})
     const proximas = posicao === -1 ? [...conexoes, entrada] : conexoes.map((atual, i) => (i === posicao ? entrada : atual));
     if (!raw)
         writeDefaultConfig(root);
-    const base = raw ?? lerJsonParaEscrita(file, 'banco.conexoes');
-    writeFileSync(file, `${JSON.stringify({ ...base, banco: { ...banco, conexoes: proximas } }, null, 2)}\n`);
+    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.registrar_mcp`, preservando o resto do JSON; sem config, cria uma com os padrões
+ * 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.
  */
 export function gravarRegistrarMcp(root, valor) {
     const file = join(root, CONFIG_PATH);
     let raw;
     if (existsSync(file)) {
-        raw = lerJsonParaEscrita(file, 'banco.registrar_mcp');
+        raw = lerJsonParaEscrita(file, 'banco_dados.registrar_mcp');
     }
     else {
-        const { banco: _banco, ...padrao } = defaultConfig();
+        const { banco_dados: _banco, ...padrao } = defaultConfig();
         raw = padrao;
     }
-    const banco = isObject(raw.banco) ? raw.banco : {};
+    const banco = secaoBanco(raw);
     if (banco.registrar_mcp === valor)
         return;
     mkdirSync(dirname(file), { recursive: true });
-    writeFileSync(file, `${JSON.stringify({ ...raw, banco: { ...banco, registrar_mcp: valor } }, null, 2)}\n`);
+    writeFileSync(file, `${JSON.stringify(comSecaoBanco(raw, { ...banco, registrar_mcp: valor }), null, 2)}\n`);
 }
 const BLOCK_START = '# ai-harness (gerenciado pelo harness; não edite entre estas linhas)';
 const BLOCK_END = '# /ai-harness';

package/dist/doctor/checks.js

@@ -1,8 +1,8 @@
 import { execFileSync, spawnSync } from 'node:child_process';
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
-import { lerEnvSettingsLocal, lerVariavel, SETTINGS_LOCAL_PATH } from '../banco/ambiente.js';
-import { caminhoCadastro, lerCadastro } from '../banco/cadastro.js';
+import { lerEnvSettingsLocal, lerVariavel, SETTINGS_LOCAL_PATH } from '../banco-dados/ambiente.js';
+import { caminhoCadastro, lerCadastro } from '../banco-dados/cadastro.js';
 import { allCommands, loadCatalog } from '../catalog.js';
 import { CONFIG_PATH, readConfig } from '../config/config.js';
 import { readArtifact, validateAllWorks, WORKS_DIR } from '../contratos/artefatos.js';
@@ -414,7 +414,7 @@ function settingsLocalIgnorado(root, env) {
         .some((linha) => LINHAS_IGNORE_SETTINGS_LOCAL.has(linha));
 }
 function checkBancoProjeto(root, config, env) {
-    const conexoes = config.banco.conexoes.flatMap((nome) => config.banco.projeto[nome] ?? []);
+    const conexoes = config.banco_dados.conexoes.flatMap((nome) => config.banco_dados.projeto[nome] ?? []);
     if (!conexoes.length)
         return [];
     const findings = [];
@@ -424,8 +424,8 @@ function checkBancoProjeto(root, config, env) {
         findings.push({
             id: 'banco-variavel-ausente',
             severidade: 'aviso',
-            mensagem: `A conexão ${nome}, declarada em banco.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 adicionar ${nome} --projeto\` ou no ambiente do terminal.`,
+            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}\` ou no ambiente do terminal.`,
         });
     }
     const envLocal = lerEnvSettingsLocal(root);
@@ -453,12 +453,12 @@ function checkBancoProjeto(root, config, env) {
     }
     return findings;
 }
-/** Confere o cadastro desta máquina e as variáveis das conexões do projeto contra `banco.conexoes`, sem abrir conexão. */
+/** Confere o cadastro desta máquina e as variáveis das conexões do projeto contra `banco_dados.conexoes`, sem abrir conexão. */
 export function checkBanco(root, config, env = process.env) {
-    if (!config.banco.conexoes.length)
+    if (!config.banco_dados.conexoes.length)
         return [];
     const findings = checkBancoProjeto(root, config, env);
-    const doCadastro = config.banco.conexoes.filter((nome) => !(nome in config.banco.projeto));
+    const doCadastro = config.banco_dados.conexoes.filter((nome) => !(nome in config.banco_dados.projeto));
     if (!doCadastro.length)
         return findings;
     const caminho = caminhoCadastro(env);
@@ -486,8 +486,8 @@ export function checkBanco(root, config, env = process.env) {
         findings.push({
             id: 'banco-conexao-ausente',
             severidade: 'aviso',
-            mensagem: `A conexão ${nome}, citada em banco.conexoes de ${join(root, CONFIG_PATH)}, não está no cadastro desta máquina (${caminho}).`,
-            correcao: `Cadastre-a com \`npx @fontdata/ai-harness banco adicionar ${nome}\`.`,
+            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} --global\`.`,
         });
     }
     for (const nome of doCadastro.filter((nome) => conexoes[nome]?.mascaramento === false)) {

package/dist/init.js

@@ -14,7 +14,7 @@ const PLUGIN_HOOKS_NOTE = 'O plugin fontdata@ai-harness está habilitado: os hoo
 const PLUGIN_MCP_NOTE = 'O plugin fontdata@ai-harness está habilitado: o servidor MCP de banco já roda por ele e não foi registrado no .mcp.json, para não duplicar.';
 /** Registra o MCP de banco no .mcp.json quando não foi recusado (flag, wizard ou config) e o plugin não o fornece. */
 export function decidirRegistroMcp(options, root, home = homedir()) {
-    return options.mcpBanco && readConfig(root).config.banco.registrar_mcp && !isHarnessPluginEnabled(root, home);
+    return options.mcpBanco && readConfig(root).config.banco_dados.registrar_mcp && !isHarnessPluginEnabled(root, home);
 }
 function applyMcpDecision(plan, options, root) {
     plan.registerMcp = decidirRegistroMcp(options, root);

package/dist/install/flags.js

@@ -7,7 +7,7 @@ const CLAUDE_MD = {
 };
 const CONFLICTS = { sobrescrever: 'overwrite', pular: 'skip' };
 const VALUE_FLAGS = ['--escopo', '--comandos', '--claude-md', '--conflito'];
-const BOOLEAN_FLAGS = ['--sem-harness', '--sem-hooks', '--sem-agents', '--sem-comentarios', '--sem-banco', '--yes', '-y', '--sim'];
+const BOOLEAN_FLAGS = ['--sem-harness', '--sem-hooks', '--sem-agents', '--sem-comentarios', '--sem-banco-dados', '--yes', '-y', '--sim'];
 function pick(flag, value, options) {
     const chosen = options[value];
     if (chosen === undefined) {
@@ -28,8 +28,13 @@ function distance(a, b) {
     }
     return row[b.length] ?? 0;
 }
+/** Flags que mudaram de nome: o erro aponta a nova, que a distância de edição não alcança. */
+const RENAMED_FLAGS = { '--sem-banco': '--sem-banco-dados' };
 /** Flag conhecida mais parecida com a digitada, para sugerir em mensagens de erro. */
 export function suggestFlag(token, flags) {
+    const renamed = RENAMED_FLAGS[token];
+    if (renamed && flags.includes(renamed))
+        return renamed;
     const [best] = flags
         .map((flag) => ({ flag, d: distance(token, flag) }))
         .filter(({ d }) => d <= 2)
@@ -69,7 +74,7 @@ export function parseInitArgs(argv) {
                 args.agents = false;
             else if (token === '--sem-comentarios')
                 args.comments = false;
-            else if (token === '--sem-banco')
+            else if (token === '--sem-banco-dados')
                 args.mcpBanco = false;
             else
                 args.yes = true;

package/dist/install/mcp.js

@@ -2,13 +2,17 @@ import { copyFileSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { timestamp } from './settings.js';
 export const MCP_PATH = '.mcp.json';
+/** Nome do servidor de banco no `.mcp.json`; as ferramentas ficam `mcp__banco_dados__*`. */
+export const BANCO_MCP_NOME = 'banco_dados';
+/** Nome do servidor até a 2.7.0; a entrada gerenciada com ele é trocada pela nova no update. */
+export const BANCO_MCP_NOME_LEGADO = 'banco';
 const PIN_PREFIX = '@fontdata/ai-harness@';
 function isPlainObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 /** Servidor MCP de banco com a versão do pacote fixada no npx, no mesmo formato do plugin. */
 export function bancoMcpServer(versao) {
-    return { command: 'npx', args: ['-y', `${PIN_PREFIX}${versao}`, 'banco-mcp'] };
+    return { command: 'npx', args: ['-y', `${PIN_PREFIX}${versao}`, 'banco-dados-mcp'] };
 }
 function pinOf(entrada) {
     if (!isPlainObject(entrada) || !Array.isArray(entrada.args))
@@ -22,9 +26,10 @@ export function ehEntradaGerenciada(entrada) {
 /**
  * Acrescenta os servidores ausentes em `mcpServers` do `.mcp.json`, preservando o resto. Com
  * `atualizarGerenciada`, regrava também a entrada gerenciada que fixa outra versão; entrada
- * personalizada nunca é tocada. Backup datado só quando muda; JSON inválido é recusado sem tocar.
+ * personalizada nunca é tocada. Os nomes de `removerGerenciadas` saem só quando a entrada é gerenciada. Backup
+ * datado só quando muda; JSON inválido é recusado sem tocar.
  */
-export function mergeMcpServers(root, servidores, now = new Date(), { atualizarGerenciada = false } = {}) {
+export function mergeMcpServers(root, servidores, now = new Date(), { atualizarGerenciada = false, removerGerenciadas = [] } = {}) {
     const file = join(root, MCP_PATH);
     const original = existsSync(file) ? readFileSync(file, 'utf8') : null;
     let config = {};
@@ -43,6 +48,12 @@ export function mergeMcpServers(root, servidores, now = new Date(), { atualizarG
     }
     const mcpServers = { ...(config.mcpServers ?? {}) };
     let changed = false;
+    for (const nome of removerGerenciadas) {
+        if (!ehEntradaGerenciada(mcpServers[nome]))
+            continue;
+        delete mcpServers[nome];
+        changed = true;
+    }
     for (const [nome, servidor] of Object.entries(servidores)) {
         const atual = mcpServers[nome];
         if (atual === undefined) {

package/dist/install/plan.js

@@ -6,10 +6,10 @@ import { applyAtomically } from './atomic.js';
 import { buildLockItem, LOCK_VERSION, readLock, writeLock } from './lock.js';
 import { HOOKS_ITEM_ID, PROJECT_HOOKS_DIR, projectHooksConfig } from './hooks.js';
 import { neededSkillsFor, resolveSelection } from './selection.js';
-import { bancoMcpServer, MCP_PATH, mergeMcpServers } from './mcp.js';
+import { BANCO_MCP_NOME, bancoMcpServer, MCP_PATH, mergeMcpServers } from './mcp.js';
 import { gravarRegistrarMcp } from '../config/config.js';
 import { COMMENTS_RULE_PATH, commentsHooksConfig, ensureCommentsBaseline } from '../comentarios/instalar.js';
-import { combineHooks, HARNESS_DENY, HARNESS_PERMISSIONS, mergeSettings } from './settings.js';
+import { combineHooks, HARNESS_DENY, harnessPermissions, mergeSettings } from './settings.js';
 /** Rule de convenção com o que é específico do projeto (D-38): é do projeto, então fica fora do lock. */
 export const PROJECT_RULE_PATH = '.claude/rules/harness-projeto.md';
 /** Esqueleto da rule de projeto; os comandos `-legado` renomeados pelo update entram na última seção. */
@@ -165,12 +165,12 @@ export function executePlan(root, plan, pkg, now = new Date()) {
     const permission = needsEventPermission(plan);
     const hooks = combineHooks(plan.registerHooks ? projectHooksConfig() : {}, plan.registerComments ? commentsHooksConfig() : {});
     if (Object.keys(hooks).length || permission) {
-        mergeSettings(root, { hooks, allow: permission ? HARNESS_PERMISSIONS : [], deny: permission ? HARNESS_DENY : [] }, now);
+        mergeSettings(root, { hooks, allow: permission ? harnessPermissions({ banco: bancoAtivo(plan) }) : [], deny: permission ? HARNESS_DENY : [] }, now);
     }
     if (plan.registerComments)
         ensureCommentsBaseline(root);
     if (plan.registerMcp)
-        mergeMcpServers(root, { banco: bancoMcpServer(pkg.versao) }, now);
+        mergeMcpServers(root, { [BANCO_MCP_NOME]: bancoMcpServer(pkg.versao) }, now);
     if (plan.mcpRecusado)
         gravarRegistrarMcp(root, false);
     const items = new Map();
@@ -193,6 +193,10 @@ export function executePlan(root, plan, pkg, now = new Date()) {
     writeLock(root, lock);
     return lock;
 }
+/** O banco não foi recusado (`--sem-banco-dados` ou `banco_dados.registrar_mcp: false`): as permissões do MCP entram. */
+function bancoAtivo(plan) {
+    return !plan.mcpRecusado && plan.mcpSkipReason !== 'config';
+}
 /** Skills e agents do harness registram o rastro com `npx @fontdata/ai-harness evento`. */
 function needsEventPermission(plan) {
     return plan.items.some((item) => item.tipo === 'skill' || item.tipo === 'agent');
@@ -209,7 +213,7 @@ export function describePlan(plan) {
     if (plan.registerHooks)
         lines.push('Hooks do harness registrados em .claude/settings.json (sem duplicar os existentes).');
     if (needsEventPermission(plan)) {
-        lines.push(`Permissões ${HARNESS_PERMISSIONS.join(', ')} em .claude/settings.json, para o rastro, a checagem de conflitos, ` +
+        lines.push(`Permissões ${harnessPermissions({ banco: bancoAtivo(plan) }).join(', ')} em .claude/settings.json, para o rastro, a checagem de conflitos, ` +
             'o /git-commit-push, os sub-agents e as consultas de leitura não pedirem aprovação (inclusive no modo auto); ' +
             'o push forçado fica bloqueado em permissions.deny.');
     }
@@ -217,13 +221,13 @@ export function describePlan(plan) {
         lines.push(`Servidor MCP de banco (somente leitura) registrado em ${MCP_PATH}, sem duplicar os servidores existentes.`);
     }
     else if (plan.mcpRecusado) {
-        lines.push(`Servidor MCP de banco não registrado (recusado); a escolha fica em banco.registrar_mcp: false no .ai-harness/config.json.`);
+        lines.push(`Servidor MCP de banco não registrado (recusado); a escolha fica em banco_dados.registrar_mcp: false no .ai-harness/config.json.`);
     }
     else if (plan.mcpSkipReason === 'plugin') {
         lines.push(`Servidor MCP de banco não registrado em ${MCP_PATH}: o plugin fontdata@ai-harness já o fornece.`);
     }
     else if (plan.mcpSkipReason === 'config') {
-        lines.push(`Servidor MCP de banco não registrado em ${MCP_PATH}: banco.registrar_mcp está false no .ai-harness/config.json.`);
+        lines.push(`Servidor MCP de banco não registrado em ${MCP_PATH}: banco_dados.registrar_mcp está false no .ai-harness/config.json.`);
     }
     if (plan.registerComments) {
         lines.push('Padrão de comentários: rule carregada em toda sessão, hook que bloqueia a violação e catraca do legado (gerada só na primeira instalação).');

package/dist/install/settings.js

@@ -33,11 +33,14 @@ export const READ_PERMISSIONS = [
     'Bash(gh pr diff:*)',
     'Bash(npm outdated:*)',
 ];
+const BANCO_TOOLS = ['listar_conexoes', 'listar_tabelas', 'descrever_tabela', 'consultar'];
 /**
- * Ferramentas de esquema do servidor MCP de banco, registrado pelo `.mcp.json` ou pelo plugin. A `consultar`
- * fica de fora: lê linhas das tabelas e continua pedindo aprovação.
+ * Ferramentas do servidor MCP de banco, registrado pelo `.mcp.json` (`banco_dados`) ou pelo plugin
+ * (`banco_dados`). A `consultar` também é liberada: os dados pessoais chegam mascarados.
  */
-export const BANCO_PERMISSIONS = ['mcp__banco__', 'mcp__plugin_fontdata_banco__'].flatMap((prefixo) => ['listar_conexoes', 'listar_tabelas', 'descrever_tabela', 'consultar'].map((ferramenta) => `${prefixo}${ferramenta}`));
+export const BANCO_PERMISSIONS = ['mcp__banco_dados__', 'mcp__plugin_fontdata_banco_dados__'].flatMap((prefixo) => BANCO_TOOLS.map((ferramenta) => `${prefixo}${ferramenta}`));
+/** As mesmas regras com o nome antigo do servidor (`banco`, até a 2.7.0); o update as remove. */
+export const BANCO_PERMISSIONS_LEGADAS = ['mcp__banco__', 'mcp__plugin_fontdata_banco__'].flatMap((prefixo) => BANCO_TOOLS.map((ferramenta) => `${prefixo}${ferramenta}`));
 /** Regras de `permissions.allow` que o init e o update gravam para as skills e os agents do harness. */
 export const HARNESS_PERMISSIONS = [
     EVENT_PERMISSION,
@@ -48,6 +51,10 @@ export const HARNESS_PERMISSIONS = [
     ...READ_PERMISSIONS,
     ...BANCO_PERMISSIONS,
 ];
+/** As regras do harness; sem o banco (recusado com `--sem-banco-dados` ou `banco_dados.registrar_mcp: false`), sem as do MCP. */
+export function harnessPermissions({ banco }) {
+    return banco ? HARNESS_PERMISSIONS : HARNESS_PERMISSIONS.filter((rule) => !BANCO_PERMISSIONS.includes(rule));
+}
 /** O push liberado não vale para reescrever o histórico remoto: `deny` vence o `allow`. */
 export const HARNESS_DENY = [
     'Bash(git push --force:*)',
@@ -92,7 +99,7 @@ export function mergeHooksIntoSettings(root, hooks, now = new Date()) {
  * Acrescenta hooks e regras de `permissions.allow` ao `.claude/settings.json` do projeto
  * sem perder o que já existe. Um hook é considerado presente quando algum grupo do mesmo
  * evento já tem o mesmo `command`, e uma regra quando já está na lista, o que torna a
- * operação idempotente. Tudo é gravado de uma vez, com um único backup datado do arquivo
+ * operação idempotente. As regras de `removeAllow` saem de `permissions.allow`. Tudo é gravado de uma vez, com um único backup datado do arquivo
  * original; JSON inválido é recusado sem tocar em nada.
  */
 export function mergeSettings(root, additions, now = new Date()) {
@@ -155,6 +162,12 @@ export function mergeSettings(root, additions, now = new Date()) {
         }
         next.permissions = { ...permissions, [key]: list };
     }
+    const remove = additions.removeAllow ?? [];
+    const currentAllow = next.permissions?.allow;
+    if (remove.length && currentAllow?.some((rule) => remove.includes(rule))) {
+        next.permissions = { ...next.permissions, allow: currentAllow.filter((rule) => !remove.includes(rule)) };
+        changed = true;
+    }
     if (!changed)
         return { changed: false, backup: null };
     let backup = null;