vault-go 0.30.0 → 0.31.0

package/dist/server.js

@@ -14,6 +14,8 @@ import { createProjectScope } from './project-scope.js';
 import { VaultCloudClient } from './cloud.js';
 import { getStatus, vaultHome } from './config.js';
 import { createPrivateBackup, restorePrivateBackup } from './backup.js';
+import { estimateAgentCost } from './agent-cost.js';
+import { flattenArchive, groupArchive, recordsFromExport } from './memory-archive.js';
 import { CONTEXT_ENGINE_IDS, generateContext, listContextEngines, parseEngineModel, selectContextEngine, selectEngineModel, selectedContextEngine, selectedEngineModel, } from './context-engines.js';
 import packageJson from '../package.json' with { type: 'json' };
 export const VERSION = packageJson.version;
@@ -486,6 +488,70 @@ export function createVaultGoServer(home = vaultHome(), cloud = new VaultCloudCl
         },
         annotations: { readOnlyHint: false, idempotentHint: true, openWorldHint: true },
     }, async (input) => run(() => cloud.importMemories(input)));
+    const archiveRecord = z.object({
+        sourceId: z.string().trim().min(1).max(500),
+        kind: z.string().trim().min(1).max(100),
+        content: z.string().trim().min(1).max(200_000),
+        title: z.string().trim().max(500).optional(),
+        sessionId: z.string().uuid().optional(),
+        memoryType: z.string().trim().min(1).max(100).optional(),
+        facts: z.array(z.string().trim().min(1).max(2_000)).max(200).optional(),
+        concepts: z.array(z.string().trim().min(1).max(500)).max(200).optional(),
+        filesRead: z.array(z.string().trim().min(1).max(2_000)).max(500).optional(),
+        filesModified: z.array(z.string().trim().min(1).max(2_000)).max(500).optional(),
+        occurredAt: z.string().trim().max(40).optional(),
+    });
+    const archiveGroup = z.array(archiveRecord).max(1_000);
+    server.registerTool('vault_go_archive_export', {
+        title: 'Exportar arquivo em quatro grupos',
+        description: 'Exporta memórias da conta e as separa em observations, sessions, summaries e prompts.',
+        inputSchema: {
+            projectId: uuid.optional(),
+            limit: z.number().int().min(1).max(1_000).default(500),
+        },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+    }, async (input) => run(async () => groupArchive(recordsFromExport(await cloud.exportMemories(input)))));
+    server.registerTool('vault_go_archive_import', {
+        title: 'Importar arquivo em quatro grupos',
+        description: 'Importa observations, sessions, summaries e prompts para um projeto existente.',
+        inputSchema: {
+            projectId: uuid,
+            observations: archiveGroup.default([]),
+            sessions: archiveGroup.default([]),
+            summaries: archiveGroup.default([]),
+            prompts: archiveGroup.default([]),
+        },
+        annotations: { readOnlyHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (input) => run(() => {
+        const records = flattenArchive({
+            version: 1,
+            format: 'vault-memory-groups',
+            observations: input.observations,
+            sessions: input.sessions,
+            summaries: input.summaries,
+            prompts: input.prompts,
+        }).map(record => ({
+            sourceId: record.sourceId,
+            kind: record.kind,
+            content: record.content,
+            memoryType: record.memoryType ?? 'discovery',
+            facts: record.facts ?? [],
+            concepts: record.concepts ?? [],
+            filesRead: record.filesRead ?? [],
+            filesModified: record.filesModified ?? [],
+            ...(record.title ? { title: record.title } : {}),
+            ...(record.sessionId ? { sessionId: record.sessionId } : {}),
+        }));
+        if (!records.length)
+            throw new Error('O arquivo não tem registros.');
+        return cloud.importMemories({ projectId: input.projectId, records });
+    }));
+    server.registerTool('vault_go_agent_cost_report', {
+        title: 'Estimar custo de transcripts',
+        description: 'Lê usage em JSONL locais e devolve tokens e um valor estimado. Sem usage, o valor fica indisponível.',
+        inputSchema: { root: z.string().trim().min(1).max(2_000) },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
+    }, async ({ root }) => run(async () => estimateAgentCost(root)));
     server.registerTool('vault_go_embedding_status', {
         title: 'Status da busca semântica',
         description: 'Mostra provedor, modelo e fila de vetores sem revelar a chave.',

package/dist/skill-download.d.ts

@@ -0,0 +1,6 @@
+import type { VaultMemoryApi } from './cloud.js';
+export declare function downloadSkillArchive(cloud: VaultMemoryApi, id: string, versionId?: string, fetcher?: typeof fetch): Promise<{
+    bytes: Uint8Array;
+    sha256: string;
+    versionId: string;
+}>;

package/dist/skill-download.js

@@ -0,0 +1,48 @@
+const MAX_ARCHIVE_BYTES = 40 * 1024 * 1024;
+function record(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Resposta de download inválida.');
+    return value;
+}
+export async function downloadSkillArchive(cloud, id, versionId, fetcher = globalThis.fetch) {
+    if (!cloud.skillDownloadGrant)
+        throw new Error('Este Vault não oferece download de skills.');
+    const grant = record(await cloud.skillDownloadGrant(id, versionId));
+    const link = record(grant.grant);
+    const version = record(grant.version);
+    if (typeof link.url !== 'string' || typeof version.id !== 'string' || typeof version.archiveSha256 !== 'string')
+        throw new Error('Resposta de download inválida.');
+    const url = new URL(link.url);
+    if (url.protocol !== 'https:')
+        throw new Error('Download inseguro da skill: HTTPS é obrigatório.');
+    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 declared = Number(response.headers.get('content-length'));
+    if (declared > MAX_ARCHIVE_BYTES) {
+        await response.body?.cancel();
+        throw new Error('Pacote acima de 40 MiB.');
+    }
+    if (!response.body)
+        throw new Error('Download vazio da skill.');
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        for (;;) {
+            const next = await reader.read();
+            if (next.done)
+                break;
+            total += next.value.byteLength;
+            if (total > MAX_ARCHIVE_BYTES) {
+                await reader.cancel();
+                throw new Error('Pacote acima de 40 MiB.');
+            }
+            chunks.push(next.value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    return { bytes: Buffer.concat(chunks, total), sha256: version.archiveSha256, versionId: version.id };
+}

package/dist/skill-library.d.ts

@@ -0,0 +1,8 @@
+import type { VaultMemoryApi } from './cloud.js';
+export type AccountSkillSummary = {
+    id: string;
+    name: string;
+    folderPath?: string | null;
+    [key: string]: unknown;
+};
+export declare function listAllSkillSummaries(cloud: VaultMemoryApi, query?: Record<string, unknown>): Promise<AccountSkillSummary[]>;

package/dist/skill-library.js

@@ -0,0 +1,32 @@
+export async function listAllSkillSummaries(cloud, query = {}) {
+    if (!cloud.skills)
+        throw new Error('Este Vault não oferece a biblioteca de skills.');
+    const output = [];
+    const cursors = new Set();
+    let cursor;
+    for (let page = 0; page < 20; page++) {
+        const response = await cloud.skills({ ...query, limit: 100, ...(cursor ? { cursor } : {}) });
+        if (!response || typeof response !== 'object' || Array.isArray(response))
+            throw new Error('Resposta inválida da biblioteca de skills.');
+        const body = response;
+        if (!Array.isArray(body.skills))
+            throw new Error('Resposta inválida da biblioteca de skills.');
+        for (const item of body.skills) {
+            if (!item || typeof item !== 'object' || Array.isArray(item))
+                throw new Error('Resposta inválida da biblioteca de skills.');
+            const skill = item;
+            if (typeof skill.id !== 'string' || typeof skill.name !== 'string' ||
+                (skill.folderPath !== null && skill.folderPath !== undefined && typeof skill.folderPath !== 'string')) {
+                throw new Error('Resposta inválida da biblioteca de skills.');
+            }
+            output.push(skill);
+        }
+        if (body.nextCursor == null)
+            return output;
+        if (typeof body.nextCursor !== 'string' || !body.nextCursor || cursors.has(body.nextCursor))
+            throw new Error('Paginação inválida da biblioteca de skills.');
+        cursor = body.nextCursor;
+        cursors.add(cursor);
+    }
+    throw new Error('Biblioteca de skills excedeu o limite de páginas.');
+}

package/dist/skill-local.d.ts

@@ -2,6 +2,8 @@ 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;
+/** Caminhos do manifesto de bundle (várias skills num tar): o Vault e o herdado. */
+export declare const SKILL_BUNDLE_MANIFEST_PATHS: readonly string[];
 export declare class SkillLocalError extends Error {
     code: string;
     constructor(code: string, message: string);
@@ -23,6 +25,11 @@ export interface InstalledSkill {
     skillId: string;
     versionId: string;
 }
+export declare function inspectSkillDestination(root: string, dirName: string, skillId: string): {
+    status: 'missing' | 'managed' | 'conflict';
+    path: string;
+    reason?: 'unmanaged' | 'foreign';
+};
 /** name/description do frontmatter; valida só o formato mínimo (o servidor valida o resto). */
 export declare function frontmatter(md: string): {
     name: string;

package/dist/skill-local.js

@@ -6,6 +6,7 @@ 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';
+import { LEGACY_SKILL_BUNDLE_MANIFEST_PATH } from './legacy-brand.js';
 export const SKILL_MARKER = '.vault-skill.json';
 export const SKILL_FILE_MAX_BYTES = 4 * 1024 * 1024;
 export const SKILL_MAX_FILES = 512;
@@ -13,6 +14,8 @@ 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}$/;
+/** Caminhos do manifesto de bundle (várias skills num tar): o Vault e o herdado. */
+export const SKILL_BUNDLE_MANIFEST_PATHS = ['dev.vault.skill-sharing/manifest.json', LEGACY_SKILL_BUNDLE_MANIFEST_PATH];
 export class SkillLocalError extends Error {
     code;
     constructor(code, message) {
@@ -21,6 +24,40 @@ export class SkillLocalError extends Error {
     }
 }
 const sha256 = (bytes) => createHash('sha256').update(bytes).digest('hex');
+export function inspectSkillDestination(root, dirName, skillId) {
+    if (!NAME.test(dirName) || dirName.includes('..'))
+        throw new SkillLocalError('skill_install_invalid', `Nome de pasta inválido: ${dirName}`);
+    const path = join(resolve(root), dirName);
+    let target;
+    try {
+        target = lstatSync(path);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return { status: 'missing', path };
+        throw error;
+    }
+    if (!target.isDirectory() || target.isSymbolicLink())
+        return { status: 'conflict', path, reason: 'unmanaged' };
+    const markerPath = join(path, SKILL_MARKER);
+    try {
+        const marker = lstatSync(markerPath);
+        if (!marker.isFile() || marker.isSymbolicLink())
+            return { status: 'conflict', path, reason: 'unmanaged' };
+        const data = JSON.parse(readFileSync(markerPath, 'utf8'));
+        if (!data || typeof data !== 'object' || Array.isArray(data))
+            return { status: 'conflict', path, reason: 'unmanaged' };
+        const skillIdInMarker = data.skillId;
+        return skillIdInMarker === skillId
+            ? { status: 'managed', path }
+            : { status: 'conflict', path, reason: typeof skillIdInMarker === 'string' ? 'foreign' : 'unmanaged' };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT' || error instanceof SyntaxError)
+            return { status: 'conflict', path, reason: 'unmanaged' };
+        throw error;
+    }
+}
 /** 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];
@@ -122,7 +159,7 @@ export function readTarGz(archive) {
 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'))
+    if (SKILL_BUNDLE_MANIFEST_PATHS.some(path => byPath.has(path)))
         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)
@@ -150,16 +187,16 @@ function verifiedFiles(entries) {
     });
 }
 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`);
-    }
+    const destination = inspectSkillDestination(root, input.dirName, input.skillId);
+    const target = destination.path;
+    if (destination.status === 'conflict')
+        throw new SkillLocalError('skill_install_conflict', destination.reason === 'foreign'
+            ? `${target} pertence a outra skill Vault; nada foi alterado`
+            : `${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}`);

package/dist/skill-tools.js

@@ -7,6 +7,8 @@ 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';
+import { downloadSkillArchive } from './skill-download.js';
+import { listAllSkillSummaries } from './skill-library.js';
 export { skillContextSection };
 export const SKILL_TEXT_MAX = 64 * 1024;
 const SOURCE = 'biblioteca privada de skills do usuário (Vault)';
@@ -39,16 +41,7 @@ export function folderByPath(folders, path) {
     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;
+    return await listAllSkillSummaries(cloud, query);
 }
 /** Aceita o id da skill, `pasta/sub/nome` ou só `nome` (quando for único). */
 export async function resolveSkill(cloud, ref) {
@@ -82,7 +75,6 @@ export async function currentProject(cloud, cwd) {
         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');
@@ -301,17 +293,7 @@ export function registerSkillTools(server, home, cloud, options = {}) {
     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 };
+        return downloadSkillArchive(cloud, id, versionId, fetcher);
     }
     async function installInto(id, name, roots, versionId) {
         const archive = await download(id, versionId);
@@ -335,7 +317,7 @@ export function registerSkillTools(server, home, cloud, options = {}) {
         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 roots = input.targets.map(t => targetRoot(t, userHome));
         const installed = installedSkills(roots);
         const updated = [], missing = [], added = [];
         for (const item of installed) {
@@ -357,11 +339,16 @@ export function registerSkillTools(server, home, cloud, options = {}) {
         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));
+            const have = new Set(installedSkills(roots).map(i => `${i.skillId}\0${i.root}`));
+            const linked = (await listAll(cloud, { projectId })).filter(s => s.scope === 'project');
             for (const skill of linked) {
-                const done = await installInto(skill.id, skill.name, input.targets.map(t => targetRoot(t, userHome)));
+                const missingRoots = roots.filter(root => !have.has(`${skill.id}\0${root}`));
+                if (!missingRoots.length)
+                    continue;
+                const done = await installInto(skill.id, skill.name, missingRoots);
                 added.push(...done.map(d => ({ skill: skill.name, path: d.path, versionId: d.versionId })));
+                for (const root of missingRoots)
+                    have.add(`${skill.id}\0${root}`);
             }
         }
         return { updated, installed: added, missing };

package/dist/skills-cli.d.ts

@@ -0,0 +1,31 @@
+import type { VaultMemoryApi } from './cloud.js';
+type Target = 'agents' | 'claude' | 'grok';
+type ListedSkill = {
+    id: string;
+    name: string;
+    folderPath: string | null;
+};
+type InstalledSkillResult = {
+    name: string;
+    target: Target;
+    path: string;
+    versionId: string;
+};
+type SkippedSkillResult = {
+    name: string;
+    target: Target;
+    path: string;
+    reason: 'unmanaged' | 'foreign';
+};
+export type SkillsCommandResult = {
+    skills: ListedSkill[];
+    installed: InstalledSkillResult[];
+    skipped: SkippedSkillResult[];
+};
+type Dependencies = {
+    cloud: VaultMemoryApi;
+    userHome?: string;
+    fetcher?: typeof fetch;
+};
+export declare function executeSkillsCommand(args: string[], dependencies: Dependencies): Promise<SkillsCommandResult>;
+export {};

package/dist/skills-cli.js

@@ -0,0 +1,90 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { inspectSkillDestination, installSkillArchive } from './skill-local.js';
+import { downloadSkillArchive } from './skill-download.js';
+import { listAllSkillSummaries } from './skill-library.js';
+async function listSkills(cloud) {
+    return (await listAllSkillSummaries(cloud)).map(skill => ({ id: skill.id, name: skill.name, folderPath: skill.folderPath ?? null }));
+}
+function parse(args) {
+    const action = args[0] ?? 'list';
+    if (action !== 'list' && action !== 'install')
+        throw new Error('Use vault-go skills list ou vault-go skills install --skill <nome>|--all.');
+    let all = false;
+    let target = 'agents';
+    const refs = [];
+    for (let index = 1; index < args.length; index++) {
+        const flag = args[index];
+        if (flag === '--all') {
+            all = true;
+            continue;
+        }
+        if (flag === '--skill' || flag === '--target') {
+            const value = args[++index];
+            if (!value || value.startsWith('--'))
+                throw new Error(`${flag} exige um valor.`);
+            if (flag === '--skill')
+                refs.push(value);
+            else if (value === 'agents' || value === 'claude' || value === 'grok')
+                target = value;
+            else
+                throw new Error('--target deve ser agents, claude ou grok.');
+            continue;
+        }
+        throw new Error(`Opção desconhecida: ${flag}`);
+    }
+    if (action === 'list' && (all || refs.length || target !== 'agents'))
+        throw new Error('vault-go skills list não aceita opções de instalação.');
+    if (action === 'install' && (all === (refs.length > 0)))
+        throw new Error('Use --all ou pelo menos um --skill.');
+    return { action, all, refs, target };
+}
+function select(skills, all, refs) {
+    const selected = all ? skills : refs.map(ref => {
+        const matches = skills.filter(skill => [skill.id, skill.name, `${skill.folderPath ? `${skill.folderPath}/` : ''}${skill.name}`].some(value => value.toLowerCase() === ref.toLowerCase()));
+        if (!matches.length)
+            throw new Error(`Skill não encontrada: ${ref}`);
+        if (matches.length > 1)
+            throw new Error(`Skill ambígua: ${ref}. Informe pasta/nome.`);
+        return matches[0];
+    });
+    const unique = [...new Map(selected.map(skill => [skill.id, skill])).values()];
+    const names = new Set();
+    for (const skill of unique) {
+        const name = skill.name.toLowerCase();
+        if (names.has(name))
+            throw new Error(`Mais de uma skill usa a pasta ${skill.name}; selecione uma por vez.`);
+        names.add(name);
+    }
+    return unique;
+}
+export async function executeSkillsCommand(args, dependencies) {
+    const command = parse(args);
+    const skills = await listSkills(dependencies.cloud);
+    if (command.action === 'list')
+        return { skills, installed: [], skipped: [] };
+    if (!dependencies.cloud.skillDownloadGrant)
+        throw new Error('Este Vault não oferece download de skills.');
+    const selected = select(skills, command.all, command.refs);
+    const root = command.target === 'agents'
+        ? join(dependencies.userHome ?? homedir(), '.agents', 'skills')
+        : join(dependencies.userHome ?? homedir(), `.${command.target}`, 'skills');
+    const fetcher = dependencies.fetcher ?? globalThis.fetch;
+    const installed = [];
+    const skipped = [];
+    const planned = selected.flatMap(skill => {
+        const destination = inspectSkillDestination(root, skill.name, skill.id);
+        if (destination.status !== 'conflict')
+            return [skill];
+        if (!command.all)
+            throw new Error(`${destination.path} já existe; skill ${skill.name} não foi instalada.`);
+        skipped.push({ name: skill.name, target: command.target, path: destination.path, reason: destination.reason });
+        return [];
+    });
+    for (const skill of planned) {
+        const downloaded = await downloadSkillArchive(dependencies.cloud, skill.id, undefined, fetcher);
+        const result = installSkillArchive({ bytes: downloaded.bytes, expectedSha256: downloaded.sha256, dirName: skill.name, root, skillId: skill.id, versionId: downloaded.versionId });
+        installed.push({ name: skill.name, target: command.target, path: result.path, versionId: downloaded.versionId });
+    }
+    return { skills: [], installed, skipped };
+}

package/dist/transcript-config.d.ts

@@ -1,4 +1,4 @@
-export type TranscriptAdapter = 'claude' | 'codex';
+export type TranscriptAdapter = 'claude' | 'codex' | 'cursor';
 export interface TranscriptTarget {
     id: string;
     adapter: TranscriptAdapter;

package/dist/transcript-config.js

@@ -44,10 +44,11 @@ function load(home) {
     const value = readPrivateJson(home, 'transcript-watchers.json', 100_000);
     if (value?.version !== 1 || value.owner !== captureOwner(home) || !Array.isArray(value.targets))
         return { version: 1, owner: captureOwner(home), targets: [] };
-    return { version: 1, owner: value.owner, targets: value.targets.filter(t => t && typeof t.id === 'string' && ['claude', 'codex'].includes(t.adapter) && typeof t.root === 'string' && isAbsolute(t.root) && typeof t.workspace === 'string' && isAbsolute(t.workspace) && typeof t.since === 'number').slice(0, 20) };
+    return { version: 1, owner: value.owner, targets: value.targets.filter(t => t && typeof t.id === 'string' && ['claude', 'codex', 'cursor'].includes(t.adapter) && typeof t.root === 'string' && isAbsolute(t.root) && typeof t.workspace === 'string' && isAbsolute(t.workspace) && typeof t.since === 'number').slice(0, 20) };
 }
 export function defaultTranscriptRoot(adapter, userHome = homedir()) {
-    return join(userHome, adapter === 'claude' ? '.claude/projects' : '.codex/sessions');
+    const folder = adapter === 'claude' ? '.claude/projects' : adapter === 'cursor' ? '.cursor/projects' : '.codex/sessions';
+    return join(userHome, folder);
 }
 export function transcriptStatus(home) {
     const config = load(home);
@@ -64,7 +65,7 @@ export function transcriptCaptureEnabled(home, adapter, cwd) {
     return load(home).targets.some(t => t.enabled && t.adapter === adapter && t.workspace === workspace);
 }
 export function configureTranscriptWatcher(home, input) {
-    if (!['claude', 'codex'].includes(input.adapter) || !isAbsolute(input.workspace))
+    if (!['claude', 'codex', 'cursor'].includes(input.adapter) || !isAbsolute(input.workspace))
         throw new Error('Adaptador ou workspace inválido. Use um caminho absoluto.');
     if (input.enabled && input.consent !== true)
         throw new Error('Ativar exige consent=true para capturar transcripts deste workspace.');

package/dist/transcript-parser.js

@@ -63,7 +63,7 @@ export function parseTranscript(adapter, value, previous, offset) {
         if (cwd)
             state.cwd = cwd;
     }
-    if (adapter === 'claude') {
+    if (adapter === 'claude' || adapter === 'cursor') {
         scope(text(row.sessionId), text(row.cwd));
         if (row.private === true || row.isPrivate === true || row.is_private === true) {
             state.private = true;

package/dist/transcript-tools.js

@@ -8,7 +8,7 @@ export function registerTranscriptTools(server, home, cloud) {
     server.registerTool('vault_go_transcripts_status', { description: 'Watchers opt-in de Claude/Codex neste dispositivo e conta. Requer automaticCapture para enviar eventos; geração usa o motor já escolhido.', inputSchema: {}, annotations: { readOnlyHint: true, openWorldHint: false } }, () => run(async () => transcriptStatus(home)));
     server.registerTool('vault_go_transcripts_configure', {
         description: 'Ativa/desativa captura persistente de um workspace com consentimento explícito. Por padrão ignora histórico existente; fromStart importa histórico. Hooks nativos preservam contexto e cedem escrita ao watcher enquanto ativo. O worker local precisa estar em execução.',
-        inputSchema: { adapter: z.enum(['claude', 'codex']), workspace: path, root: path.optional(), enabled: z.boolean(), consent: z.boolean().default(false), fromStart: z.boolean().default(false) },
+        inputSchema: { adapter: z.enum(['claude', 'codex', 'cursor']), workspace: path, root: path.optional(), enabled: z.boolean(), consent: z.boolean().default(false), fromStart: z.boolean().default(false) },
         annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false },
     }, input => run(async () => { const { root, ...rest } = input; return configureTranscriptWatcher(home, { ...rest, ...(root === undefined ? {} : { root }) }); }));
     server.registerTool('vault_go_transcripts_poll', { description: 'Processa um lote limitado dos watchers já consentidos. Retomada e idempotência persistem entre reinícios; não ativa captura nem muda o motor.', inputSchema: {}, annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true } }, () => run(() => pollTranscripts(home, cloud)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vault-go",
-  "version": "0.30.0",
+  "version": "0.31.0",
   "description": "MCP server and installer for Vault Memory: search, capture, and use account memory across AI clients.",
   "type": "module",
   "bin": {
@@ -30,8 +30,16 @@
     "dist/skill-context.d.ts",
     "dist/skill-local.js",
     "dist/skill-local.d.ts",
+    "dist/legacy-brand.js",
+    "dist/legacy-brand.d.ts",
     "dist/skill-tools.js",
     "dist/skill-tools.d.ts",
+    "dist/skill-download.js",
+    "dist/skill-download.d.ts",
+    "dist/skill-library.js",
+    "dist/skill-library.d.ts",
+    "dist/skills-cli.js",
+    "dist/skills-cli.d.ts",
     "dist/activity.js",
     "dist/activity.d.ts",
     "dist/auth.js",
@@ -139,6 +147,10 @@
     "dist/awareness-tools.d.ts",
     "dist/skill-install.js",
     "dist/skill-install.d.ts",
+    "dist/memory-archive.js",
+    "dist/memory-archive.d.ts",
+    "dist/agent-cost.js",
+    "dist/agent-cost.d.ts",
     "grammars/"
   ],
   "scripts": {