vault-go 0.29.1 → 0.30.0

package/dist/capabilities.d.ts

@@ -112,6 +112,11 @@ export declare const CAPABILITIES: {
         readonly status: "available";
         readonly tools: readonly ["vault_go_modes", "vault_go_mode"];
         readonly difference: "Setup writes managed SKILL.md files for Claude, Grok and shared agent skill directories. mem-search uses vault_go_search_index → vault_go_timeline → vault_go_observations → vault_go_tool_uses. babysit is a session loop with gh, not a Vault background daemon.";
+    }, {
+        readonly upstream: readonly ["private skills library"];
+        readonly status: "available";
+        readonly tools: readonly ["vault_go_skills", "vault_go_skill_folders", "vault_go_skill_read", "vault_go_skill_file", "vault_go_skill_save", "vault_go_skill_organize", "vault_go_skill_install", "vault_go_skill_sync"];
+        readonly requires: "Account skill packages organized by folders and linked to projects (/v1/skills). Saving publishes a new immutable version; deleting is only available in the Vault apps. Local install verifies sha256 and manifest digest and never replaces a skill the Vault did not install.";
     }];
 };
 /** API tools verify by default. Resources pass verify=false and never perform network I/O. */
@@ -228,6 +233,11 @@ export declare function getCapabilities(home: string, cloud: VaultMemoryApi, ver
         readonly status: "available";
         readonly tools: readonly ["vault_go_modes", "vault_go_mode"];
         readonly difference: "Setup writes managed SKILL.md files for Claude, Grok and shared agent skill directories. mem-search uses vault_go_search_index → vault_go_timeline → vault_go_observations → vault_go_tool_uses. babysit is a session loop with gh, not a Vault background daemon.";
+    }, {
+        readonly upstream: readonly ["private skills library"];
+        readonly status: "available";
+        readonly tools: readonly ["vault_go_skills", "vault_go_skill_folders", "vault_go_skill_read", "vault_go_skill_file", "vault_go_skill_save", "vault_go_skill_organize", "vault_go_skill_install", "vault_go_skill_sync"];
+        readonly requires: "Account skill packages organized by folders and linked to projects (/v1/skills). Saving publishes a new immutable version; deleting is only available in the Vault apps. Local install verifies sha256 and manifest digest and never replaces a skill the Vault did not install.";
     }];
 }>;
 export declare const WORKFLOW: {

package/dist/capabilities.js

@@ -29,6 +29,7 @@ export const CAPABILITIES = {
         { upstream: ['transcript watchers'], status: 'available', tools: ['vault_go_transcripts_status', 'vault_go_transcripts_configure', 'vault_go_transcripts_poll'], difference: 'Persistent, consented and resumable watchers are implemented for Claude and Codex transcripts. Other client transcript formats are not claimed.' },
         { upstream: ['Grok awareness push'], status: 'available', tools: ['vault_go_grok_awareness_status', 'vault_go_grok_awareness_configure', 'vault_go_grok_awareness_push'], requires: 'Explicit consent, an allowlisted agent UUID and a local agent-data root. Monthly awareness logs are bounded, private and separate from Telegram.' },
         { upstream: ['development/report/presentation skills', 'babysit', 'mem-search'], status: 'available', tools: ['vault_go_modes', 'vault_go_mode'], difference: 'Setup writes managed SKILL.md files for Claude, Grok and shared agent skill directories. mem-search uses vault_go_search_index → vault_go_timeline → vault_go_observations → vault_go_tool_uses. babysit is a session loop with gh, not a Vault background daemon.' },
+        { upstream: ['private skills library'], status: 'available', tools: ['vault_go_skills', 'vault_go_skill_folders', 'vault_go_skill_read', 'vault_go_skill_file', 'vault_go_skill_save', 'vault_go_skill_organize', 'vault_go_skill_install', 'vault_go_skill_sync'], requires: 'Account skill packages organized by folders and linked to projects (/v1/skills). Saving publishes a new immutable version; deleting is only available in the Vault apps. Local install verifies sha256 and manifest digest and never replaces a skill the Vault did not install.' },
     ],
 };
 function unavailableVerification() {

package/dist/cloud.d.ts

@@ -52,6 +52,17 @@ export interface VaultMemoryApi {
     rebuildKnowledgeBase(id: string): Promise<unknown>;
     queryKnowledgeBase(id: string, input: Record<string, unknown>): Promise<unknown>;
     deleteKnowledgeBase(id: string): Promise<unknown>;
+    skills?(query: Record<string, unknown>): Promise<unknown>;
+    skillFolders?(): Promise<unknown>;
+    skill?(id: string, version?: string): Promise<unknown>;
+    skillFile?(id: string, path: string, version?: string): Promise<unknown>;
+    createSkill?(input: Record<string, unknown>, idempotencyKey?: string): Promise<unknown>;
+    createSkillVersion?(id: string, input: Record<string, unknown>, idempotencyKey?: string): Promise<unknown>;
+    updateSkill?(id: string, input: Record<string, unknown>): Promise<unknown>;
+    setSkillProjects?(id: string, projectIds: string[]): Promise<unknown>;
+    createSkillFolder?(input: Record<string, unknown>): Promise<unknown>;
+    updateSkillFolder?(id: string, input: Record<string, unknown>): Promise<unknown>;
+    skillDownloadGrant?(id: string, versionId?: string): Promise<unknown>;
 }
 export declare class VaultCloudClient implements VaultMemoryApi {
     private readonly home;
@@ -101,6 +112,17 @@ export declare class VaultCloudClient implements VaultMemoryApi {
     rebuildKnowledgeBase(id: string): Promise<unknown>;
     queryKnowledgeBase(id: string, input: Record<string, unknown>): Promise<unknown>;
     deleteKnowledgeBase(id: string): Promise<unknown>;
+    skills(query: Record<string, unknown>): Promise<unknown>;
+    skillFolders(): Promise<unknown>;
+    skill(id: string, version?: string): Promise<unknown>;
+    skillFile(id: string, path: string, version?: string): Promise<unknown>;
+    createSkill(input: Record<string, unknown>, idempotencyKey?: string): Promise<unknown>;
+    createSkillVersion(id: string, input: Record<string, unknown>, idempotencyKey?: string): Promise<unknown>;
+    updateSkill(id: string, input: Record<string, unknown>): Promise<unknown>;
+    setSkillProjects(id: string, projectIds: string[]): Promise<unknown>;
+    createSkillFolder(input: Record<string, unknown>): Promise<unknown>;
+    updateSkillFolder(id: string, input: Record<string, unknown>): Promise<unknown>;
+    skillDownloadGrant(id: string, versionId?: string): Promise<unknown>;
     updatePreferences(input: Record<string, unknown>): Promise<unknown>;
     memory(id: string): Promise<unknown>;
     toolUses(input: Record<string, unknown>): Promise<unknown>;

package/dist/cloud.js

@@ -1,6 +1,7 @@
 import { recordActivity } from './activity.js';
 import { loadConfig, loadTokens, saveTokens, validateApiUrl, vaultHome, } from './config.js';
 const KNOWLEDGE_BASE_RESPONSE_MAX_BYTES = 8 * 1024 * 1024;
+const SKILL_RESPONSE_MAX_BYTES = 8 * 1024 * 1024;
 const KNOWLEDGE_BASE_RESPONSE_LIMIT_ERROR = 'A base de conhecimento excede o limite de resposta de 8 MiB.';
 const observationTypes = new Set(['decision', 'discovery', 'fix', 'feature', 'refactor', 'other']);
 const retentionClasses = new Set(['transient', 'supporting', 'durable', 'critical']);
@@ -204,6 +205,36 @@ export class VaultCloudClient {
             method: 'DELETE',
         });
     }
+    async skills(query) { return this.request('/v1/skills', { query }); }
+    async skillFolders() { return this.request('/v1/skills/folders'); }
+    async skill(id, version) {
+        return this.request(`/v1/skills/${encodeURIComponent(id)}`, { query: { version } });
+    }
+    async skillFile(id, path, version) {
+        const encoded = path.split('/').map(encodeURIComponent).join('/');
+        return this.request(`/v1/skills/${encodeURIComponent(id)}/files/${encoded}`, { query: { version }, responseMaxBytes: SKILL_RESPONSE_MAX_BYTES });
+    }
+    async createSkill(input, idempotencyKey) {
+        return this.request('/v1/skills', { method: 'POST', body: input, timeoutMs: 60_000, ...(idempotencyKey ? { headers: { 'idempotency-key': idempotencyKey } } : {}) });
+    }
+    async createSkillVersion(id, input, idempotencyKey) {
+        return this.request(`/v1/skills/${encodeURIComponent(id)}/versions`, { method: 'POST', body: input, timeoutMs: 60_000, ...(idempotencyKey ? { headers: { 'idempotency-key': idempotencyKey } } : {}) });
+    }
+    async updateSkill(id, input) {
+        return this.request(`/v1/skills/${encodeURIComponent(id)}`, { method: 'PATCH', body: input });
+    }
+    async setSkillProjects(id, projectIds) {
+        return this.request(`/v1/skills/${encodeURIComponent(id)}/projects`, { method: 'PUT', body: { projectIds } });
+    }
+    async createSkillFolder(input) {
+        return this.request('/v1/skills/folders', { method: 'POST', body: input });
+    }
+    async updateSkillFolder(id, input) {
+        return this.request(`/v1/skills/folders/${encodeURIComponent(id)}`, { method: 'PATCH', body: input });
+    }
+    async skillDownloadGrant(id, versionId) {
+        return this.request(`/v1/skills/${encodeURIComponent(id)}/download-grants`, { method: 'POST', body: versionId ? { versionId } : {} });
+    }
     async updatePreferences(input) {
         return this.request('/preferences', { method: 'PATCH', body: input });
     }
@@ -286,6 +317,8 @@ export class VaultCloudClient {
         const headers = new Headers({ accept: 'application/json' });
         if (options.body)
             headers.set('content-type', 'application/json');
+        for (const [name, value] of Object.entries(options.headers ?? {}))
+            headers.set(name, value);
         if (options.authenticated !== false) {
             headers.set('authorization', `Bearer ${await this.accessToken(options.retried)}`);
         }

package/dist/crystal-memory-mirror.js

@@ -23,7 +23,15 @@ export async function resolveCrystalProjectFolder(cloud, projectId) {
     if (!Array.isArray(projects))
         return null;
     const found = projects.find((item) => item && typeof item === 'object' && item.id === projectId);
-    return crystalProjectFolder(found);
+    const folder = crystalProjectFolder(found);
+    if (!folder)
+        return null;
+    // Why: same-named projects used to share one Crystal folder and mix their
+    // memories. The oldest keeps the plain name (existing folders stay put); newer
+    // namesakes get a stable suffix from their id. Projects arrive newest first.
+    const namesakes = projects.filter((item) => crystalProjectFolder(item)?.toLowerCase() === folder.toLowerCase());
+    const oldest = namesakes.at(-1);
+    return oldest?.id === projectId ? folder : `${folder}-${projectId.slice(0, 8)}`;
 }
 export async function mirrorCrystalMemory(input) {
     if (!shouldMirrorCrystalMemory(input.job))

package/dist/hooks.js

@@ -10,6 +10,7 @@ import { vaultHome } from "./config.js";
 import { enqueueGeneration } from "./hook-queue.js";
 import { transcriptCaptureEnabled } from './transcript-config.js';
 import { loadProjectContext } from './context-chain.js';
+import { skillContextSection } from './skill-context.js';
 export const HOOK_EVENTS = [
     "context",
     "session-init",
@@ -246,6 +247,15 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
             })
             : { context: await loadProjectContext(home, cloud, { workspace, primary: { id: project.id }, projects, ...limits }) });
         let context = string(result.context).slice(0, limits.maxChars);
+        if (event === "context") {
+            // Skills do projeto entram depois da memória e só no espaço que sobrar; falha aqui nunca derruba o contexto.
+            try {
+                const skills = await skillContextSection(cloud, project.id);
+                if (skills && context.length + skills.length + 2 <= limits.maxChars)
+                    context = context ? `${context}\n\n${skills}` : skills;
+            }
+            catch { /* biblioteca de skills indisponível */ }
+        }
         try {
             context = applyCustomModeContext(home, context, limits.maxChars);
         }

package/dist/server.js

@@ -8,6 +8,7 @@ import { registerVaultModes } from './modes.js';
 import { registerCrystalTools } from './crystal-tools.js';
 import { registerModeIntegrations } from './mode-integrations.js';
 import { registerKnowledgeAgentTools } from './knowledge-tools.js';
+import { registerSkillTools } from './skill-tools.js';
 import { redact } from './hooks.js';
 import { createProjectScope } from './project-scope.js';
 import { VaultCloudClient } from './cloud.js';
@@ -55,6 +56,7 @@ export function createVaultGoServer(home = vaultHome(), cloud = new VaultCloudCl
     registerVaultModes(server);
     registerCrystalTools(server, home);
     registerKnowledgeAgentTools(server, home, cloud);
+    registerSkillTools(server, home, cloud);
     server.registerTool('vault_go_engines', {
         title: 'Listar motores de contexto',
         description: 'Lista os motores disponíveis para preparar contexto: Vault AI, Claude, OpenRouter, Gemini e ChatGPT/Codex. Não revela chaves.',

package/dist/skill-context.d.ts

@@ -0,0 +1,4 @@
+import type { VaultMemoryApi } from './cloud.js';
+export declare const clip: (text: string, max?: number) => string;
+/** Seção curta para o contexto de início de sessão; vazia quando não há o que mostrar. */
+export declare function skillContextSection(cloud: VaultMemoryApi, projectId: string, max?: number): Promise<string>;

package/dist/skill-context.js

@@ -0,0 +1,16 @@
+export const clip = (text, max = 200) => (text.length > max ? `${text.slice(0, max - 1)}…` : text);
+/** Seção curta para o contexto de início de sessão; vazia quando não há o que mostrar. */
+export async function skillContextSection(cloud, projectId, max = 20) {
+    if (!cloud.skills)
+        return '';
+    const raw = await cloud.skills({ projectId, limit: max });
+    const result = raw && typeof raw === 'object' ? raw : {};
+    const skills = Array.isArray(result.skills) ? result.skills : [];
+    if (!skills.length)
+        return '';
+    return [
+        '## Skills privadas do Vault',
+        ...skills.map(s => `- ${s.name}${s.folderPath ? ` (${s.folderPath})` : ''} — ${clip(s.description, 160)}`),
+        'Use `vault_go_skill_read skill="<nome>"` para carregar uma skill quando ela se aplicar à tarefa.',
+    ].join('\n');
+}

package/dist/skill-local.d.ts

@@ -0,0 +1,46 @@
+export declare const SKILL_MARKER = ".vault-skill.json";
+export declare const SKILL_FILE_MAX_BYTES: number;
+export declare const SKILL_MAX_FILES = 512;
+export declare const SKILL_TOTAL_MAX_BYTES: number;
+export declare class SkillLocalError extends Error {
+    code: string;
+    constructor(code: string, message: string);
+}
+export interface LocalSkillFile {
+    path: string;
+    content: string;
+    encoding: 'utf8' | 'base64';
+    executable: boolean;
+}
+export interface TarEntry {
+    path: string;
+    bytes: Buffer;
+    mode: number;
+}
+export interface InstalledSkill {
+    root: string;
+    dir: string;
+    skillId: string;
+    versionId: string;
+}
+/** name/description do frontmatter; valida só o formato mínimo (o servidor valida o resto). */
+export declare function frontmatter(md: string): {
+    name: string;
+    description: string;
+} | null;
+/** Lê uma pasta de skill para publicar; symlinks e pastas de ferramentas ficam de fora. */
+export declare function readSourceDir(directory: string): LocalSkillFile[];
+/** Leitor ustar mínimo: só arquivos regulares; link, dispositivo ou caminho perigoso recusa o pacote inteiro. */
+export declare function readTarGz(archive: Uint8Array): TarEntry[];
+export declare function installSkillArchive(input: {
+    bytes: Uint8Array;
+    expectedSha256: string;
+    dirName: string;
+    root: string;
+    skillId: string;
+    versionId: string;
+}): {
+    path: string;
+};
+/** Skills instaladas pelo Vault nas raízes informadas. */
+export declare function installedSkills(roots: string[]): InstalledSkill[];

package/dist/skill-local.js

@@ -0,0 +1,214 @@
+// Lado local da biblioteca de skills: ler uma pasta para publicar e instalar um
+// pacote baixado. A instalação confere sha256, cada arquivo e o digest do
+// manifesto, grava tudo numa pasta temporária irmã e só então troca de lugar.
+// Uma pasta que o Vault não instalou (sem .vault-skill.json) nunca é tocada.
+import { createHash, randomBytes } from 'node:crypto';
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+import { gunzipSync } from 'node:zlib';
+export const SKILL_MARKER = '.vault-skill.json';
+export const SKILL_FILE_MAX_BYTES = 4 * 1024 * 1024;
+export const SKILL_MAX_FILES = 512;
+export const SKILL_TOTAL_MAX_BYTES = 32 * 1024 * 1024;
+const EXPANDED_MAX_BYTES = 40 * 1024 * 1024;
+const IGNORED = new Set(['.git', 'node_modules', '.DS_Store', SKILL_MARKER]);
+const NAME = /^[a-z0-9][a-z0-9.-]{0,63}$/;
+export class SkillLocalError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+const sha256 = (bytes) => createHash('sha256').update(bytes).digest('hex');
+/** name/description do frontmatter; valida só o formato mínimo (o servidor valida o resto). */
+export function frontmatter(md) {
+    const block = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(md)?.[1];
+    if (!block)
+        return null;
+    const field = (key) => {
+        const raw = new RegExp(`^${key}:[ \\t]*(.+)$`, 'm').exec(block)?.[1]?.trim();
+        return raw ? raw.replace(/^(['"])(.*)\1$/, '$2').trim() : '';
+    };
+    const name = field('name'), description = field('description');
+    return name && description ? { name, description } : null;
+}
+function isText(bytes) {
+    if (bytes.includes(0))
+        return false;
+    try {
+        new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Lê uma pasta de skill para publicar; symlinks e pastas de ferramentas ficam de fora. */
+export function readSourceDir(directory) {
+    const base = resolve(directory);
+    if (!lstatSync(base).isDirectory())
+        throw new SkillLocalError('source_invalid', `Não é uma pasta: ${directory}`);
+    const files = [];
+    let total = 0;
+    const walk = (dir) => {
+        for (const name of readdirSync(dir).sort()) {
+            if (IGNORED.has(name))
+                continue;
+            const full = join(dir, name);
+            const stat = lstatSync(full);
+            if (stat.isSymbolicLink())
+                continue;
+            if (stat.isDirectory()) {
+                walk(full);
+                continue;
+            }
+            if (!stat.isFile())
+                continue;
+            if (files.length >= SKILL_MAX_FILES)
+                throw new SkillLocalError('payload_too_large', `A skill passa de ${SKILL_MAX_FILES} arquivos`);
+            if (stat.size > SKILL_FILE_MAX_BYTES)
+                throw new SkillLocalError('payload_too_large', `Arquivo acima de 4 MiB: ${relative(base, full)}`);
+            total += stat.size;
+            if (total > SKILL_TOTAL_MAX_BYTES)
+                throw new SkillLocalError('payload_too_large', 'Skill acima de 32 MiB');
+            const bytes = readFileSync(full);
+            const text = isText(bytes);
+            files.push({ path: relative(base, full).split(sep).join('/'), content: text ? bytes.toString('utf8') : bytes.toString('base64'), encoding: text ? 'utf8' : 'base64', executable: (stat.mode & 0o111) !== 0 });
+        }
+    };
+    walk(base);
+    return files.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+}
+function safePath(path) {
+    if (!path || path.startsWith('/') || path.includes('\\') || path.includes('\0') || /^[A-Za-z]:/.test(path))
+        throw new SkillLocalError('skill_package_invalid', `Caminho inválido no pacote: ${path}`);
+    const segments = path.split('/');
+    if (segments.some(s => s === '' || s === '.' || s === '..'))
+        throw new SkillLocalError('skill_package_invalid', `Caminho inválido no pacote: ${path}`);
+    return path;
+}
+/** Leitor ustar mínimo: só arquivos regulares; link, dispositivo ou caminho perigoso recusa o pacote inteiro. */
+export function readTarGz(archive) {
+    let tar;
+    try {
+        tar = gunzipSync(archive, { maxOutputLength: EXPANDED_MAX_BYTES });
+    }
+    catch {
+        throw new SkillLocalError('skill_package_invalid', 'Pacote corrompido');
+    }
+    const field = (block, offset, length) => { const raw = block.subarray(offset, offset + length); const end = raw.indexOf(0); return (end === -1 ? raw : raw.subarray(0, end)).toString('utf8'); };
+    const entries = [];
+    let offset = 0;
+    while (offset + 512 <= tar.length) {
+        const header = tar.subarray(offset, offset + 512);
+        if (header.every(b => b === 0))
+            break;
+        const type = String.fromCharCode(header[156]);
+        if (type !== '0' && type !== '\0')
+            throw new SkillLocalError('skill_package_invalid', 'Pacote contém entrada que não é arquivo regular');
+        const name = field(header, 0, 100), prefix = field(header, 345, 155);
+        const size = parseInt(field(header, 124, 12).trim() || '0', 8), mode = parseInt(field(header, 100, 8).trim() || '0', 8);
+        if (!Number.isSafeInteger(size) || size < 0 || offset + 512 + size > tar.length)
+            throw new SkillLocalError('skill_package_invalid', 'Pacote corrompido');
+        if (entries.length > SKILL_MAX_FILES + 2)
+            throw new SkillLocalError('skill_package_invalid', 'Pacote com entradas demais');
+        entries.push({ path: safePath(prefix ? `${prefix}/${name}` : name), bytes: Buffer.from(tar.subarray(offset + 512, offset + 512 + size)), mode });
+        offset += 512 + Math.ceil(size / 512) * 512;
+    }
+    return entries;
+}
+/** Confere o manifest.json do formato do Vault contra os bytes: nada fora dele, nada faltando, digest correto. */
+function verifiedFiles(entries) {
+    const integrity = (detail) => new SkillLocalError('skill_install_integrity', `Falha de integridade do pacote: ${detail}`);
+    const byPath = new Map(entries.map(e => [e.path, e]));
+    if (byPath.has('dev.orca.skill-sharing/manifest.json'))
+        throw new SkillLocalError('skill_install_unsupported', 'Pacotes com várias skills (bundle) devem ser instalados pelo Vault Desktop');
+    const raw = byPath.get('manifest.json');
+    if (!raw)
+        throw integrity('manifest.json ausente');
+    let manifest;
+    try {
+        manifest = JSON.parse(raw.bytes.toString('utf8'));
+    }
+    catch {
+        throw integrity('manifest.json inválido');
+    }
+    const files = Array.isArray(manifest.files) ? manifest.files : [];
+    if (!files.some(f => f.path === 'SKILL.md'))
+        throw integrity('SKILL.md ausente');
+    const digest = createHash('sha256').update(JSON.stringify(files.map(f => ({ path: f.path, executable: f.executable, classification: f.classification, identitySha256: f.identitySha256 })))).digest('hex');
+    if (digest !== manifest.packageDigest)
+        throw integrity('digest do manifesto');
+    if (entries.length !== files.length + 1)
+        throw integrity('entradas fora do manifesto');
+    return files.map(file => {
+        const entry = byPath.get(safePath(file.path));
+        if (!entry || entry.bytes.length !== file.size || sha256(entry.bytes) !== file.sha256)
+            throw integrity(file.path);
+        return { file, entry };
+    });
+}
+export function installSkillArchive(input) {
+    if (!NAME.test(input.dirName) || input.dirName.includes('..'))
+        throw new SkillLocalError('skill_install_invalid', `Nome de pasta inválido: ${input.dirName}`);
+    if (sha256(input.bytes) !== input.expectedSha256)
+        throw new SkillLocalError('skill_install_integrity', 'Falha de integridade do pacote: sha256');
+    const files = verifiedFiles(readTarGz(input.bytes));
+    const root = resolve(input.root);
+    const target = join(root, input.dirName);
+    if (existsSync(target) && !existsSync(join(target, SKILL_MARKER))) {
+        throw new SkillLocalError('skill_install_conflict', `${target} já existe e não foi instalada pelo Vault; nada foi alterado`);
+    }
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    const token = `${process.pid}-${randomBytes(4).toString('hex')}`;
+    const staging = join(root, `.${input.dirName}.vault-tmp-${token}`);
+    const previous = join(root, `.${input.dirName}.vault-old-${token}`);
+    try {
+        for (const { file, entry } of files) {
+            const destination = resolve(staging, file.path);
+            if (!destination.startsWith(staging + sep))
+                throw new SkillLocalError('skill_package_invalid', `Caminho inválido no pacote: ${file.path}`);
+            mkdirSync(dirname(destination), { recursive: true, mode: 0o700 });
+            writeFileSync(destination, entry.bytes, { mode: file.executable ? 0o755 : 0o644 });
+        }
+        writeFileSync(join(staging, SKILL_MARKER), `${JSON.stringify({ skillId: input.skillId, versionId: input.versionId, installedAt: new Date().toISOString() }, null, 2)}\n`, { mode: 0o644 });
+        const replacing = existsSync(target);
+        if (replacing)
+            renameSync(target, previous);
+        try {
+            renameSync(staging, target);
+        }
+        catch (error) {
+            if (replacing)
+                renameSync(previous, target);
+            throw error;
+        }
+        if (replacing)
+            rmSync(previous, { recursive: true, force: true });
+        return { path: target };
+    }
+    finally {
+        rmSync(staging, { recursive: true, force: true });
+    }
+}
+/** Skills instaladas pelo Vault nas raízes informadas. */
+export function installedSkills(roots) {
+    const out = [];
+    for (const root of roots) {
+        if (!existsSync(root))
+            continue;
+        for (const dir of readdirSync(root).sort()) {
+            const marker = join(root, dir, SKILL_MARKER);
+            if (dir.startsWith('.') || !existsSync(marker))
+                continue;
+            try {
+                const data = JSON.parse(readFileSync(marker, 'utf8'));
+                if (typeof data.skillId === 'string' && typeof data.versionId === 'string')
+                    out.push({ root, dir, skillId: data.skillId, versionId: data.versionId });
+            }
+            catch { /* marcador corrompido: tratado como não gerenciado */ }
+        }
+    }
+    return out;
+}

package/dist/skill-tools.d.ts

@@ -0,0 +1,52 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { VaultMemoryApi } from './cloud.js';
+import { skillContextSection } from './skill-context.js';
+export { skillContextSection };
+export declare const SKILL_TEXT_MAX: number;
+export interface SkillToolOptions {
+    cwd?: () => string;
+    fetch?: typeof fetch;
+    userHome?: string;
+    maxChars?: number;
+}
+type Folder = {
+    id: string;
+    parentId: string | null;
+    name: string;
+    path: string;
+    depth: number;
+    skillCount: number;
+};
+type Summary = {
+    id: string;
+    name: string;
+    description: string;
+    folderId: string | null;
+    folderPath: string | null;
+    projectIds: string[];
+    scope?: string;
+    latestVersion: {
+        id: string;
+    } | null;
+};
+export declare function page(text: string, offset?: number, max?: number): {
+    text: string;
+    offset: number;
+    nextOffset: number | null;
+    truncated: boolean;
+};
+export declare function loadFolders(cloud: VaultMemoryApi): Promise<Folder[]>;
+/** Caminho "a/b" → id da pasta ('' ou '/' = raiz → null). */
+export declare function folderByPath(folders: Folder[], path: string): Folder | null | undefined;
+/** Aceita o id da skill, `pasta/sub/nome` ou só `nome` (quando for único). */
+export declare function resolveSkill(cloud: VaultMemoryApi, ref: string): Promise<Summary | {
+    id: string;
+}>;
+export declare function currentProject(cloud: VaultMemoryApi, cwd: string): Promise<{
+    id: string;
+    name: string;
+} | null>;
+export declare const SKILL_TARGETS: readonly ["claude", "grok", "agents"];
+export type SkillTarget = typeof SKILL_TARGETS[number];
+export declare function targetRoot(target: SkillTarget, userHome?: string): string;
+export declare function registerSkillTools(server: McpServer, home: string, cloud: VaultMemoryApi, options?: SkillToolOptions): void;

package/dist/skill-tools.js

@@ -0,0 +1,369 @@
+// Biblioteca privada de skills do Vault pelo MCP: listar, ler, salvar, organizar
+// e instalar localmente. Excluir fica de fora de propósito (só nas interfaces).
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { findWorkspaceProject } from './hooks.js';
+import { run } from './mcp-result.js';
+import { clip, skillContextSection } from './skill-context.js';
+import { frontmatter, installedSkills, installSkillArchive, readSourceDir } from './skill-local.js';
+export { skillContextSection };
+export const SKILL_TEXT_MAX = 64 * 1024;
+const SOURCE = 'biblioteca privada de skills do usuário (Vault)';
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const unsupported = () => { throw new Error('Este Vault ainda não oferece a biblioteca de skills. Atualize o vault-go ou o servidor.'); };
+/** Método do cliente preso ao próprio objeto: o VaultCloudClient é uma classe e depende do this. */
+function api(cloud, key) {
+    const fn = cloud[key];
+    if (typeof fn !== 'function')
+        return unsupported();
+    return fn.bind(cloud);
+}
+const record = (value) => (value && typeof value === 'object' && !Array.isArray(value) ? value : {});
+export function page(text, offset = 0, max = SKILL_TEXT_MAX) {
+    const start = Math.max(0, Math.min(offset, text.length));
+    const end = Math.min(text.length, start + max);
+    return { text: text.slice(start, end), offset: start, nextOffset: end < text.length ? end : null, truncated: end < text.length };
+}
+export async function loadFolders(cloud) {
+    const folders = record(await api(cloud, 'skillFolders')()).folders;
+    if (!Array.isArray(folders))
+        throw new Error('Resposta de pastas inválida.');
+    return folders;
+}
+/** Caminho "a/b" → id da pasta ('' ou '/' = raiz → null). */
+export function folderByPath(folders, path) {
+    const normalized = path.trim().replace(/^\/+|\/+$/g, '');
+    if (!normalized)
+        return null;
+    return folders.find(f => f.path.toLowerCase() === normalized.toLowerCase());
+}
+async function listAll(cloud, query) {
+    const out = [];
+    let cursor;
+    for (let i = 0; i < 20; i++) {
+        const result = record(await api(cloud, 'skills')({ ...query, limit: 100, ...(cursor ? { cursor } : {}) }));
+        out.push(...(Array.isArray(result.skills) ? result.skills : []));
+        if (typeof result.nextCursor !== 'string')
+            break;
+        cursor = result.nextCursor;
+    }
+    return out;
+}
+/** Aceita o id da skill, `pasta/sub/nome` ou só `nome` (quando for único). */
+export async function resolveSkill(cloud, ref) {
+    const value = ref.trim();
+    if (UUID.test(value))
+        return { id: value };
+    const parts = value.replace(/^\/+|\/+$/g, '').split('/');
+    const name = parts.pop().toLowerCase();
+    if (parts.length) {
+        const folder = folderByPath(await loadFolders(cloud), parts.join('/'));
+        if (!folder)
+            throw new Error(`Pasta não encontrada: ${parts.join('/')}`);
+        const found = (await listAll(cloud, { folderId: folder.id })).find(s => s.name.toLowerCase() === name);
+        if (!found)
+            throw new Error(`Skill não encontrada: ${value}`);
+        return found;
+    }
+    const matches = (await listAll(cloud, {})).filter(s => s.name.toLowerCase() === name);
+    if (matches.length === 1)
+        return matches[0];
+    if (!matches.length)
+        throw new Error(`Skill não encontrada: ${value}`);
+    throw new Error(`Mais de uma skill com esse nome; informe o caminho: ${matches.map(s => `${s.folderPath ? `${s.folderPath}/` : ''}${s.name}`).join(', ')}`);
+}
+export async function currentProject(cloud, cwd) {
+    try {
+        const project = await findWorkspaceProject(cloud, cwd);
+        return project && typeof project.id === 'string' ? { id: project.id, name: typeof project.name === 'string' ? project.name : '' } : null;
+    }
+    catch {
+        return null;
+    }
+}
+const ARCHIVE_MAX_BYTES = 40 * 1024 * 1024;
+export const SKILL_TARGETS = ['claude', 'grok', 'agents'];
+export function targetRoot(target, userHome = homedir()) {
+    return target === 'agents' ? join(userHome, '.agents', 'skills') : join(userHome, `.${target}`, 'skills');
+}
+/** Garante a pasta pelo caminho, criando os segmentos que faltarem; '' é a raiz (null). */
+async function ensureFolder(cloud, path) {
+    const segments = path.trim().replace(/^\/+|\/+$/g, '').split('/').filter(Boolean);
+    if (!segments.length)
+        return null;
+    const folders = await loadFolders(cloud);
+    let parentId = null;
+    let prefix = '';
+    for (const name of segments) {
+        prefix = prefix ? `${prefix}/${name}` : name;
+        const existing = folderByPath(folders, prefix);
+        if (existing) {
+            parentId = existing.id;
+            continue;
+        }
+        const created = record(record(await api(cloud, 'createSkillFolder')({ name, parentId })).folder);
+        if (typeof created.id !== 'string')
+            throw new Error('Resposta de pasta inválida.');
+        folders.push(created);
+        parentId = created.id;
+    }
+    return parentId;
+}
+const union = (a, b) => [...new Set([...a, ...b])];
+const compact = (s) => ({ id: s.id, name: s.name, description: clip(s.description), folder: s.folderPath, scope: s.scope ?? null, version: s.latestVersion?.id ?? null, projectIds: s.projectIds });
+function tree(folders) {
+    return folders.map(f => `${'  '.repeat(f.depth - 1)}${f.name} (${f.skillCount})`).join('\n');
+}
+export function registerSkillTools(server, home, cloud, options = {}) {
+    void home;
+    const cwd = options.cwd ?? (() => process.cwd());
+    const max = options.maxChars ?? SKILL_TEXT_MAX;
+    const read = { readOnlyHint: true, idempotentHint: true, openWorldHint: true };
+    const skillRef = z.string().trim().min(1).max(600).describe('Id da skill, "pasta/sub/nome" ou só o nome quando for único');
+    const version = z.string().trim().regex(/^[A-Za-z0-9_-]{1,128}$/).optional();
+    const offset = z.number().int().min(0).default(0);
+    server.registerTool('vault_go_skills', {
+        title: 'Listar skills privadas',
+        description: 'Lista a biblioteca privada de skills do usuário. Sem projectId, usa o projeto do diretório atual (skills do projeto primeiro, depois as globais). Use q para busca por texto e folder ("dev/review") para filtrar por pasta.',
+        inputSchema: {
+            q: z.string().trim().min(1).max(200).optional(), folder: z.string().trim().max(600).optional(), recursive: z.boolean().optional(),
+            projectId: z.string().trim().min(1).max(128).optional(), ignoreProject: z.boolean().optional(), limit: z.number().int().min(1).max(50).default(25),
+            cursor: z.string().max(200).optional(),
+        },
+        annotations: read,
+    }, async (input) => run(async () => {
+        const query = {};
+        if (input.q)
+            query.q = input.q;
+        if (input.folder !== undefined) {
+            const folder = folderByPath(await loadFolders(cloud), input.folder);
+            if (folder === undefined)
+                throw new Error(`Pasta não encontrada: ${input.folder}`);
+            query.folderId = folder ? folder.id : 'root';
+            if (input.recursive)
+                query.recursive = 'true';
+        }
+        const project = input.projectId ? { id: input.projectId, name: '' } : input.ignoreProject ? null : await currentProject(cloud, cwd());
+        if (project)
+            query.projectId = project.id;
+        query.limit = input.limit;
+        if (input.cursor)
+            query.cursor = input.cursor;
+        const result = record(await api(cloud, 'skills')(query));
+        const skills = (Array.isArray(result.skills) ? result.skills : []).map(compact);
+        return {
+            project, skills, nextCursor: result.nextCursor ?? null,
+            ...(!project && !input.ignoreProject && !input.projectId ? { note: 'Nenhum projeto do Vault corresponde ao diretório atual; listando toda a biblioteca.' } : {}),
+        };
+    }));
+    server.registerTool('vault_go_skill_folders', {
+        title: 'Pastas de skills',
+        description: 'Mostra a árvore de pastas da biblioteca privada de skills, com a quantidade de skills em cada pasta.',
+        inputSchema: {}, annotations: read,
+    }, async () => run(async () => {
+        const folders = await loadFolders(cloud);
+        return { tree: tree(folders), folders };
+    }));
+    server.registerTool('vault_go_skill_read', {
+        title: 'Ler skill',
+        description: 'Carrega uma skill da biblioteca privada: o SKILL.md completo e a lista de arquivos. Siga o SKILL.md; abra arquivos auxiliares com vault_go_skill_file só quando ele mandar.',
+        inputSchema: { skill: skillRef, version, offset }, annotations: read,
+    }, async (input) => run(async () => {
+        const { id } = await resolveSkill(cloud, input.skill);
+        const skill = record(record(await api(cloud, 'skill')(id, input.version)).skill);
+        const md = page(typeof skill.skillMd === 'string' ? skill.skillMd : '', input.offset, max);
+        const files = (Array.isArray(skill.files) ? skill.files : []).map(f => ({ path: f.path, size: f.size, kind: f.classification }));
+        return {
+            source: SOURCE, id: skill.id, name: skill.name, description: skill.description, folder: skill.folderPath ?? null,
+            version: record(skill.version).id ?? null, projectIds: skill.projectIds ?? [],
+            instructions: 'Siga as instruções do SKILL.md. Abra um arquivo auxiliar com vault_go_skill_file somente quando o SKILL.md o referenciar e ele for necessário. Não execute scripts sem necessidade clara.',
+            skillMd: md.text, offset: md.offset, nextOffset: md.nextOffset, truncated: md.truncated, files,
+        };
+    }));
+    server.registerTool('vault_go_skill_file', {
+        title: 'Ler arquivo de skill',
+        description: 'Lê um arquivo auxiliar de uma skill (ex.: references/guia.md, scripts/run.py). Texto volta em UTF-8; binário em base64. Conteúdo grande é paginado com offset.',
+        inputSchema: { skill: skillRef, path: z.string().trim().min(1).max(1024), version, offset }, annotations: read,
+    }, async (input) => run(async () => {
+        const { id } = await resolveSkill(cloud, input.skill);
+        const file = record(await api(cloud, 'skillFile')(id, input.path, input.version));
+        const content = page(typeof file.content === 'string' ? file.content : '', input.offset, max);
+        return { source: SOURCE, path: file.path, encoding: file.encoding, size: file.size, executable: file.executable ?? false, version: file.version ?? null, content: content.text, offset: content.offset, nextOffset: content.nextOffset, truncated: content.truncated };
+    }));
+    const fileInput = z.object({
+        path: z.string().trim().min(1).max(1024), content: z.string(), encoding: z.enum(['utf8', 'base64']).optional(), executable: z.boolean().optional(),
+    });
+    const normalize = (files) => files.map(f => ({ path: f.path, content: f.content, encoding: f.encoding ?? 'utf8', ...(f.executable !== undefined ? { executable: f.executable } : {}) }));
+    const write = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true };
+    server.registerTool('vault_go_skill_save', {
+        title: 'Salvar skill',
+        description: 'Salva uma skill na biblioteca privada: cria se não existir nessa pasta, senão publica uma nova versão (as anteriores ficam guardadas). Envie files (SKILL.md com frontmatter name/description e arquivos auxiliares) ou sourceDir (pasta local). folder aceita caminho ("dev/review") e cria o que faltar. linkCurrentProject liga ao projeto do diretório atual.',
+        inputSchema: {
+            name: z.string().trim().min(1).max(64).optional(), description: z.string().trim().min(1).max(4096).optional(),
+            folder: z.string().trim().max(600).optional(), projectIds: z.array(z.string().trim().min(1).max(128)).max(50).optional(),
+            linkCurrentProject: z.boolean().optional(), files: z.array(fileInput).max(512).optional(), sourceDir: z.string().trim().min(1).max(2000).optional(),
+            patch: z.boolean().optional(), remove: z.array(z.string().trim().min(1).max(1024)).max(512).optional(),
+            baseVersion: z.string().trim().regex(/^[A-Za-z0-9_-]{1,128}$/).optional(), releaseNotes: z.string().max(10_000).optional(),
+        },
+        annotations: write,
+    }, async (input) => run(async () => {
+        if (!input.files && !input.sourceDir)
+            throw new Error('Informe files ou sourceDir.');
+        const files = input.sourceDir ? readSourceDir(input.sourceDir) : normalize(input.files ?? []);
+        const md = files.find(f => f.path === 'SKILL.md');
+        const front = md && md.encoding === 'utf8' ? frontmatter(md.content) : null;
+        if (!input.patch && !front)
+            throw new Error('SKILL.md na raiz precisa de frontmatter com name e description.');
+        if (input.patch && !input.baseVersion)
+            throw new Error('patch exige baseVersion.');
+        const name = input.name ?? front?.name;
+        if (!name)
+            throw new Error('Informe name (ou um SKILL.md com frontmatter).');
+        const folderId = input.folder !== undefined ? await ensureFolder(cloud, input.folder) : null;
+        const existing = (await listAll(cloud, { folderId: folderId ?? 'root' })).find(s => s.name.toLowerCase() === name.toLowerCase());
+        const project = input.linkCurrentProject ? await currentProject(cloud, cwd()) : null;
+        if (input.linkCurrentProject && !project)
+            throw new Error('Nenhum projeto do Vault corresponde ao diretório atual.');
+        const links = union(input.projectIds ?? [], project ? [project.id] : []);
+        const releaseNotes = input.releaseNotes ?? '';
+        const naming = { ...(input.name ? { name: input.name } : {}), ...(input.description ? { description: input.description } : {}) };
+        if (!existing) {
+            if (input.patch)
+                throw new Error(`Skill não encontrada para patch: ${name}`);
+            const created = record(await api(cloud, 'createSkill')({ files, folderId, releaseNotes, ...naming, ...(links.length ? { projectIds: links } : {}) }));
+            return { action: 'created', skill: compact(record(created.skill)) };
+        }
+        const body = input.patch
+            ? { baseVersion: input.baseVersion, upsert: files, remove: input.remove ?? [], releaseNotes, ...(input.description ? { description: input.description } : {}) }
+            : { files, ...(input.baseVersion ? { baseVersion: input.baseVersion } : {}), releaseNotes, ...naming };
+        let updated = record(record(await api(cloud, 'createSkillVersion')(existing.id, body)).skill);
+        if (links.length)
+            updated = record(record(await api(cloud, 'setSkillProjects')(existing.id, union(existing.projectIds ?? [], links))).skill);
+        return { action: 'updated', skill: compact(updated) };
+    }));
+    server.registerTool('vault_go_skill_organize', {
+        title: 'Organizar skills',
+        description: 'Organiza a biblioteca privada: create_folder, move_folder, rename_folder, move_skill, rename_skill, link_projects e unlink_projects. Caminhos de pasta usam "/" e "" é a raiz. Sem projectIds, link/unlink usam o projeto do diretório atual. Não exclui nada.',
+        inputSchema: {
+            action: z.enum(['create_folder', 'move_folder', 'rename_folder', 'move_skill', 'rename_skill', 'link_projects', 'unlink_projects']),
+            skill: skillRef.optional(), folder: z.string().trim().max(600).optional(), targetFolder: z.string().trim().max(600).optional(),
+            newName: z.string().trim().min(1).max(64).optional(), description: z.string().trim().min(1).max(4096).optional(),
+            projectIds: z.array(z.string().trim().min(1).max(128)).max(50).optional(),
+        },
+        annotations: write,
+    }, async (input) => run(async () => {
+        const required = (value, field) => { if (value === undefined || value === null)
+            throw new Error(`${input.action} exige ${field}.`); return value; };
+        const existingFolder = async (path) => {
+            const folder = folderByPath(await loadFolders(cloud), path);
+            if (!folder)
+                throw new Error(`Pasta não encontrada: ${path}`);
+            return folder;
+        };
+        switch (input.action) {
+            case 'create_folder':
+                return { folderId: await ensureFolder(cloud, required(input.folder, 'folder')) };
+            case 'rename_folder': {
+                const folder = await existingFolder(required(input.folder, 'folder'));
+                return api(cloud, 'updateSkillFolder')(folder.id, { name: required(input.newName, 'newName') });
+            }
+            case 'move_folder': {
+                const folder = await existingFolder(required(input.folder, 'folder'));
+                return api(cloud, 'updateSkillFolder')(folder.id, { parentId: await ensureFolder(cloud, required(input.targetFolder, 'targetFolder')) });
+            }
+            case 'move_skill': {
+                const target = required(input.targetFolder, 'targetFolder');
+                const { id } = await resolveSkill(cloud, required(input.skill, 'skill'));
+                return api(cloud, 'updateSkill')(id, { folderId: await ensureFolder(cloud, target) });
+            }
+            case 'rename_skill': {
+                const { id } = await resolveSkill(cloud, required(input.skill, 'skill'));
+                return api(cloud, 'updateSkill')(id, { name: required(input.newName, 'newName'), ...(input.description ? { description: input.description } : {}) });
+            }
+            case 'link_projects':
+            case 'unlink_projects': {
+                const { id } = await resolveSkill(cloud, required(input.skill, 'skill'));
+                let ids = input.projectIds;
+                if (!ids?.length) {
+                    const project = await currentProject(cloud, cwd());
+                    if (!project)
+                        throw new Error('Informe projectIds: nenhum projeto do Vault corresponde ao diretório atual.');
+                    ids = [project.id];
+                }
+                const current = record(record(await api(cloud, 'skill')(id)).skill).projectIds ?? [];
+                const next = input.action === 'link_projects' ? union(current, ids) : current.filter(p => !ids.includes(p));
+                return api(cloud, 'setSkillProjects')(id, next);
+            }
+        }
+    }));
+    const userHome = options.userHome ?? homedir();
+    const fetcher = options.fetch ?? globalThis.fetch;
+    const targets = z.array(z.enum(SKILL_TARGETS)).min(1).max(3).default(['claude']);
+    async function download(id, versionId) {
+        const grant = record(await api(cloud, 'skillDownloadGrant')(id, versionId));
+        const url = record(grant.grant).url, version = record(grant.version);
+        if (typeof url !== 'string' || typeof version.archiveSha256 !== 'string' || typeof version.id !== 'string')
+            throw new Error('Resposta de download inválida.');
+        const response = await fetcher(url, { redirect: 'error', signal: AbortSignal.timeout(60_000) });
+        if (!response.ok)
+            throw new Error(`Download da skill falhou (HTTP ${response.status}).`);
+        const bytes = new Uint8Array(await response.arrayBuffer());
+        if (bytes.length > ARCHIVE_MAX_BYTES)
+            throw new Error('Pacote acima de 40 MiB.');
+        return { bytes, sha256: version.archiveSha256, versionId: version.id };
+    }
+    async function installInto(id, name, roots, versionId) {
+        const archive = await download(id, versionId);
+        return roots.map(root => ({ root, versionId: archive.versionId, ...installSkillArchive({ bytes: archive.bytes, expectedSha256: archive.sha256, dirName: name, root, skillId: id, versionId: archive.versionId }) }));
+    }
+    server.registerTool('vault_go_skill_install', {
+        title: 'Instalar skill localmente',
+        description: 'Baixa uma skill da biblioteca privada, confere a integridade e instala em ~/.claude/skills (ou .grok/.agents). Nunca sobrescreve uma skill que o Vault não instalou.',
+        inputSchema: { skill: skillRef, version, targets },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (input) => run(async () => {
+        const { id } = await resolveSkill(cloud, input.skill);
+        const detail = record(record(await api(cloud, 'skill')(id, input.version)).skill);
+        const name = String(detail.name);
+        const done = await installInto(id, name, input.targets.map(t => targetRoot(t, userHome)), input.version);
+        return { installed: done.map((d, i) => ({ target: input.targets[i], path: d.path, versionId: d.versionId })) };
+    }));
+    server.registerTool('vault_go_skill_sync', {
+        title: 'Sincronizar skills instaladas',
+        description: 'Atualiza as skills instaladas pelo Vault que têm versão nova. Com currentProject ou projectId, também instala as skills vinculadas ao projeto que ainda não estão instaladas.',
+        inputSchema: { currentProject: z.boolean().optional(), projectId: z.string().trim().min(1).max(128).optional(), targets },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (input) => run(async () => {
+        const roots = SKILL_TARGETS.map(t => targetRoot(t, userHome));
+        const installed = installedSkills(roots);
+        const updated = [], missing = [], added = [];
+        for (const item of installed) {
+            let detail;
+            try {
+                detail = record(record(await api(cloud, 'skill')(item.skillId)).skill);
+            }
+            catch {
+                missing.push({ skill: item.dir, path: join(item.root, item.dir) });
+                continue;
+            }
+            const latest = record(detail.latestVersion).id;
+            if (typeof latest !== 'string' || latest === item.versionId)
+                continue;
+            const [done] = await installInto(item.skillId, item.dir, [item.root], latest);
+            updated.push({ skill: detail.name, from: item.versionId, to: latest, path: done.path });
+        }
+        const projectId = input.projectId ?? (input.currentProject ? (await currentProject(cloud, cwd()))?.id : undefined);
+        if (input.currentProject && !projectId)
+            throw new Error('Nenhum projeto do Vault corresponde ao diretório atual.');
+        if (projectId) {
+            const have = new Set(installedSkills(roots).map(i => i.skillId));
+            const linked = (await listAll(cloud, { projectId })).filter(s => s.scope === 'project' && !have.has(s.id));
+            for (const skill of linked) {
+                const done = await installInto(skill.id, skill.name, input.targets.map(t => targetRoot(t, userHome)));
+                added.push(...done.map(d => ({ skill: skill.name, path: d.path, versionId: d.versionId })));
+            }
+        }
+        return { updated, installed: added, missing };
+    }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vault-go",
-  "version": "0.29.1",
+  "version": "0.30.0",
   "description": "MCP server and installer for Vault Memory: search, capture, and use account memory across AI clients.",
   "type": "module",
   "bin": {
@@ -26,6 +26,12 @@
     "dist/knowledge-agent.d.ts",
     "dist/knowledge-tools.js",
     "dist/knowledge-tools.d.ts",
+    "dist/skill-context.js",
+    "dist/skill-context.d.ts",
+    "dist/skill-local.js",
+    "dist/skill-local.d.ts",
+    "dist/skill-tools.js",
+    "dist/skill-tools.d.ts",
     "dist/activity.js",
     "dist/activity.d.ts",
     "dist/auth.js",