vault-go 0.15.0 → 0.16.1

package/README.md

@@ -170,6 +170,8 @@ 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.
+
 O recurso `vault-go://status` fornece o resumo sanitizado em JSON.
 
 Para reduzir o uso de contexto, prefira a recuperação em três camadas:

package/dist/cli.d.ts

@@ -1,6 +1,6 @@
 import { type McpClient } from './installer.js';
 import { type ContextEngineId } from './context-engines.js';
-export type CliMode = 'help' | 'version' | 'setup' | 'login' | 'serve' | 'local' | 'engine' | 'invalid';
+export type CliMode = 'help' | 'version' | 'setup' | 'login' | 'serve' | 'local' | 'engine' | 'hook' | 'invalid';
 export declare function resolveCliMode(argument: string | undefined, stdinIsTTY: boolean, stderrIsTTY: boolean): CliMode;
 export declare function parseEngineChoice(value: string): ContextEngineId;
 export declare function parseNumberedClients(value: string): McpClient[];

package/dist/cli.js

@@ -21,6 +21,8 @@ export function resolveCliMode(argument, stdinIsTTY, stderrIsTTY) {
         return 'local';
     if (argument === 'engine')
         return 'engine';
+    if (argument === 'hook')
+        return 'hook';
     if (argument === undefined)
         return stdinIsTTY && stderrIsTTY ? 'setup' : 'serve';
     return 'invalid';
@@ -321,6 +323,10 @@ Uso:
   vault-go engine list|use <motor> [--model haiku|sonnet|opus]|key openrouter|gemini
       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.
+
   --lang pt|en|es
       Idioma do assistente (padrão: idioma do sistema).
 

package/dist/cloud.d.ts

@@ -1,6 +1,7 @@
 export interface VaultMemoryApi {
     observerStatus?(): Promise<unknown>;
     observerGenerate?(text: string, signal?: AbortSignal): Promise<unknown>;
+    preferences?(): Promise<unknown>;
     health(): Promise<unknown>;
     projects(): Promise<unknown>;
     createProject(input: Record<string, unknown>): Promise<unknown>;
@@ -38,6 +39,7 @@ export declare class VaultCloudClient implements VaultMemoryApi {
     constructor(home?: string, cloudFetch?: typeof fetch, journal?: boolean);
     health(): Promise<unknown>;
     observerStatus(): Promise<unknown>;
+    preferences(): Promise<unknown>;
     observerGenerate(text: string, signal?: AbortSignal): Promise<unknown>;
     registerDevice(input: Record<string, unknown>): Promise<unknown>;
     rotateDevice(id: string): Promise<unknown>;

package/dist/cloud.js

@@ -13,6 +13,20 @@ export class VaultCloudClient {
         return this.request('/health', { authenticated: false });
     }
     async observerStatus() { return this.request('/memory/observer/status'); }
+    async preferences() {
+        try {
+            return await this.request('/preferences');
+        }
+        catch {
+            return {
+                automaticCapture: true,
+                captureMode: 'balanced',
+                includeToolResults: false,
+                contextItems: 20,
+                contextMaxChars: 24_000,
+            };
+        }
+    }
     async observerGenerate(text, signal) {
         return this.request('/memory/observer/generate', { method: 'POST', body: { text }, timeoutMs: 60_000, ...(signal ? { signal } : {}) });
     }

package/dist/hook-install.d.ts

@@ -0,0 +1,13 @@
+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 declare function installClientHooks(client: "claude" | "codex", userHome?: string, configHome?: string): void;
+export declare function repairClientHooks(userHome?: string, configHome?: string): void;

package/dist/hook-install.js

@@ -0,0 +1,113 @@
+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 }
+                                : {}),
+                        },
+                    ],
+                },
+            ],
+        ])),
+    };
+}
+export function installClientHooks(client, userHome = homedir(), configHome = vaultHome()) {
+    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);
+}

package/dist/hook-queue.d.ts

@@ -0,0 +1,13 @@
+import { VaultCloudClient } from "./cloud.js";
+import { generateContext } from "./context-engines.js";
+export interface GenerationJob {
+    id: string;
+    projectId: string;
+    sessionId?: string;
+    text: string;
+    title?: string;
+    kind: "observation" | "summary" | "prompt";
+}
+export declare function enqueueGeneration(home: string, job: GenerationJob): void;
+export declare function takeGeneration(home: string): GenerationJob | undefined;
+export declare function processGenerationQueue(home?: string, cloud?: VaultCloudClient, generate?: typeof generateContext): Promise<boolean>;

package/dist/hook-queue.js

@@ -0,0 +1,72 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync } from "node:fs";
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { VaultCloudClient } from "./cloud.js";
+import { vaultHome } from "./config.js";
+import { generateContext, selectedContextEngine, } from "./context-engines.js";
+function queuePath(home) {
+    return join(home, "generation-queue.json");
+}
+function readQueue(home) {
+    try {
+        const value = JSON.parse(readFileSync(queuePath(home), "utf8"));
+        return Array.isArray(value) ? value : [];
+    }
+    catch {
+        return [];
+    }
+}
+function writeQueue(home, jobs) {
+    mkdirSync(home, { recursive: true, mode: 0o700 });
+    const destination = queuePath(home);
+    const temporary = destination + "." + process.pid + ".tmp";
+    writeFileSync(temporary, JSON.stringify(jobs.slice(0, 50)) + "\n", { mode: 0o600 });
+    chmodSync(temporary, 0o600);
+    renameSync(temporary, destination);
+    chmodSync(destination, 0o600);
+}
+export function enqueueGeneration(home, job) {
+    if (!job.text.trim() || job.text.length > 16_000)
+        return;
+    const jobs = readQueue(home);
+    if (jobs.some((item) => item.id === job.id))
+        return;
+    writeQueue(home, [...jobs, job]);
+}
+export function takeGeneration(home) {
+    const jobs = readQueue(home);
+    const next = jobs[0];
+    if (!next)
+        return;
+    writeQueue(home, jobs.slice(1));
+    return next;
+}
+export async function processGenerationQueue(home = vaultHome(), cloud = new VaultCloudClient(home), generate = generateContext) {
+    const job = takeGeneration(home);
+    if (!job)
+        return false;
+    const engine = selectedContextEngine(home);
+    try {
+        const result = await generate(home, engine, job.text.slice(0, 16_000), {
+            ...(cloud.observerGenerate
+                ? {
+                    managedGenerate: (text, options) => cloud.observerGenerate(text, options.signal),
+                }
+                : {}),
+        });
+        await cloud.remember({
+            projectId: job.projectId,
+            ...(job.sessionId ? { sessionId: job.sessionId } : {}),
+            kind: job.kind === "summary" ? "summary" : "observation",
+            memoryType: "discovery",
+            title: result.title || job.title,
+            content: result.content,
+            facts: result.facts,
+            concepts: result.concepts,
+        });
+    }
+    catch {
+        // Drop poison items so the watcher keeps draining.
+    }
+    return existsSync(queuePath(home)) && readQueue(home).length > 0;
+}

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

@@ -0,0 +1,9 @@
+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 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>;
+export {};

package/dist/hooks.js

@@ -0,0 +1,227 @@
+import { createHash } from "node:crypto";
+import { basename, dirname, resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { VaultCloudClient } from "./cloud.js";
+import { vaultHome } from "./config.js";
+import { enqueueGeneration } from "./hook-queue.js";
+export const HOOK_EVENTS = [
+    "context",
+    "session-init",
+    "observation",
+    "file-context",
+    "summarize",
+];
+const record = (value) => value && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : {};
+const string = (...values) => values.find((value) => typeof value === "string" && value.trim()) ||
+    "";
+function root(cwd) {
+    const initial = resolve(cwd);
+    let dir = initial;
+    while (dirname(dir) !== dir) {
+        if (existsSync(resolve(dir, ".git")))
+            return dir;
+        dir = dirname(dir);
+    }
+    return initial;
+}
+function redact(value) {
+    if (typeof value === "string") {
+        return value
+            .replace(/<private>[\s\S]*?<\/private>/gi, "[redacted]")
+            .replace(/(api[_-]?key|secret|token|password)\s*[:=]\s*['"]?[^\s'"]+/gi, "$1=[redacted]");
+    }
+    if (Array.isArray(value))
+        return value.map(redact);
+    if (value && typeof value === "object") {
+        const output = {};
+        for (const [key, nested] of Object.entries(value)) {
+            output[key] = /api[_-]?key|secret|token|password|authorization/i.test(key)
+                ? "[redacted]"
+                : redact(nested);
+        }
+        return output;
+    }
+    return value;
+}
+export function hookOutput(event, context = "") {
+    const result = { continue: true, suppressOutput: true };
+    const name = event === "context"
+        ? "SessionStart"
+        : event === "file-context"
+            ? "PreToolUse"
+            : event === "session-init"
+                ? "UserPromptSubmit"
+                : "";
+    if (name && context) {
+        result.hookSpecificOutput = {
+            hookEventName: name,
+            additionalContext: context,
+        };
+    }
+    return result;
+}
+async function preferences(cloud) {
+    try {
+        if (cloud.preferences)
+            return record(await cloud.preferences());
+    }
+    catch {
+        /* use defaults */
+    }
+    return {
+        automaticCapture: true,
+        captureMode: "balanced",
+        includeToolResults: false,
+        contextItems: 20,
+        contextMaxChars: 24_000,
+    };
+}
+export async function executeHook(adapter, event, value, cloud = new VaultCloudClient(), home = vaultHome()) {
+    const input = record(value);
+    const toolName = string(input.tool_name, input.toolName);
+    if (input.private === true ||
+        input.is_private === true ||
+        /vault[_-]go|vault[_-]mem/.test(toolName)) {
+        return hookOutput(event);
+    }
+    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);
+    const modifies = /write|edit|patch|create|delete|move|rename/i.test(toolName);
+    if (!reading && prefs.captureMode === "focused" && event !== "summarize")
+        return hookOutput(event);
+    if (event === "observation" && prefs.captureMode === "balanced" && !modifies)
+        return hookOutput(event);
+    if (event === "file-context" && !file)
+        return hookOutput(event);
+    const sessionId = string(input.session_id, input.sessionId, input.thread_id, input.conversation_id);
+    if (!reading && !sessionId)
+        return hookOutput(event);
+    const cwd = root(string(input.cwd, input.workspace) || process.cwd());
+    const projects = await cloud.projects();
+    if (!Array.isArray(projects))
+        throw new Error("Resposta de projetos inválida");
+    let project = projects.find((item) => item &&
+        typeof item === "object" &&
+        resolve(String(item.rootPath || "")) === cwd);
+    if (!project && reading)
+        return hookOutput(event);
+    if (!project) {
+        project = record(await cloud.createProject({
+            name: (basename(cwd) || "workspace").padEnd(3, "_").slice(0, 80),
+            rootPath: cwd,
+        }));
+    }
+    if (typeof project.id !== "string")
+        throw new Error("Projeto inválido");
+    const limits = {
+        projectId: project.id,
+        limit: 20,
+        maxChars: 24_000,
+    };
+    if (reading) {
+        const result = record(event === "file-context"
+            ? await cloud.fileContext({
+                ...limits,
+                paths: [...new Set([file, resolve(cwd, file)])],
+            })
+            : await cloud.context(limits));
+        return hookOutput(event, string(result.context).slice(0, 24_000));
+    }
+    const session = record(await cloud.startSession({
+        projectId: project.id,
+        externalSessionId: sessionId,
+        platformSource: adapter,
+    }));
+    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 rawContent = event === "session-init"
+        ? prompt
+        : event === "summarize"
+            ? response
+            : JSON.stringify(redact({
+                toolName,
+                toolInput: tool,
+            }));
+    const content = String(redact(rawContent));
+    if (content.trim()) {
+        const eventType = event === "session-init"
+            ? "user_prompt"
+            : event === "summarize"
+                ? "session_summary"
+                : "tool_use";
+        const sourceEventId = createHash("sha256")
+            .update(JSON.stringify([
+            adapter,
+            event,
+            cwd,
+            sessionId,
+            input.tool_use_id,
+            input.turn_id,
+            input.timestamp,
+        ]))
+            .digest("hex");
+        await cloud.event({
+            projectId: project.id,
+            sessionId: session.id,
+            sourceAdapter: adapter,
+            sourceEventId,
+            eventType,
+            payload: {
+                title: toolName ||
+                    (event === "summarize" ? "Resumo da sessão" : "Solicitação do usuário"),
+                content,
+                filesRead: !modifies && file ? [file] : [],
+                filesModified: modifies && file ? [file] : [],
+            },
+            occurredAtEpoch: Date.now(),
+        });
+        enqueueGeneration(home, {
+            id: sourceEventId,
+            projectId: project.id,
+            sessionId: session.id,
+            text: content.slice(0, 16_000),
+            title: toolName ||
+                (event === "summarize" ? "Resumo da sessão" : "Solicitação do usuário"),
+            kind: event === "summarize" ? "summary" : event === "session-init" ? "prompt" : "observation",
+        });
+    }
+    if (event === "summarize")
+        await cloud.endSession(session.id);
+    return hookOutput(event);
+}
+export async function readHookInput(stream = process.stdin) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of stream) {
+        const buffer = Buffer.from(chunk);
+        size += buffer.length;
+        if (size > 1_000_000)
+            throw new Error("Hook excede o limite de entrada");
+        chunks.push(buffer);
+    }
+    return JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}");
+}
+export async function runHook(adapter, event) {
+    if (!HOOK_EVENTS.includes(event)) {
+        throw new Error("Evento de hook desconhecido.");
+    }
+    if (event === "context") {
+        try {
+            const { startLocal } = await import("./local-install.js");
+            await startLocal();
+        }
+        catch {
+            /* dashboard already running or unavailable */
+        }
+    }
+    const result = await executeHook(adapter === "auto" ? "claude" : adapter, event, await readHookInput());
+    process.stdout.write(JSON.stringify(result) + "\n");
+}

package/dist/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env bun
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { cliArguments, helpText, resolveCliMode, runEngine, runLocal, runLogin, runSetup } from './cli.js';
+import { HOOK_EVENTS, runHook } from './hooks.js';
 import { createVaultGoServer, VERSION } from './server.js';
 const { argument, options } = cliArguments(process.argv.slice(2));
 const mode = resolveCliMode(argument, process.stdin.isTTY === true, process.stderr.isTTY === true);
@@ -32,6 +33,15 @@ async function main() {
         process.exitCode = await runEngine(options);
         return;
     }
+    if (mode === 'hook') {
+        const adapter = options.find((item) => !item.startsWith('--')) ?? 'auto';
+        const event = options.filter((item) => !item.startsWith('--'))[1];
+        if (!event || !HOOK_EVENTS.includes(event)) {
+            throw new Error('Uso: vault-go hook <adaptador> context|session-init|observation|file-context|summarize');
+        }
+        await runHook(adapter, event);
+        return;
+    }
     const server = createVaultGoServer();
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/installer.js

@@ -2,6 +2,9 @@ import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync
 import { homedir, platform } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 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 = [
@@ -83,10 +86,16 @@ export function installMcpClient(client, options = {}) {
     const cwd = options.cwd ?? process.cwd();
     const runner = options.runner ?? runCommand;
     if (client === 'codex') {
-        return installViaCli(client, 'codex', ['mcp', 'get', MCP_SERVER_NAME], ['mcp', 'add', MCP_SERVER_NAME, '--', ...MCP_SERVER_COMMAND], runner);
+        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;
     }
     if (client === 'claude') {
-        return installViaCli(client, 'claude', ['mcp', 'get', MCP_SERVER_NAME], [
+        const result = installViaCli(client, 'claude', ['mcp', 'get', MCP_SERVER_NAME], [
             'mcp',
             'add',
             '--scope',
@@ -97,6 +106,12 @@ export function installMcpClient(client, options = {}) {
             '--',
             ...MCP_SERVER_COMMAND,
         ], runner);
+        try {
+            stageLocalRuntime(vaultHome());
+        }
+        catch { /* incomplete installs still write hooks */ }
+        installClientHooks('claude', home);
+        return result;
     }
     if (client === 'vscode') {
         const payload = JSON.stringify({

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(["index.js", "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/dist/local-service.js

@@ -12,6 +12,7 @@ import { resolveLocale } from "./locale.js";
 import { callbackPage } from "./callback-page.js";
 import { privateStore } from "./private-store.js";
 import { localDevice } from "./local-device.js";
+import { processGenerationQueue } from "./hook-queue.js";
 import { generateContext, isApiEngine, isContextEngine, listContextEngines, parseEngineModel, saveEngineKey, selectContextEngine, selectEngineModel, selectedContextEngine, } from "./context-engines.js";
 export const LOCAL_PORT = 38850;
 const safeEqual = (a, b) => a.length === b.length &&
@@ -258,6 +259,11 @@ export async function startLocalService(options = {}) {
                 connected = true;
                 cloudError = undefined;
                 storage?.write(cache, { owner, projects, memories, updatedAt });
+                if (!generating && !options.cloud) {
+                    generating = processGenerationQueue(home, accountCloud).finally(() => {
+                        generating = null;
+                    });
+                }
             }
             catch {
                 if (requestOwner === identity()) {
@@ -271,6 +277,7 @@ export async function startLocalService(options = {}) {
         })();
         return syncing;
     }
+    let generating = null;
     const server = createServer(async (req, res) => {
         res.setHeader("Cache-Control", "no-store");
         res.setHeader("Referrer-Policy", "no-referrer");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vault-go",
-  "version": "0.15.0",
+  "version": "0.16.1",
   "description": "Servidor MCP universal com autenticação e instalação multi-cliente para a plataforma Vault.",
   "type": "module",
   "bin": {
@@ -34,6 +34,14 @@
     "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",
     "dist/index.d.ts",
     "dist/installer.js",