@fontdata/ai-harness 2.6.0 → 3.0.0

package/dist/doctor/checks.js

@@ -1,6 +1,8 @@
-import { execFileSync } from 'node:child_process';
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
+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-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';
@@ -396,6 +398,108 @@ function checkConfig(problems) {
         correcao: `Corrija o ${CONFIG_PATH}; enquanto isso, valem os padrões (segurança em bloqueio, demais hooks em aviso).`,
     }));
 }
+const LINHAS_IGNORE_SETTINGS_LOCAL = new Set(['.claude/settings.local.json', '.claude/', '.claude', 'settings.local.json']);
+function settingsLocalIgnorado(root, env) {
+    const opcoes = { cwd: root, env: { ...process.env, ...env }, stdio: 'ignore', timeout: 5000 };
+    const repositorio = spawnSync('git', ['rev-parse', '--is-inside-work-tree'], opcoes);
+    if (!repositorio.error && repositorio.status === 0) {
+        return spawnSync('git', ['check-ignore', '-q', SETTINGS_LOCAL_PATH], opcoes).status === 0;
+    }
+    const gitignore = join(root, '.gitignore');
+    if (!existsSync(gitignore))
+        return false;
+    return readFileSync(gitignore, 'utf8')
+        .split(/\r?\n/)
+        .map((linha) => linha.trim().replace(/^\//, '').replace(/^\*\*\//, ''))
+        .some((linha) => LINHAS_IGNORE_SETTINGS_LOCAL.has(linha));
+}
+function checkBancoProjeto(root, config, env) {
+    const conexoes = config.banco_dados.conexoes.flatMap((nome) => config.banco_dados.projeto[nome] ?? []);
+    if (!conexoes.length)
+        return [];
+    const findings = [];
+    for (const { nome, dsn_env } of conexoes) {
+        if (lerVariavel(dsn_env, root, env))
+            continue;
+        findings.push({
+            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.`,
+        });
+    }
+    const envLocal = lerEnvSettingsLocal(root);
+    const variaveis = [...new Set(conexoes.map(({ dsn_env }) => dsn_env).filter((variavel) => envLocal[variavel]))];
+    if (!variaveis.length)
+        return findings;
+    const caminho = join(root, SETTINGS_LOCAL_PATH);
+    const lista = variaveis.join(', ');
+    if (!settingsLocalIgnorado(root, env)) {
+        findings.push({
+            id: 'banco-settings-local-versionado',
+            severidade: 'aviso',
+            mensagem: `O ${caminho} guarda o DSN de ${lista} e não está ignorado pelo git; a senha pode ir para o repositório.`,
+            correcao: `Acrescente ao .gitignore da raiz a linha \`.claude/settings.local.json\`. Se o arquivo já foi commitado, rode também \`git rm --cached .claude/settings.local.json\`.`,
+        });
+    }
+    const modo = process.platform !== 'win32' ? statSync(caminho).mode & 0o777 : 0;
+    if (modo & 0o077) {
+        findings.push({
+            id: 'banco-settings-local-permissao',
+            severidade: 'aviso',
+            mensagem: `O ${caminho} guarda o DSN de ${lista} e pode ser lido por outros usuários desta máquina (modo ${modo.toString(8)}).`,
+            correcao: `Restrinja ao seu usuário: \`chmod 600 ${caminho}\`.`,
+        });
+    }
+    return findings;
+}
+/** 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_dados.conexoes.length)
+        return [];
+    const findings = checkBancoProjeto(root, config, env);
+    const doCadastro = config.banco_dados.conexoes.filter((nome) => !(nome in config.banco_dados.projeto));
+    if (!doCadastro.length)
+        return findings;
+    const caminho = caminhoCadastro(env);
+    const modo = process.platform !== 'win32' && existsSync(caminho) ? statSync(caminho).mode & 0o777 : 0;
+    if (modo & 0o077) {
+        findings.push({
+            id: 'banco-cadastro-permissao',
+            severidade: 'aviso',
+            mensagem: `O cadastro de conexões ${caminho} pode ser lido por outros usuários desta máquina (modo ${modo.toString(8)}).`,
+            correcao: `Restrinja ao seu usuário: \`chmod 600 ${caminho}\`.`,
+        });
+    }
+    const { conexoes, problemas } = lerCadastro(caminho);
+    for (const mensagem of problemas) {
+        findings.push({
+            id: 'banco-cadastro-invalido',
+            severidade: 'aviso',
+            mensagem,
+            correcao: `Corrija o JSON de ${caminho} (formato {"versao": 1, "conexoes": {...}}) ou recadastre as conexões.`,
+        });
+    }
+    if (problemas.length)
+        return findings;
+    for (const nome of doCadastro.filter((nome) => !(nome in conexoes))) {
+        findings.push({
+            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}\`.`,
+        });
+    }
+    for (const nome of doCadastro.filter((nome) => conexoes[nome]?.mascaramento === false)) {
+        findings.push({
+            id: 'banco-mascaramento-desligado',
+            severidade: 'aviso',
+            mensagem: `A conexão ${nome}, usada por este projeto, está com o mascaramento LGPD desligado no cadastro desta máquina (${caminho}).`,
+            correcao: `Os dados pessoais da conexão ${nome} chegam sem máscara ao Claude. Se não for de propósito, remova "mascaramento": false dela em ${caminho}.`,
+        });
+    }
+    return findings;
+}
 /** Diagnostica a instalação do harness no projeto; nunca altera arquivos. */
 export function runDoctor(root, options = {}) {
     const { findings: lockFindings, lock } = checkLock(root);
@@ -410,6 +514,7 @@ export function runDoctor(root, options = {}) {
         ...checkSettings(root),
         ...checkGitIgnore(root),
         ...checkConfig(configProblems),
+        ...checkBanco(root, config),
         ...checkWorks(root),
         ...checkStaleBlocks(root, options.now ?? new Date(), options.staleBlockDays ?? config.bloqueios.dias_para_aviso),
         ...checkEventLogs(root),

package/dist/init.js

@@ -1,5 +1,5 @@
 import { existsSync } from 'node:fs';
-import { EOL } from 'node:os';
+import { EOL, homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import * as p from '@clack/prompts';
 import { allCommands, loadCatalog, recommendedCommands } from './catalog.js';
@@ -11,6 +11,17 @@ import { describePlan, executePlan, packageInfo, planInstall, resolveInstallOpti
 import { detectProjectKind } from './install/selection.js';
 export { detectProjectKind, neededSkillsFor, resolveSelection } from './install/selection.js';
 const PLUGIN_HOOKS_NOTE = 'O plugin fontdata@ai-harness está habilitado: os hooks já rodam por ele e não foram instalados no projeto, para não rodarem duas vezes.';
+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_dados.registrar_mcp && !isHarnessPluginEnabled(root, home);
+}
+function applyMcpDecision(plan, options, root) {
+    plan.registerMcp = decidirRegistroMcp(options, root);
+    plan.mcpRecusado = !options.mcpBanco;
+    if (!plan.registerMcp && options.mcpBanco)
+        plan.mcpSkipReason = isHarnessPluginEnabled(root) ? 'plugin' : 'config';
+}
 /** Encerra o fluxo com mensagem amigável quando o usuário cancela (Ctrl+C). */
 function bail(value) {
     if (p.isCancel(value)) {
@@ -97,6 +108,7 @@ function runNonInteractive(args) {
     if (skippedForPlugin)
         options.hooks = false;
     const plan = planInstall(catalog, repoPath, options);
+    applyMcpDecision(plan, options, repoPath);
     const summary = [describePlan(plan), ...(skippedForPlugin ? [PLUGIN_HOOKS_NOTE] : [])].join(EOL + EOL);
     if (!args.yes) {
         console.log(`Simulação — nada foi gravado em ${repoPath}.\n\n${summary}\n\nRode de novo com --yes para aplicar.`);
@@ -184,6 +196,16 @@ async function runWizard(args) {
             initialValue: true,
         }));
     }
+    let mcpBanco = true;
+    if (isHarnessPluginEnabled(repoPath)) {
+        p.note(PLUGIN_MCP_NOTE, 'Banco');
+    }
+    else {
+        mcpBanco = bail(await p.confirm({
+            message: 'Registrar o servidor MCP de banco (somente leitura) no .mcp.json?',
+            initialValue: true,
+        }));
+    }
     const agents = bail(await p.confirm({
         message: 'Instalar os agents somente leitura do harness (revisor-testes, qa, investigador, auditor-plano)?',
         initialValue: true,
@@ -201,6 +223,7 @@ async function runWizard(args) {
         hooks,
         agents,
         comments,
+        mcpBanco,
     };
     let plan = planInstall(catalog, repoPath, options);
     // 6. Confirmação final
@@ -221,6 +244,7 @@ async function runWizard(args) {
         if (conflict === 'skip')
             plan = planInstall(catalog, repoPath, { ...options, conflict });
     }
+    applyMcpDecision(plan, options, repoPath);
     // Execução
     const s = p.spinner();
     s.start('Instalando...');

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', '--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)
@@ -48,6 +53,7 @@ export function parseInitArgs(argv) {
         hooks: undefined,
         agents: undefined,
         comments: undefined,
+        mcpBanco: undefined,
         yes: false,
         hasSelectionFlags: false,
     };
@@ -68,6 +74,8 @@ export function parseInitArgs(argv) {
                 args.agents = false;
             else if (token === '--sem-comentarios')
                 args.comments = false;
+            else if (token === '--sem-banco-dados')
+                args.mcpBanco = false;
             else
                 args.yes = true;
             continue;

package/dist/install/mcp.js

@@ -0,0 +1,77 @@
+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-dados-mcp'] };
+}
+function pinOf(entrada) {
+    if (!isPlainObject(entrada) || !Array.isArray(entrada.args))
+        return undefined;
+    return entrada.args.find((arg) => typeof arg === 'string' && arg.includes(PIN_PREFIX));
+}
+/** Entrada gravada pelo harness: os args fixam `@fontdata/ai-harness@<versão>`. */
+export function ehEntradaGerenciada(entrada) {
+    return pinOf(entrada) !== undefined;
+}
+/**
+ * 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. 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, removerGerenciadas = [] } = {}) {
+    const file = join(root, MCP_PATH);
+    const original = existsSync(file) ? readFileSync(file, 'utf8') : null;
+    let config = {};
+    if (original !== null) {
+        let parsed;
+        try {
+            parsed = JSON.parse(original);
+        }
+        catch {
+            parsed = undefined;
+        }
+        if (!isPlainObject(parsed) || (parsed.mcpServers !== undefined && !isPlainObject(parsed.mcpServers))) {
+            throw new Error(`O ${MCP_PATH} está com JSON inválido; corrija-o antes de registrar o servidor MCP de banco.`);
+        }
+        config = parsed;
+    }
+    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) {
+            mcpServers[nome] = servidor;
+            changed = true;
+        }
+        else if (atualizarGerenciada && ehEntradaGerenciada(atual) && pinOf(atual) !== pinOf(servidor)) {
+            mcpServers[nome] = { ...atual, command: servidor.command, args: servidor.args };
+            changed = true;
+        }
+    }
+    if (!changed)
+        return { changed: false, backup: null };
+    let backup = null;
+    if (original !== null) {
+        backup = `${MCP_PATH}.bak-${timestamp(now)}`;
+        copyFileSync(file, join(root, backup));
+    }
+    writeFileSync(file, `${JSON.stringify({ ...config, mcpServers }, null, 2)}\n`);
+    return { changed: true, backup };
+}

package/dist/install/plan.js

@@ -6,8 +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 { 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. */
@@ -27,6 +29,7 @@ export function resolveInstallOptions(args) {
         hooks: args.hooks ?? true,
         agents: args.agents ?? true,
         comments: args.comments ?? true,
+        mcpBanco: args.mcpBanco ?? true,
     };
 }
 export function packageInfo() {
@@ -162,10 +165,14 @@ 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_MCP_NOME]: bancoMcpServer(pkg.versao) }, now);
+    if (plan.mcpRecusado)
+        gravarRegistrarMcp(root, false);
     const items = new Map();
     for (const item of previous?.itens ?? [])
         items.set(`${item.tipo}:${item.id}`, item);
@@ -186,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');
@@ -202,10 +213,22 @@ 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.');
     }
+    if (plan.registerMcp) {
+        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_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_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,6 +33,14 @@ export const READ_PERMISSIONS = [
     'Bash(gh pr diff:*)',
     'Bash(npm outdated:*)',
 ];
+const BANCO_TOOLS = ['listar_conexoes', 'listar_tabelas', 'descrever_tabela', 'consultar'];
+/**
+ * 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_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,
@@ -41,7 +49,12 @@ export const HARNESS_PERMISSIONS = [
     AGENT_PERMISSION,
     ...TOOL_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:*)',
@@ -54,7 +67,7 @@ export const HARNESS_DENY = [
 function isPlainObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-function timestamp(date) {
+export function timestamp(date) {
     const pad = (n) => String(n).padStart(2, '0');
     return (`${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(date.getDate())}-` +
         `${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`);
@@ -86,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()) {
@@ -149,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;

package/dist/update/update.js

@@ -2,15 +2,45 @@ import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync
 import { dirname, join, resolve } from 'node:path';
 import { allCommands, loadCatalog } from '../catalog.js';
 import { commentsHooksConfig, ensureCommentsBaseline } from '../comentarios/instalar.js';
-import { readConfig, syncGitignore, writeDefaultConfig } from '../config/config.js';
+import { CONFIG_PATH, gravarRegistrarMcp, migrarSecaoBanco, readConfig, syncGitignore, temSecaoBancoLegada, writeDefaultConfig, } from '../config/config.js';
 import { applyAtomically } from '../install/atomic.js';
 import { suggestFlag } from '../install/flags.js';
 import { HOOKS_ITEM_ID, isHarnessPluginEnabled, projectHooksConfig } from '../install/hooks.js';
+import { BANCO_MCP_NOME, BANCO_MCP_NOME_LEGADO, bancoMcpServer, ehEntradaGerenciada, MCP_PATH, mergeMcpServers } from '../install/mcp.js';
 import { hashContent, LOCK_PATH, LOCK_VERSION, readLock, writeLock } from '../install/lock.js';
 import { itemSources, packageInfo, PROJECT_RULE_PATH, projectRuleContent } from '../install/plan.js';
 import { neededSkillsFor } from '../install/selection.js';
-import { combineHooks, HARNESS_DENY, HARNESS_PERMISSIONS, hasAllowRule, mergeSettings } from '../install/settings.js';
+import { BANCO_PERMISSIONS_LEGADAS, combineHooks, HARNESS_DENY, harnessPermissions, hasAllowRule, mergeSettings, SETTINGS_PATH, } from '../install/settings.js';
 import { adoptLegacyInstall } from './legado.js';
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** Espelha o `mergeMcpServers` com `atualizarGerenciada`; JSON inválido vira `invalido`, e o apply pula o registro. */
+function mcpChange(root, versao) {
+    const file = join(root, MCP_PATH);
+    if (!existsSync(file))
+        return 'ausente';
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        return 'invalido';
+    }
+    if (!isPlainObject(parsed))
+        return 'invalido';
+    const servers = parsed.mcpServers === undefined ? {} : parsed.mcpServers;
+    if (!isPlainObject(servers))
+        return 'invalido';
+    if (ehEntradaGerenciada(servers[BANCO_MCP_NOME_LEGADO]))
+        return 'renomear';
+    const atual = servers[BANCO_MCP_NOME];
+    if (atual === undefined)
+        return 'faltando';
+    const pin = bancoMcpServer(versao).args.find((arg) => arg.startsWith('@fontdata/'));
+    const args = isPlainObject(atual) && Array.isArray(atual.args) ? atual.args : [];
+    return ehEntradaGerenciada(atual) && !args.includes(pin) ? 'versao' : null;
+}
 /** `<id>-legado.md`, com sufixo numérico quando o nome já está em uso. */
 function legacyPath(root, path) {
     const base = path.replace(/\.md$/, '');
@@ -20,7 +50,7 @@ function legacyPath(root, path) {
             return candidate;
     }
 }
-export function checkUpdate(root, catalog = loadCatalog(), legacy, home) {
+export function checkUpdate(root, catalog = loadCatalog(), legacy, home, { semBanco = false } = {}) {
     const recorded = readLock(root);
     const lock = recorded ?? adoptLegacyInstall(root, legacy);
     if (!lock) {
@@ -108,10 +138,14 @@ export function checkUpdate(root, catalog = loadCatalog(), legacy, home) {
         addItem('rule', 'comentarios', true);
         addItem('hook', 'comentarios', true);
     }
+    const registrarMcpConfig = readConfig(root).config.banco_dados.registrar_mcp;
+    const permissoesBanco = !semBanco && registrarMcpConfig;
     const permissoesFaltando = [
-        ...HARNESS_PERMISSIONS.filter((rule) => !hasAllowRule(root, rule)),
+        ...harnessPermissions({ banco: permissoesBanco }).filter((rule) => !hasAllowRule(root, rule)),
         ...HARNESS_DENY.filter((rule) => !hasAllowRule(root, rule, 'deny')).map((rule) => `deny ${rule}`),
     ];
+    const permissoesLegadas = BANCO_PERMISSIONS_LEGADAS.filter((rule) => hasAllowRule(root, rule));
+    const registrarMcp = !semBanco && registrarMcpConfig && !isHarnessPluginEnabled(root, home);
     return {
         changes,
         lock,
@@ -121,6 +155,12 @@ export function checkUpdate(root, catalog = loadCatalog(), legacy, home) {
         registrarComentarios: adotada,
         permissaoAusente: permissoesFaltando.length > 0,
         permissoesFaltando,
+        permissoesLegadas,
+        permissoesBanco,
+        registrarMcp,
+        mudancaMcp: registrarMcp ? mcpChange(root, packageInfo().versao) : null,
+        recusarMcp: semBanco && registrarMcpConfig,
+        renomearSecaoBanco: temSecaoBancoLegada(root),
     };
 }
 /**
@@ -159,7 +199,10 @@ export function applyUpdate(root, report, options, pkg, now = new Date()) {
         return { de: path, para };
     });
     const hooks = combineHooks(report.registrarHooks ? projectHooksConfig() : {}, report.registrarComentarios ? commentsHooksConfig() : {});
-    mergeSettings(root, { hooks, allow: HARNESS_PERMISSIONS, deny: HARNESS_DENY }, now);
+    const ajustes = [];
+    const settings = mergeSettings(root, { hooks, allow: harnessPermissions({ banco: report.permissoesBanco }), deny: HARNESS_DENY, removeAllow: BANCO_PERMISSIONS_LEGADAS }, now);
+    if (settings.changed)
+        ajustes.push(`${SETTINGS_PATH} atualizado${settings.backup ? ` (backup em ${settings.backup})` : ''}.`);
     if (report.registrarComentarios)
         ensureCommentsBaseline(root);
     if (report.adotada) {
@@ -172,6 +215,29 @@ export function applyUpdate(root, report, options, pkg, now = new Date()) {
             writeFileSync(projectRule, projectRuleContent(renamed.map(({ para }) => para)));
         }
     }
+    const avisos = [];
+    if (report.registrarMcp && report.mudancaMcp === 'invalido')
+        avisos.push(MCP_INVALIDO);
+    else if (report.registrarMcp) {
+        // Uma falha no .mcp.json nunca deixa o update pela metade, sem lock.
+        try {
+            const mcp = mergeMcpServers(root, { [BANCO_MCP_NOME]: bancoMcpServer(pkg.versao) }, now, {
+                atualizarGerenciada: true,
+                removerGerenciadas: [BANCO_MCP_NOME_LEGADO],
+            });
+            if (mcp.changed)
+                ajustes.push(`${MCP_PATH} com mcpServers.${BANCO_MCP_NOME} na versão ${pkg.versao}${mcp.backup ? ` (backup em ${mcp.backup})` : ''}.`);
+        }
+        catch (error) {
+            avisos.push(error instanceof Error ? error.message : String(error));
+        }
+    }
+    if (report.renomearSecaoBanco && migrarSecaoBanco(root))
+        ajustes.push(`seção banco renomeada para banco_dados em ${CONFIG_PATH}.`);
+    if (report.recusarMcp) {
+        gravarRegistrarMcp(root, false);
+        ajustes.push(`banco_dados.registrar_mcp: false gravado em ${CONFIG_PATH}.`);
+    }
     const itemOf = new Map(report.changes.map((change) => [change.caminho, change.item]));
     const writtenHash = new Map(write.map((file) => [file.path, hashContent(file.content)]));
     const dropped = new Set([...remove, ...report.stale, ...legacy]);
@@ -205,8 +271,15 @@ export function applyUpdate(root, report, options, pkg, now = new Date()) {
         itens.push({ ...added, arquivos: added.arquivos.sort((a, b) => a.caminho.localeCompare(b.caminho)) });
     }
     writeLock(root, { lock_versao: LOCK_VERSION, pacote: pkg, gerado_em: now.toISOString(), itens });
-    return { written: write.map((file) => file.path), removed: remove, kept, renamed };
+    return { written: write.map((file) => file.path), removed: remove, kept, renamed, avisos, ajustes };
 }
+const MCP_INVALIDO = `O ${MCP_PATH} está com JSON inválido: o registro do MCP de banco foi pulado e o arquivo não foi tocado. Corrija-o e rode o update de novo.`;
+const MCP_DESCRIPTIONS = {
+    ausente: 'não existe',
+    faltando: `não tem a entrada ${BANCO_MCP_NOME}`,
+    versao: `fixa outra versão do servidor ${BANCO_MCP_NOME}`,
+    renomear: `tem a entrada ${BANCO_MCP_NOME_LEGADO} do harness, com o nome antigo; ela é trocada pela ${BANCO_MCP_NOME}`,
+};
 const DESCRIPTIONS = {
     novo: 'novo no pacote, será gravado',
     alterado: 'mudou no pacote, será atualizado',
@@ -230,20 +303,34 @@ export function describeUpdate(report) {
             `Faltam permissões do harness em .claude/settings.json (${report.permissoesFaltando.join(', ')}); o --yes as acrescenta.`,
         ]
         : [];
+    const legadas = report.permissoesLegadas.length
+        ? [`Permissões do MCP de banco com o nome antigo em .claude/settings.json (${report.permissoesLegadas.join(', ')}); o --yes as remove.`]
+        : [];
+    const mcp = [
+        ...(report.mudancaMcp === 'invalido'
+            ? [`O ${MCP_PATH} está com JSON inválido; o --yes pula o registro do MCP de banco e não toca no arquivo.`]
+            : report.mudancaMcp
+                ? [`O ${MCP_PATH} ${MCP_DESCRIPTIONS[report.mudancaMcp]}; o --yes grava mcpServers.${BANCO_MCP_NOME} na versão ${packageInfo().versao}.`]
+                : []),
+        ...(report.renomearSecaoBanco ? [`A seção banco de ${CONFIG_PATH} agora se chama banco_dados; o --yes a renomeia.`] : []),
+        ...(report.recusarMcp ? [`--sem-banco-dados: o --yes grava banco_dados.registrar_mcp: false em ${CONFIG_PATH} e não registra o MCP.`] : []),
+    ];
     if (!report.changes.length) {
-        const status = adopted.length || permission.length ? 'Nenhum arquivo a atualizar.' : 'A instalação está em dia: nenhum arquivo a atualizar.';
-        return [...adopted, ...permission, status].join('\n');
+        const status = adopted.length || permission.length || legadas.length || mcp.length ? 'Nenhum arquivo a atualizar.' : 'A instalação está em dia: nenhum arquivo a atualizar.';
+        return [...adopted, ...permission, ...legadas, ...mcp, status].join('\n');
     }
     return [
         ...adopted,
         ...permission,
+        ...legadas,
+        ...mcp,
         `Mudanças em relação ao pacote ${packageInfo().versao} (instalado: ${report.lock.pacote.versao}):`,
         ...report.changes.map((change) => `  ${change.tipo.padEnd(16)} ${change.caminho}${change.destino ? ` → ${change.destino}` : ''}  (${DESCRIPTIONS[change.tipo]})`),
     ].join('\n');
 }
-const UPDATE_FLAGS = ['--check', '--yes', '-y', '--sim', '--forcar'];
+const UPDATE_FLAGS = ['--check', '--yes', '-y', '--sim', '--forcar', '--sem-banco-dados'];
 export function parseUpdateArgs(argv) {
-    const args = { path: undefined, check: false, yes: false, force: false };
+    const args = { path: undefined, check: false, yes: false, force: false, semBanco: false };
     for (const token of argv) {
         if (!token.startsWith('-')) {
             if (args.path !== undefined)
@@ -254,6 +341,8 @@ export function parseUpdateArgs(argv) {
             args.check = true;
         else if (token === '--forcar')
             args.force = true;
+        else if (token === '--sem-banco-dados')
+            args.semBanco = true;
         else if (token === '--yes' || token === '-y' || token === '--sim')
             args.yes = true;
         else {
@@ -263,16 +352,17 @@ export function parseUpdateArgs(argv) {
     }
     return args;
 }
-/** `ai-harness update [caminho] [--check] [--yes] [--forcar]`; sem `--yes` só simula. */
+/** `ai-harness update [caminho] [--check] [--yes] [--forcar] [--sem-banco-dados]`; sem `--yes` só simula. */
 export function runUpdateCommand(argv) {
     const args = parseUpdateArgs(argv);
     const root = resolve(process.cwd(), args.path ?? '.');
     if (!existsSync(root))
         throw new Error(`Pasta não encontrada: ${root}`);
-    const report = checkUpdate(root);
+    const report = checkUpdate(root, undefined, undefined, undefined, { semBanco: args.semBanco });
     console.log(describeUpdate(report));
-    // Sem arquivo a atualizar, a adoção ainda grava o lock, e a permissão ausente ainda é acrescentada.
-    if (args.check || (!report.changes.length && !report.adotada && !report.permissaoAusente))
+    // Sem arquivo a atualizar, a adoção ainda grava o lock, e a permissão e o MCP ainda são acrescentados.
+    const pendente = report.adotada || report.permissaoAusente || report.permissoesLegadas.length > 0 || report.mudancaMcp !== null || report.recusarMcp || report.renomearSecaoBanco;
+    if (args.check || (!report.changes.length && !pendente))
         return 0;
     if (!args.yes) {
         const conflicts = report.changes.some((change) => change.tipo === 'conflito');
@@ -282,6 +372,10 @@ export function runUpdateCommand(argv) {
     const result = applyUpdate(root, report, { force: args.force }, packageInfo());
     console.log(`\nAtualização aplicada: ${result.written.length} gravado(s), ${result.removed.length} apagado(s), ` +
         `${result.renamed.length} renomeado(s), ${result.kept.length} preservado(s).`);
+    for (const ajuste of result.ajustes)
+        console.log(`Gravado: ${ajuste}`);
+    for (const aviso of result.avisos)
+        console.log(`Aviso: ${aviso}`);
     if (result.renamed.length) {
         console.log('Comandos personalizados renomeados (leve o que for do projeto para uma rule e apague o arquivo):\n' +
             result.renamed.map(({ de, para }) => `  ${de} → ${para}`).join('\n'));