vault-go 0.16.0 → 0.17.0

package/README.md

@@ -76,6 +76,9 @@ Clientes suportados:
 
 - Codex e ChatGPT Desktop local;
 - Claude Code e Claude Desktop;
+- Grok (config.toml nativo e hooks em `~/.grok/hooks`);
+- Agy / Antigravity CLI e IDE;
+- Gemini CLI;
 - Cursor e Windsurf;
 - VS Code com GitHub Copilot;
 - GitHub Copilot CLI;
@@ -170,7 +173,7 @@ limitados.
 
 O seletor de motor segue o mesmo modelo do claude-mem: Claude (CLI da assinatura), OpenRouter (chave), Gemini (chave) ou o Vault AI Resume da conta. Grave chaves com `vault-go engine key openrouter|gemini` ou no painel local; as ferramentas MCP não aceitam segredos.
 
-Na instalação, o Vault Go registra hooks no Claude Code e no Codex. Eles injetam contexto no início da sessão, capturam prompts e ferramentas, e o serviço local (`http://localhost:38850`) gera memórias com o motor escolhido — o mesmo ciclo do claude-mem, persistindo no Vault.
+Na instalação, o Vault Go registra hooks no Claude Code, no Codex, no Grok e no Agy. Eles injetam contexto no início da sessão, capturam prompts e ferramentas, e o serviço local (`http://localhost:38850`) gera memórias com o motor escolhido — o mesmo ciclo do claude-mem, persistindo no Vault.
 
 O recurso `vault-go://status` fornece o resumo sanitizado em JSON.
 

package/dist/cli.js

@@ -324,8 +324,8 @@ Uso:
       Escolhe o motor e o modelo de contexto. No Claude: haiku, sonnet ou opus.
 
   vault-go hook <adaptador> <evento>
-      Usado pelos hooks do Claude/Codex: injeta contexto, captura atividade
-      e enfileira geração com o motor escolhido.
+      Usado pelos hooks do Claude, Codex, Grok e Agy: injeta contexto,
+      captura atividade e enfileira geração com o motor escolhido.
 
   --lang pt|en|es
       Idioma do assistente (padrão: idioma do sistema).

package/dist/hook-install.d.ts

@@ -0,0 +1,14 @@
+export declare const HOOK_OWNER = "Vault Go: captura e contexto";
+export declare const HOOK_EVENTS: {
+    readonly SessionStart: "context";
+    readonly UserPromptSubmit: "session-init";
+    readonly PreToolUse: "file-context";
+    readonly PostToolUse: "observation";
+    readonly Stop: "summarize";
+};
+export declare function quoteShell(value: string): string;
+export declare function hookEntryPath(configHome?: string): string;
+export declare function hookCommand(adapter: string, event: string, configHome?: string): string;
+export type HookClient = "claude" | "codex" | "grok" | "agy";
+export declare function installClientHooks(client: HookClient, userHome?: string, configHome?: string): void;
+export declare function repairClientHooks(userHome?: string, configHome?: string): void;

package/dist/hook-install.js

@@ -0,0 +1,148 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { vaultHome } from "./config.js";
+function readJsonObject(path) {
+    if (!existsSync(path))
+        return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (error) {
+        throw new Error(`JSON inválido em ${path}; o arquivo não foi alterado.`, {
+            cause: error,
+        });
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`Configuração inválida em ${path}; o arquivo não foi alterado.`);
+    }
+    return parsed;
+}
+function atomicWriteJson(path, value) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const temporary = join(dirname(path), `.${process.pid}.${Date.now()}.tmp`);
+    writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, {
+        mode: 0o600,
+    });
+    renameSync(temporary, path);
+    chmodSync(path, 0o600);
+}
+export const HOOK_OWNER = "Vault Go: captura e contexto";
+export const HOOK_EVENTS = {
+    SessionStart: "context",
+    UserPromptSubmit: "session-init",
+    PreToolUse: "file-context",
+    PostToolUse: "observation",
+    Stop: "summarize",
+};
+export function quoteShell(value) {
+    return "'" + value.replaceAll("'", "'\\''") + "'";
+}
+export function hookEntryPath(configHome = vaultHome()) {
+    const staged = join(configHome, "local-runtime", "dist", "hook-runner.js");
+    if (existsSync(staged))
+        return staged;
+    return join(dirname(fileURLToPath(import.meta.url)), "hook-runner.js");
+}
+export function hookCommand(adapter, event, configHome = vaultHome()) {
+    return `${quoteShell(process.execPath)} ${quoteShell(hookEntryPath(configHome))} ${adapter} ${event}`;
+}
+function hookManifest(adapter, configHome = vaultHome()) {
+    return {
+        hooks: Object.fromEntries(Object.entries(HOOK_EVENTS).map(([name, event]) => [
+            name,
+            [
+                {
+                    hooks: [
+                        {
+                            type: "command",
+                            command: hookCommand(adapter, event, configHome),
+                            timeout: event === "context" ? 60 : 20,
+                            statusMessage: HOOK_OWNER,
+                            ...(event === "observation" ||
+                                event === "summarize" ||
+                                event === "file-context"
+                                ? { async: true }
+                                : {}),
+                        },
+                    ],
+                },
+            ],
+        ])),
+    };
+}
+function agyHandler(event, configHome = vaultHome()) {
+    return {
+        type: "command",
+        command: hookCommand("agy", event, configHome),
+        timeout: event === "context" ? 60 : 20,
+    };
+}
+function agyHookManifest(configHome = vaultHome()) {
+    return {
+        PreInvocation: [agyHandler("context", configHome)],
+        PreToolUse: [{ matcher: "*", hooks: [agyHandler("file-context", configHome)] }],
+        PostToolUse: [
+            { matcher: "*", hooks: [agyHandler("observation", configHome)] },
+        ],
+        Stop: [agyHandler("summarize", configHome)],
+    };
+}
+export function installClientHooks(client, userHome = homedir(), configHome = vaultHome()) {
+    if (client === "grok") {
+        atomicWriteJson(join(userHome, ".grok", "hooks", "vault-go.json"), hookManifest("grok", configHome));
+        return;
+    }
+    if (client === "agy") {
+        const path = join(userHome, ".gemini", "config", "hooks.json");
+        const config = readJsonObject(path);
+        atomicWriteJson(path, { ...config, "vault-go": agyHookManifest(configHome) });
+        return;
+    }
+    const path = join(userHome, client === "claude" ? ".claude/settings.json" : ".codex/hooks.json");
+    const config = readJsonObject(path);
+    const hooks = {
+        ...(config.hooks &&
+            typeof config.hooks === "object" &&
+            !Array.isArray(config.hooks)
+            ? config.hooks
+            : {}),
+    };
+    const desired = hookManifest(client, configHome).hooks;
+    for (const event of Object.keys(HOOK_EVENTS)) {
+        const current = hooks[event];
+        const retained = Array.isArray(current)
+            ? current
+                .map((group) => {
+                if (!group ||
+                    typeof group !== "object" ||
+                    !Array.isArray(group.hooks))
+                    return group;
+                const filtered = group.hooks.filter((hook) => !hook ||
+                    typeof hook !== "object" ||
+                    hook.statusMessage !== HOOK_OWNER);
+                return { ...group, hooks: filtered };
+            })
+                .filter((group) => !group ||
+                typeof group !== "object" ||
+                !Array.isArray(group.hooks) ||
+                group.hooks.length > 0)
+            : [];
+        hooks[event] = [...retained, ...(desired[event] || [])];
+    }
+    atomicWriteJson(path, { ...config, hooks });
+}
+export function repairClientHooks(userHome = homedir(), configHome = vaultHome()) {
+    installClientHooks("claude", userHome, configHome);
+    installClientHooks("codex", userHome, configHome);
+    if (existsSync(join(userHome, ".grok"))) {
+        installClientHooks("grok", userHome, configHome);
+    }
+    if (existsSync(join(userHome, ".gemini", "config")) ||
+        existsSync(join(userHome, ".gemini", "antigravity")) ||
+        existsSync(join(userHome, ".gemini", "antigravity-cli"))) {
+        installClientHooks("agy", userHome, configHome);
+    }
+}

package/dist/hook-runner.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/hook-runner.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { HOOK_EVENTS, runHook } from "./hooks.js";
+const adapter = process.argv[2] ?? "auto";
+const event = process.argv[3];
+if (!event || !HOOK_EVENTS.includes(event)) {
+    process.stderr.write("Uso: hook-runner <adaptador> context|session-init|observation|file-context|summarize\n");
+    process.exit(1);
+}
+await runHook(adapter, event);

package/dist/hooks.d.ts

@@ -2,7 +2,8 @@ import { type VaultMemoryApi } from "./cloud.js";
 export declare const HOOK_EVENTS: readonly ["context", "session-init", "observation", "file-context", "summarize"];
 export type HookEvent = (typeof HOOK_EVENTS)[number];
 type RecordValue = Record<string, unknown>;
-export declare function hookOutput(event: HookEvent, context?: string): RecordValue;
+export declare function normalizeHookInput(adapter: string, value: unknown): RecordValue;
+export declare function hookOutput(event: HookEvent, context?: string, adapter?: string): RecordValue;
 export declare function executeHook(adapter: string, event: HookEvent, value: unknown, cloud?: VaultMemoryApi, home?: string): Promise<RecordValue>;
 export declare function readHookInput(stream?: NodeJS.ReadableStream): Promise<unknown>;
 export declare function runHook(adapter: string, event: string): Promise<void>;

package/dist/hooks.js

@@ -45,7 +45,34 @@ function redact(value) {
     }
     return value;
 }
-export function hookOutput(event, context = "") {
+export function normalizeHookInput(adapter, value) {
+    const input = record(value);
+    const toolCall = record(input.toolCall);
+    const workspaces = Array.isArray(input.workspacePaths)
+        ? input.workspacePaths
+        : [];
+    const workspace = workspaces.find((item) => typeof item === "string" && Boolean(item.trim()));
+    return {
+        ...input,
+        session_id: string(input.session_id, input.sessionId, input.conversation_id, input.conversationId, input.thread_id),
+        cwd: string(input.cwd, input.workspace, input.workspaceRoot, workspace),
+        tool_name: string(input.tool_name, input.toolName, toolCall.name),
+        tool_input: record(input.tool_input ?? input.toolInput ?? toolCall.args),
+        last_assistant_message: string(input.last_assistant_message, input.lastAssistantMessage, input.response, input.summary),
+        prompt: string(input.prompt, input.user_prompt, input.userPrompt),
+    };
+}
+export function hookOutput(event, context = "", adapter = "claude") {
+    if (adapter === "agy") {
+        if (event === "context" || event === "session-init") {
+            return context
+                ? { injectSteps: [{ ephemeralMessage: context }] }
+                : {};
+        }
+        if (event === "file-context")
+            return { decision: "allow" };
+        return {};
+    }
     const result = { continue: true, suppressOutput: true };
     const name = event === "context"
         ? "SessionStart"
@@ -79,29 +106,29 @@ async function preferences(cloud) {
     };
 }
 export async function executeHook(adapter, event, value, cloud = new VaultCloudClient(), home = vaultHome()) {
-    const input = record(value);
-    const toolName = string(input.tool_name, input.toolName);
+    const input = normalizeHookInput(adapter, value);
+    const toolName = string(input.tool_name);
     if (input.private === true ||
         input.is_private === true ||
         /vault[_-]go|vault[_-]mem/.test(toolName)) {
-        return hookOutput(event);
+        return hookOutput(event, "", adapter);
     }
     const prefs = await preferences(cloud);
     const reading = event === "context" || event === "file-context";
     if (!reading && prefs.automaticCapture !== true)
-        return hookOutput(event);
-    const tool = record(input.tool_input ?? input.toolInput);
-    const file = string(tool.file_path, tool.path, tool.notebook_path);
+        return hookOutput(event, "", adapter);
+    const tool = record(input.tool_input);
+    const file = string(tool.file_path, tool.path, tool.notebook_path, tool.AbsolutePath, tool.Path, tool.filePath);
     const modifies = /write|edit|patch|create|delete|move|rename/i.test(toolName);
     if (!reading && prefs.captureMode === "focused" && event !== "summarize")
-        return hookOutput(event);
+        return hookOutput(event, "", adapter);
     if (event === "observation" && prefs.captureMode === "balanced" && !modifies)
-        return hookOutput(event);
+        return hookOutput(event, "", adapter);
     if (event === "file-context" && !file)
-        return hookOutput(event);
-    const sessionId = string(input.session_id, input.sessionId, input.thread_id, input.conversation_id);
+        return hookOutput(event, "", adapter);
+    const sessionId = string(input.session_id);
     if (!reading && !sessionId)
-        return hookOutput(event);
+        return hookOutput(event, "", adapter);
     const cwd = root(string(input.cwd, input.workspace) || process.cwd());
     const projects = await cloud.projects();
     if (!Array.isArray(projects))
@@ -110,7 +137,7 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
         typeof item === "object" &&
         resolve(String(item.rootPath || "")) === cwd);
     if (!project && reading)
-        return hookOutput(event);
+        return hookOutput(event, "", adapter);
     if (!project) {
         project = record(await cloud.createProject({
             name: (basename(cwd) || "workspace").padEnd(3, "_").slice(0, 80),
@@ -131,7 +158,7 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
                 paths: [...new Set([file, resolve(cwd, file)])],
             })
             : await cloud.context(limits));
-        return hookOutput(event, string(result.context).slice(0, 24_000));
+        return hookOutput(event, string(result.context).slice(0, 24_000), adapter);
     }
     const session = record(await cloud.startSession({
         projectId: project.id,
@@ -140,8 +167,8 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
     }));
     if (typeof session.id !== "string")
         throw new Error("Sessão inválida");
-    const prompt = string(input.prompt, input.user_prompt);
-    const response = string(input.last_assistant_message, input.response, input.summary);
+    const prompt = string(input.prompt);
+    const response = string(input.last_assistant_message);
     const rawContent = event === "session-init"
         ? prompt
         : event === "summarize"
@@ -195,7 +222,7 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
     }
     if (event === "summarize")
         await cloud.endSession(session.id);
-    return hookOutput(event);
+    return hookOutput(event, "", adapter);
 }
 export async function readHookInput(stream = process.stdin) {
     const chunks = [];

package/dist/installer.d.ts

@@ -1,10 +1,7 @@
 export declare const MCP_SERVER_NAME = "vault-go";
 export declare const MCP_SERVER_COMMAND: readonly ["bunx", "--bun", "vault-go@latest", "serve"];
-export declare const MCP_CLIENTS: readonly ["codex", "claude", "claude-desktop", "cursor", "vscode", "copilot", "windsurf", "roo", "opencode"];
+export declare const MCP_CLIENTS: readonly ["codex", "claude", "claude-desktop", "cursor", "vscode", "copilot", "windsurf", "roo", "opencode", "grok", "agy", "gemini"];
 export type McpClient = (typeof MCP_CLIENTS)[number];
-export declare function quoteShell(value: string): string;
-export declare function hookEntryPath(configHome?: string): string;
-export declare function hookCommand(adapter: string, event: string, configHome?: string): string;
 export interface DetectedClient {
     client: McpClient;
     detected: boolean;

package/dist/installer.js

@@ -1,10 +1,10 @@
 import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, writeFileSync, } from 'node:fs';
 import { homedir, platform } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
 import { spawnSync } from 'node:child_process';
 import { vaultHome } from './config.js';
 import { stageLocalRuntime } from './local-install.js';
+import { installClientHooks } from './hook-install.js';
 export const MCP_SERVER_NAME = 'vault-go';
 export const MCP_SERVER_COMMAND = ['bunx', '--bun', 'vault-go@latest', 'serve'];
 export const MCP_CLIENTS = [
@@ -17,76 +17,14 @@ export const MCP_CLIENTS = [
     'windsurf',
     'roo',
     'opencode',
+    'grok',
+    'agy',
+    'gemini',
 ];
-const HOOK_OWNER = 'Vault Go: captura e contexto';
-const HOOK_EVENTS = {
-    SessionStart: 'context',
-    UserPromptSubmit: 'session-init',
-    PreToolUse: 'file-context',
-    PostToolUse: 'observation',
-    Stop: 'summarize',
+const CLIENT_ALIASES = {
+    antigravity: 'agy',
+    'gemini-cli': 'gemini',
 };
-export function quoteShell(value) {
-    return "'" + value.replaceAll("'", "'\\''") + "'";
-}
-export function hookEntryPath(configHome = vaultHome()) {
-    const staged = join(configHome, 'local-runtime', 'dist', 'index.js');
-    if (existsSync(staged))
-        return staged;
-    return join(dirname(fileURLToPath(import.meta.url)), 'index.js');
-}
-export function hookCommand(adapter, event, configHome = vaultHome()) {
-    return `${quoteShell(process.execPath)} ${quoteShell(hookEntryPath(configHome))} hook ${adapter} ${event}`;
-}
-function hookManifest(adapter, configHome = vaultHome()) {
-    return {
-        hooks: Object.fromEntries(Object.entries(HOOK_EVENTS).map(([name, event]) => [
-            name,
-            [
-                {
-                    hooks: [
-                        {
-                            type: 'command',
-                            command: hookCommand(adapter, event, configHome),
-                            timeout: event === 'context' ? 60 : 20,
-                            statusMessage: HOOK_OWNER,
-                            ...(event === 'observation' || event === 'summarize' || event === 'file-context'
-                                ? { async: true }
-                                : {}),
-                        },
-                    ],
-                },
-            ],
-        ])),
-    };
-}
-function installClientHooks(client, userHome, configHome = vaultHome()) {
-    try {
-        stageLocalRuntime(configHome);
-    }
-    catch {
-        /* tests and incomplete installs still write the hook command */
-    }
-    const path = join(userHome, client === 'claude' ? '.claude/settings.json' : '.codex/hooks.json');
-    const config = readJsonObject(path);
-    const hooks = { ...(config.hooks && typeof config.hooks === 'object' && !Array.isArray(config.hooks) ? config.hooks : {}) };
-    const desired = hookManifest(client, configHome).hooks;
-    for (const event of Object.keys(HOOK_EVENTS)) {
-        const current = hooks[event];
-        const retained = Array.isArray(current)
-            ? current
-                .map((group) => {
-                if (!group || typeof group !== 'object' || !Array.isArray(group.hooks))
-                    return group;
-                const filtered = group.hooks.filter((hook) => !hook || typeof hook !== 'object' || hook.statusMessage !== HOOK_OWNER);
-                return { ...group, hooks: filtered };
-            })
-                .filter((group) => !group || typeof group !== 'object' || !Array.isArray(group.hooks) || group.hooks.length > 0)
-            : [];
-        hooks[event] = [...retained, ...(desired[event] || [])];
-    }
-    atomicWriteJson(path, { ...config, hooks });
-}
 const runCommand = (command, args) => spawnSync(command, [...args], { stdio: 'ignore' });
 function readJsonObject(path) {
     if (!existsSync(path))
@@ -104,12 +42,37 @@ function readJsonObject(path) {
     return parsed;
 }
 function atomicWriteJson(path, value) {
+    atomicWriteText(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+function atomicWriteText(path, text) {
     mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
     const temporary = join(dirname(path), `.${process.pid}.${Date.now()}.tmp`);
-    writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+    writeFileSync(temporary, text.endsWith('\n') ? text : `${text}\n`, { mode: 0o600 });
     renameSync(temporary, path);
     chmodSync(path, 0o600);
 }
+function formatTomlValue(value) {
+    if (typeof value === 'boolean')
+        return value ? 'true' : 'false';
+    if (typeof value === 'string')
+        return JSON.stringify(value);
+    return `[${value.map((item) => JSON.stringify(item)).join(', ')}]`;
+}
+function upsertTomlTable(path, table, assignments) {
+    const previous = existsSync(path) ? readFileSync(path, 'utf8') : '';
+    const body = Object.entries(assignments)
+        .map(([key, value]) => `${key} = ${formatTomlValue(value)}`)
+        .join('\n');
+    const block = `[${table}]\n${body}\n`;
+    const escaped = table.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const pattern = new RegExp(`(^|\\r?\\n)\\[${escaped}\\](?:\\r?\\n(?!\\[).*)*`);
+    const next = pattern.test(previous)
+        ? previous.replace(pattern, (match) => `${/^\r?\n/.exec(match)?.[0] ?? ''}${block}`)
+        : previous.trimEnd()
+            ? `${previous.trimEnd()}\n\n${block}`
+            : block;
+    atomicWriteText(path, next);
+}
 function standardServer() {
     return {
         command: MCP_SERVER_COMMAND[0],
@@ -156,6 +119,10 @@ export function installMcpClient(client, options = {}) {
     const runner = options.runner ?? runCommand;
     if (client === 'codex') {
         const result = installViaCli(client, 'codex', ['mcp', 'get', MCP_SERVER_NAME], ['mcp', 'add', MCP_SERVER_NAME, '--', ...MCP_SERVER_COMMAND], runner);
+        try {
+            stageLocalRuntime(vaultHome());
+        }
+        catch { /* incomplete installs still write hooks */ }
         installClientHooks('codex', home);
         return result;
     }
@@ -171,6 +138,10 @@ export function installMcpClient(client, options = {}) {
             '--',
             ...MCP_SERVER_COMMAND,
         ], runner);
+        try {
+            stageLocalRuntime(vaultHome());
+        }
+        catch { /* incomplete installs still write hooks */ }
         installClientHooks('claude', home);
         return result;
     }
@@ -186,6 +157,36 @@ export function installMcpClient(client, options = {}) {
         }
         return { client, status: 'installed', destination: 'VS Code user profile' };
     }
+    if (client === 'grok') {
+        const destination = join(home, '.grok', 'config.toml');
+        upsertTomlTable(destination, 'mcp_servers.vault-go', {
+            command: MCP_SERVER_COMMAND[0],
+            args: MCP_SERVER_COMMAND.slice(1),
+            enabled: true,
+        });
+        try {
+            stageLocalRuntime(vaultHome());
+        }
+        catch { /* incomplete installs still write hooks */ }
+        installClientHooks('grok', home);
+        return { client, status: 'installed', destination };
+    }
+    if (client === 'agy') {
+        const cliPath = join(home, '.gemini', 'config', 'mcp_config.json');
+        mergeServer(cliPath);
+        mergeServer(join(home, '.gemini', 'antigravity', 'mcp_config.json'));
+        try {
+            stageLocalRuntime(vaultHome());
+        }
+        catch { /* incomplete installs still write hooks */ }
+        installClientHooks('agy', home);
+        return { client, status: 'installed', destination: cliPath };
+    }
+    if (client === 'gemini') {
+        const path = join(home, '.gemini', 'settings.json');
+        mergeServer(path);
+        return { client, status: 'installed', destination: path };
+    }
     let path;
     if (client === 'claude-desktop')
         path = claudeDesktopPath(home);
@@ -230,6 +231,9 @@ export function detectMcpClients(home = homedir()) {
         ['windsurf', ['windsurf'], [join(home, '.codeium', 'windsurf')]],
         ['roo', [], []],
         ['opencode', ['opencode'], [join(home, '.config', 'opencode')]],
+        ['grok', ['grok'], [join(home, '.grok')]],
+        ['agy', ['agy'], [join(home, '.gemini', 'antigravity-cli'), join(home, '.gemini', 'config'), join(home, '.gemini', 'antigravity')]],
+        ['gemini', ['gemini'], [join(home, '.gemini', 'settings.json')]],
     ];
     return definitions.map(([client, commands, paths]) => {
         const command = commands.find((candidate) => Bun.which(candidate));
@@ -256,7 +260,10 @@ export function parseClientSelection(value) {
     const normalized = value.trim().toLowerCase();
     if (normalized === 'all' || normalized === 'todos')
         return [...MCP_CLIENTS];
-    const selected = [...new Set(normalized.split(',').map((item) => item.trim()).filter(Boolean))];
+    const selected = [...new Set(normalized.split(',').map((item) => {
+            const trimmed = item.trim();
+            return CLIENT_ALIASES[trimmed] ?? trimmed;
+        }).filter(Boolean))];
     const invalid = selected.filter((item) => !MCP_CLIENTS.includes(item));
     if (invalid.length > 0)
         throw new Error(`Clientes MCP desconhecidos: ${invalid.join(', ')}`);

package/dist/local-install.js

@@ -51,13 +51,10 @@ export function stageLocalRuntime(home = vaultHome(), source = dirname(fileURLTo
     mkdirSync(target, { recursive: true, mode: 0o700 });
     chmodSync(root, 0o700);
     chmodSync(target, 0o700);
-    const excluded = new Set(["server.js", "installer.js", "cli.js"]);
     if (!existsSync(join(source, "local-worker.js")))
         throw new Error("Local worker is missing. Build or reinstall vault-go first.");
     for (const file of readdirSync(source)) {
-        if (!file.endsWith(".js") ||
-            file.endsWith(".test.js") ||
-            excluded.has(file))
+        if (!file.endsWith(".js") || file.endsWith(".test.js"))
             continue;
         const destination = join(target, file);
         copyFileSync(join(source, file), `${destination}.tmp`);
@@ -76,6 +73,8 @@ export function stageLocalRuntime(home = vaultHome(), source = dirname(fileURLTo
         version: manifest.version,
         type: "module",
     }), { mode: 0o600 });
+    if (!existsSync(join(target, "hook-runner.js")))
+        throw new Error("Hook runner is missing. Build or reinstall vault-go first.");
     return join(target, "local-worker.js");
 }
 export async function startLocal(home = vaultHome()) {
@@ -218,6 +217,13 @@ export async function replaceLaunchAgent(domain, path, prepare, operations) {
 }
 export async function installLocal(home = vaultHome()) {
     const worker = stageLocalRuntime(home);
+    try {
+        const { repairClientHooks } = await import("./hook-install.js");
+        repairClientHooks(homedir(), home);
+    }
+    catch {
+        /* settings files may not exist yet */
+    }
     if (process.platform !== "darwin") {
         await startLocal(home);
         return { startup: false };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vault-go",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "Servidor MCP universal com autenticação e instalação multi-cliente para a plataforma Vault.",
   "type": "module",
   "bin": {
@@ -34,8 +34,12 @@
     "dist/config.d.ts",
     "dist/context-engines.js",
     "dist/context-engines.d.ts",
+    "dist/hook-install.js",
+    "dist/hook-install.d.ts",
     "dist/hook-queue.js",
     "dist/hook-queue.d.ts",
+    "dist/hook-runner.js",
+    "dist/hook-runner.d.ts",
     "dist/hooks.js",
     "dist/hooks.d.ts",
     "dist/index.js",
@@ -99,7 +103,10 @@
     "codex",
     "claude",
     "copilot",
-    "cursor"
+    "cursor",
+    "grok",
+    "opencode",
+    "antigravity"
   ],
   "author": "Gutierrez Henrique",
   "license": "MIT",