vault-go 0.18.0 → 0.19.0

package/dist/hook-queue.js

@@ -1,72 +1,146 @@
-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");
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { VaultCloudClient } from './cloud.js';
+import { loadConfig, loadTokens, vaultHome } from './config.js';
+import { generateContext, selectedContextEngine } from './context-engines.js';
+const queuePath = (home) => join(home, 'generation-queue.json');
+function ownerKey(home) {
+    const config = loadConfig(home);
+    return createHash('sha256').update(JSON.stringify([config.apiUrl, process.env['VAULT_GO_TOKEN'] ?? config.email ?? loadTokens(home)?.accessToken ?? 'anonymous'])).digest('hex');
 }
 function readQueue(home) {
-    try {
-        const value = JSON.parse(readFileSync(queuePath(home), "utf8"));
-        return Array.isArray(value) ? value : [];
-    }
-    catch {
+    if (!existsSync(queuePath(home)))
         return [];
-    }
+    const value = JSON.parse(readFileSync(queuePath(home), 'utf8'));
+    if (!Array.isArray(value))
+        throw new Error('Invalid generation queue; source preserved.');
+    return value;
 }
 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);
+    const destination = queuePath(home), temporary = `${destination}.${randomUUID()}.tmp`;
+    writeFileSync(temporary, JSON.stringify(jobs) + '\n', { mode: 0o600 });
     renameSync(temporary, destination);
     chmodSync(destination, 0o600);
 }
-export function enqueueGeneration(home, job) {
+// Separate short storage locks and a long consumer lock let hooks enqueue while a model runs.
+async function lock(home, name, wait = true) {
+    mkdirSync(home, { recursive: true, mode: 0o700 });
+    const path = join(home, `${name}.lock`);
+    const token = randomUUID();
+    for (let attempt = 0; attempt < (wait ? 100 : 1); attempt++) {
+        try {
+            writeFileSync(path, JSON.stringify({ pid: process.pid, token }), { flag: 'wx', mode: 0o600 });
+            return () => {
+                try {
+                    if (JSON.parse(readFileSync(path, 'utf8')).token === token)
+                        rmSync(path, { force: true });
+                }
+                catch { /* already released; never remove another consumer's lock */ }
+            };
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            try {
+                const before = statSync(path);
+                const stored = JSON.parse(readFileSync(path, 'utf8'));
+                const pid = typeof stored === 'number' ? stored : Number(stored?.pid);
+                if (Number.isInteger(pid) && pid > 0) {
+                    try {
+                        process.kill(pid, 0);
+                    }
+                    catch (probe) {
+                        if (probe.code === 'ESRCH') {
+                            const after = statSync(path);
+                            if (before.ino === after.ino && before.mtimeMs === after.mtimeMs)
+                                rmSync(path, { force: true });
+                            continue;
+                        }
+                    }
+                }
+            }
+            catch { /* another process may have just released it */ }
+            if (wait)
+                await new Promise(resolve => setTimeout(resolve, 20));
+        }
+    }
+    if (wait)
+        throw new Error('Generation queue is busy; retry capture.');
+}
+async function mutate(home, change) {
+    const release = await lock(home, 'generation-storage');
+    try {
+        writeQueue(home, change(readQueue(home)));
+    }
+    finally {
+        release?.();
+    }
+}
+export async 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]);
+    await mutate(home, jobs => {
+        if (jobs.some(item => item.id === job.id))
+            return jobs;
+        if (jobs.length >= 1000)
+            throw new Error('Generation queue is full; existing items preserved.');
+        return [...jobs, { ...job, owner: ownerKey(home) }];
+    });
 }
-export function takeGeneration(home) {
-    const jobs = readQueue(home);
-    const next = jobs[0];
-    if (!next)
-        return;
-    writeQueue(home, jobs.slice(1));
-    return next;
+export function generationQueueStatus(home = vaultHome()) {
+    const jobs = readQueue(home), owner = ownerKey(home);
+    return { pending: jobs.filter(j => j.owner === owner || !j.owner).length, failed: jobs.filter(j => j.owner === owner && j.lastError).length, legacyAwaitingOwnership: jobs.filter(j => !j.owner).length, heldForOtherAccount: jobs.filter(j => j.owner && j.owner !== owner).length };
 }
 export async function processGenerationQueue(home = vaultHome(), cloud = new VaultCloudClient(home), generate = generateContext) {
-    const job = takeGeneration(home);
-    if (!job)
+    const release = await lock(home, 'generation-worker', false);
+    if (!release)
         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,
-        });
+        const owner = ownerKey(home);
+        if (readQueue(home).some(item => !item.owner)) {
+            // Pre-upgrade jobs have no account fingerprint. Adopt only projects proven
+            // to belong to the currently authenticated account; never infer from login.
+            const projects = await cloud.projects().catch(() => null);
+            if (Array.isArray(projects) && owner === ownerKey(home)) {
+                const owned = new Set(projects.flatMap(project => project && typeof project === 'object' && typeof project.id === 'string' ? [project.id] : []));
+                await mutate(home, jobs => jobs.map(item => !item.owner && owned.has(item.projectId) ? { ...item, owner } : item));
+            }
+        }
+        const job = readQueue(home).find(item => item.owner === owner && (item.nextAttemptAt ?? 0) <= Date.now());
+        if (!job)
+            return false;
+        try {
+            const result = job.result ?? (job.generate === false ? { title: job.title ?? 'Memória', content: job.text, facts: [], concepts: [] } : await generate(home, selectedContextEngine(home), job.text, {
+                ...(cloud.observerGenerate ? { managedGenerate: (text, options) => cloud.observerGenerate(text, options.signal) } : {}),
+            }));
+            if (owner !== ownerKey(home))
+                throw new Error('Account changed.');
+            // Cache successful generation before persistence, so a network retry does not pay for the model twice.
+            await mutate(home, jobs => jobs.map(item => item.id === job.id ? { ...item, result } : item));
+            await cloud.importMemories({ projectId: job.projectId, records: [{
+                        sourceId: `vault-go:event:${job.id}`,
+                        ...(job.sessionId ? { sessionId: job.sessionId } : {}),
+                        kind: job.kind,
+                        memoryType: 'discovery',
+                        title: result.title || job.title,
+                        content: result.content.slice(0, job.maxChars ?? 4000),
+                        facts: result.facts, concepts: result.concepts,
+                        filesRead: job.filesRead ?? [], filesModified: job.filesModified ?? [],
+                    }] });
+            await mutate(home, jobs => jobs.filter(item => item.id !== job.id));
+        }
+        catch {
+            await mutate(home, jobs => jobs.map(item => item.id !== job.id ? item : {
+                ...item, attempts: (item.attempts ?? 0) + 1,
+                nextAttemptAt: Date.now() + Math.min(300_000, 5000 * 2 ** Math.min(item.attempts ?? 0, 6)),
+                lastError: 'generation_or_persistence_failed',
+            }));
+        }
+        return readQueue(home).some(item => item.owner === owner);
     }
-    catch {
-        // Drop poison items so the watcher keeps draining.
+    finally {
+        release();
     }
-    return existsSync(queuePath(home)) && readQueue(home).length > 0;
 }

package/dist/hooks.d.ts

@@ -2,6 +2,7 @@ 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 redact(value: unknown): unknown;
 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>;

package/dist/hooks.js

@@ -1,4 +1,4 @@
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { basename, dirname, resolve } from "node:path";
 import { existsSync } from "node:fs";
 import { VaultCloudClient } from "./cloud.js";
@@ -26,10 +26,10 @@ function root(cwd) {
     }
     return initial;
 }
-function redact(value) {
+export function redact(value) {
     if (typeof value === "string") {
         return value
-            .replace(/<private>[\s\S]*?<\/private>/gi, "[redacted]")
+            .replace(/<(private|vault-private|claude-mem-context|system_instruction|system-instruction|persisted-output|system-reminder)\b[^>]*>[\s\S]*?(?:<\/\1\s*>|$)/gi, "[redacted]")
             .replace(/(api[_-]?key|secret|token|password)\s*[:=]\s*['"]?[^\s'"]+/gi, "$1=[redacted]");
     }
     if (Array.isArray(value))
@@ -37,7 +37,7 @@ function redact(value) {
     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)
+            output[key] = /api[_-]?key|secret|token|password|authorization|cookie|credential|private[_-]?key/i.test(key)
                 ? "[redacted]"
                 : redact(nested);
         }
@@ -98,7 +98,7 @@ async function preferences(cloud) {
         /* use defaults */
     }
     return {
-        automaticCapture: true,
+        automaticCapture: false,
         captureMode: "balanced",
         includeToolResults: false,
         contextItems: 20,
@@ -110,6 +110,7 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
     const toolName = string(input.tool_name);
     if (input.private === true ||
         input.is_private === true ||
+        input.isPrivate === true ||
         /vault[_-]go|vault[_-]mem/.test(toolName)) {
         return hookOutput(event, "", adapter);
     }
@@ -135,7 +136,9 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
         throw new Error("Resposta de projetos inválida");
     let project = projects.find((item) => item &&
         typeof item === "object" &&
-        resolve(String(item.rootPath || "")) === cwd);
+        typeof item.rootPath === "string" &&
+        Boolean(String(item.rootPath).trim()) &&
+        resolve(String(item.rootPath)) === cwd);
     if (!project && reading)
         return hookOutput(event, "", adapter);
     if (!project) {
@@ -148,8 +151,8 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
         throw new Error("Projeto inválido");
     const limits = {
         projectId: project.id,
-        limit: 20,
-        maxChars: 24_000,
+        limit: boundedPreference(prefs.contextItems, 20, 1, 100),
+        maxChars: boundedPreference(prefs.contextMaxChars, 24_000, 1_000, 100_000),
     };
     if (reading) {
         const result = record(event === "file-context"
@@ -158,7 +161,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), adapter);
+        return hookOutput(event, string(result.context).slice(0, limits.maxChars), adapter);
     }
     const session = record(await cloud.startSession({
         projectId: project.id,
@@ -169,14 +172,18 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
         throw new Error("Sessão inválida");
     const prompt = string(input.prompt);
     const response = string(input.last_assistant_message);
+    const toolPayload = record(redact({
+        toolName,
+        toolInput: tool,
+        ...(prefs.includeToolResults === true ? {
+            toolResponse: input.tool_response ?? input.toolResponse ?? input.tool_result ?? input.toolResult ?? input.result ?? null,
+        } : {}),
+    }));
     const rawContent = event === "session-init"
         ? prompt
         : event === "summarize"
             ? response
-            : JSON.stringify(redact({
-                toolName,
-                toolInput: tool,
-            }));
+            : JSON.stringify(toolPayload);
     const content = String(redact(rawContent));
     if (content.trim()) {
         const eventType = event === "session-init"
@@ -193,6 +200,8 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
             input.tool_use_id,
             input.turn_id,
             input.timestamp,
+            string(input.tool_use_id, input.turn_id, input.timestamp) ? undefined : randomUUID(),
+            content,
         ]))
             .digest("hex");
         await cloud.event({
@@ -201,7 +210,11 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
             sourceAdapter: adapter,
             sourceEventId,
             eventType,
+            generate: false,
             payload: {
+                ...(event === 'observation' ? toolPayload : {}),
+                summaryMode: 'off',
+                metadata: { summaryMode: 'off' },
                 title: toolName ||
                     (event === "summarize" ? "Resumo da sessão" : "Solicitação do usuário"),
                 content,
@@ -210,20 +223,27 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
             },
             occurredAtEpoch: Date.now(),
         });
-        enqueueGeneration(home, {
+        await enqueueGeneration(home, {
             id: sourceEventId,
+            generate: prefs.summaryMode !== 'off',
             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",
+            maxChars: boundedPreference(prefs.summaryMaxChars, 4_000, 256, 16_000),
+            filesRead: !modifies && file ? [file] : [],
+            filesModified: modifies && file ? [file] : [],
         });
     }
     if (event === "summarize")
         await cloud.endSession(session.id);
     return hookOutput(event, "", adapter);
 }
+function boundedPreference(value, fallback, min, max) {
+    return typeof value === 'number' && Number.isInteger(value) ? Math.max(min, Math.min(max, value)) : fallback;
+}
 export async function readHookInput(stream = process.stdin) {
     const chunks = [];
     let size = 0;

package/dist/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { cliArguments, helpText, resolveCliMode, runEngine, runLocal, runLogin, runSetup } from './cli.js';
+import { cliArguments, helpText, resolveCliMode, runEngine, runLocal, runLogin, runSetup, runUpdate } from './cli.js';
 import { HOOK_EVENTS, runHook } from './hooks.js';
 import { createVaultGoServer, VERSION } from './server.js';
 const { argument, options } = cliArguments(process.argv.slice(2));
@@ -33,6 +33,10 @@ async function main() {
         process.exitCode = await runEngine(options);
         return;
     }
+    if (mode === 'update') {
+        process.exitCode = await runUpdate(options);
+        return;
+    }
     if (mode === 'hook') {
         const adapter = options.find((item) => !item.startsWith('--')) ?? 'auto';
         const event = options.filter((item) => !item.startsWith('--'))[1];

package/dist/local-install.js

@@ -1,5 +1,5 @@
 import { execFile, spawn } from "node:child_process";
-import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+import { createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import { chmodSync, copyFileSync, existsSync, mkdirSync, openSync, closeSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync, } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
@@ -46,42 +46,51 @@ export async function localStatus(port = LOCAL_PORT, home = vaultHome()) {
 }
 export function stageLocalRuntime(home = vaultHome(), source = dirname(fileURLToPath(import.meta.url))) {
     const manifest = JSON.parse(readFileSync(join(source, "..", "package.json"), "utf8"));
-    const root = join(home, "local-runtime");
-    const target = join(root, "dist");
-    mkdirSync(target, { recursive: true, mode: 0o700 });
-    chmodSync(root, 0o700);
-    chmodSync(target, 0o700);
     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"))
-            continue;
-        const destination = join(target, file);
-        copyFileSync(join(source, file), `${destination}.tmp`);
-        chmodSync(`${destination}.tmp`, 0o600);
-        renameSync(`${destination}.tmp`, destination);
+    if (!existsSync(join(source, "hook-runner.js")))
+        throw new Error("Hook runner is missing. Build or reinstall vault-go first.");
+    const root = join(home, "local-runtime"), candidate = join(home, `.runtime-${randomUUID()}`), previous = join(home, "local-runtime.previous");
+    const target = join(candidate, "dist");
+    mkdirSync(target, { recursive: true, mode: 0o700 });
+    chmodSync(candidate, 0o700);
+    try {
+        for (const file of readdirSync(source)) {
+            if (!file.endsWith(".js") || file.endsWith(".test.js"))
+                continue;
+            copyFileSync(join(source, file), join(target, file));
+            chmodSync(join(target, file), 0o600);
+        }
+        const logo = join(source, "..", "assets", "vault-logo-glass.png");
+        if (existsSync(logo)) {
+            mkdirSync(join(candidate, "assets"), { mode: 0o700 });
+            copyFileSync(logo, join(candidate, "assets", "vault-logo-glass.png"));
+            chmodSync(join(candidate, "assets", "vault-logo-glass.png"), 0o600);
+        }
+        writeFileSync(join(candidate, "package.json"), JSON.stringify({ name: "vault-go-local-runtime", version: manifest.version, type: "module" }), { mode: 0o600 });
+        rmSync(previous, { recursive: true, force: true });
+        if (existsSync(root))
+            renameSync(root, previous);
+        try {
+            renameSync(candidate, root);
+        }
+        catch (error) {
+            if (existsSync(previous))
+                renameSync(previous, root);
+            throw error;
+        }
     }
-    const assets = join(root, "assets");
-    mkdirSync(assets, { recursive: true, mode: 0o700 });
-    const logo = join(source, "..", "assets", "vault-logo-glass.png");
-    if (existsSync(logo)) {
-        copyFileSync(logo, join(assets, "vault-logo-glass.png"));
-        chmodSync(join(assets, "vault-logo-glass.png"), 0o600);
+    finally {
+        rmSync(candidate, { recursive: true, force: true });
     }
-    writeFileSync(join(root, "package.json"), JSON.stringify({
-        name: "vault-go-local-runtime",
-        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");
+    return join(root, "dist", "local-worker.js");
 }
 export async function startLocal(home = vaultHome()) {
     const running = await localStatus(LOCAL_PORT, home);
     if (running)
         return running;
-    const worker = stageLocalRuntime(home);
+    const stagedWorker = join(home, "local-runtime", "dist", "local-worker.js");
+    const worker = existsSync(stagedWorker) ? stagedWorker : stageLocalRuntime(home);
     const log = openSync(join(home, "local-service.log"), "a", 0o600);
     try {
         const child = spawn(process.execPath, [worker], {

package/dist/local-service.d.ts

@@ -22,5 +22,6 @@ export declare function startLocalService(options?: {
     server: import("http").Server<typeof IncomingMessage, typeof import("http").ServerResponse>;
     port: number;
     close: () => Promise<void>;
+    isIdle: () => boolean;
 }>;
 export {};

package/dist/local-service.js

@@ -260,7 +260,7 @@ export async function startLocalService(options = {}) {
                 cloudError = undefined;
                 storage?.write(cache, { owner, projects, memories, updatedAt });
                 if (!generating && !options.cloud) {
-                    generating = processGenerationQueue(home, accountCloud).finally(() => {
+                    generating = processGenerationQueue(home, accountCloud).catch(() => { cloudError = "generation_queue_unavailable"; }).finally(() => {
                         generating = null;
                     });
                 }
@@ -657,5 +657,5 @@ export async function startLocalService(options = {}) {
         await new Promise((resolve) => server.close(() => resolve()));
         storage?.close();
     }
-    return { server, port, close };
+    return { server, port, close, isIdle: () => !generating && !syncing && login?.status !== "pending" && [...jobs.values()].every(job => job.status !== "running") };
 }

package/dist/local-worker.js

@@ -1,8 +1,10 @@
 import { startLocalService } from './local-service.js';
+import { scheduleAutomaticUpdates } from './update-control.js';
 const port = Number(process.env['VAULT_GO_LOCAL_PORT'] ?? 38850);
 if (!Number.isInteger(port) || port < 1024 || port > 65535)
     throw new Error('Invalid local port');
 const local = await startLocalService({ port });
+const stopUpdates = scheduleAutomaticUpdates(local.isIdle);
 for (const signal of ['SIGINT', 'SIGTERM'])
-    process.once(signal, () => void local.close());
+    process.once(signal, () => { stopUpdates(); void local.close(); });
 console.log(`AI Vault Memory local service · http://localhost:${local.port}`);

package/dist/mcp-result.d.ts

@@ -0,0 +1,20 @@
+export declare function jsonResult(value: unknown): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent: Record<string, unknown>;
+};
+export declare function run(operation: () => Promise<unknown>): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent: Record<string, unknown>;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+}>;

package/dist/mcp-result.js

@@ -0,0 +1,21 @@
+export function jsonResult(value) {
+    const structuredContent = value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : { value };
+    return {
+        content: [{ type: 'text', text: JSON.stringify(value, null, 2) }],
+        structuredContent,
+    };
+}
+function errorResult(error) {
+    const message = error instanceof Error ? error.message : 'Erro inesperado.';
+    return { content: [{ type: 'text', text: message }], isError: true };
+}
+export async function run(operation) {
+    try {
+        return jsonResult(await operation());
+    }
+    catch (error) {
+        return errorResult(error);
+    }
+}

package/dist/modes.d.ts

@@ -0,0 +1,17 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare const MODE_NAMES: readonly ["babysit", "mem-search", "how-it-works", "make-plan", "do", "smart-explore", "knowledge-agent", "standup", "timeline-report", "weekly-digests", "learn-codebase", "pathfinder", "design-is", "what-the", "version-bump", "oh-my-issues", "cloud-sync", "mode-creator", "ccs-align", "wowerpoint"];
+export type VaultModeName = (typeof MODE_NAMES)[number];
+export type VaultModeStatus = 'native' | 'instructional' | 'limited';
+export interface VaultMode {
+    name: VaultModeName;
+    promptName: string;
+    title: string;
+    summary: string;
+    status: VaultModeStatus;
+    readOnlyDefault: boolean;
+    runtimeRequires: readonly string[];
+    limitations: readonly string[];
+    steps: readonly string[];
+}
+export declare const VAULT_MODES: readonly VaultMode[];
+export declare function registerVaultModes(server: McpServer): void;