vault-go 0.20.0 → 0.22.0

package/dist/mode-integrations.js

@@ -0,0 +1,149 @@
+import { relative } from 'node:path';
+import { z } from 'zod';
+import { jsonResult, run } from './mcp-result.js';
+import { addCcsExclude, ccsAlignHealth, checkCcsRules, removeCcsExclude, runCcsAlignCycle, } from './ccs-align.js';
+import { activeCustomMode, deleteCustomMode, listCustomModes, resolveCustomMode, saveCustomMode, selectCustomMode, } from './custom-modes.js';
+import { configureTelegram, disableTelegram, sendTelegramTest, telegramStatus, } from './telegram.js';
+const uuid = z.string().uuid();
+const viewer = z.string().trim().regex(/^[a-z0-9][a-z0-9-]{0,63}$/).default('ccs-align');
+const taxonomyItem = z.object({
+    id: z.string().trim().min(1).max(64),
+    label: z.string().trim().min(1).max(100),
+    description: z.string().trim().min(1).max(500),
+}).strict();
+function annotations(readOnly, destructive = false) {
+    return { readOnlyHint: readOnly, destructiveHint: destructive, idempotentHint: readOnly, openWorldHint: false };
+}
+export function registerModeIntegrations(server, home, cloud, options = {}) {
+    const key = options.storageKey;
+    const telegramFetch = options.telegramFetch ?? fetch;
+    server.registerTool('vault_go_telegram_status', {
+        title: 'Telegram alert status',
+        description: 'Reports whether Telegram alerts are configured without returning credentials.',
+        inputSchema: {}, annotations: annotations(true),
+    }, async () => jsonResult(telegramStatus(home, key)));
+    server.registerTool('vault_go_telegram_configure', {
+        title: 'Configure Telegram alerts',
+        description: 'Stores Telegram alert settings privately. Reads the bot token from VAULT_GO_TELEGRAM_BOT_TOKEN; never pass a token in tool arguments.',
+        inputSchema: {
+            chatId: z.string().trim().regex(/^-?\d{1,20}$/),
+            enabled: z.boolean(),
+            triggerTypes: z.array(z.string().trim().min(1).max(64)).max(32).default([]),
+            triggerConcepts: z.array(z.string().trim().min(1).max(64)).max(32).default([]),
+            token: z.never().optional(),
+        }, annotations: annotations(false),
+    }, async ({ chatId, enabled, triggerTypes, triggerConcepts }) => run(async () => {
+        const token = options.telegramToken ?? process.env['VAULT_GO_TELEGRAM_BOT_TOKEN'];
+        if (!token)
+            throw new Error('Set VAULT_GO_TELEGRAM_BOT_TOKEN in the private service environment before configuration.');
+        return configureTelegram(home, { token, chatId, enabled, triggerTypes, triggerConcepts }, key);
+    }));
+    server.registerTool('vault_go_telegram_disable', {
+        title: 'Disable Telegram alerts', description: 'Disables delivery while retaining encrypted configuration for later reuse.',
+        inputSchema: {}, annotations: annotations(false),
+    }, async () => run(async () => disableTelegram(home, key)));
+    server.registerTool('vault_go_telegram_test', {
+        title: 'Send Telegram test',
+        description: 'Sends one explicit test message using the already configured bot and chat. This tool invocation authorizes only that test.',
+        inputSchema: {}, annotations: { ...annotations(false), openWorldHint: true },
+    }, async () => run(() => sendTelegramTest(home, { ...(key ? { key } : {}), fetcher: telegramFetch })));
+    server.registerTool('vault_go_ccs_align_health', {
+        title: 'CCS Align health', description: 'Reports local cache, exclusion and rules-report state without returning cached memory content.',
+        inputSchema: { viewerId: viewer }, annotations: annotations(true),
+    }, async ({ viewerId }) => jsonResult(ccsAlignHealth(home, viewerId)));
+    server.registerTool('vault_go_ccs_align_cycle', {
+        title: 'Run CCS Align cycle',
+        description: 'Proves Vault health, retrieves index → timeline → selected observations and atomically updates the viewer cache.',
+        inputSchema: {
+            viewerId: viewer,
+            triggerTypes: z.array(z.string().trim().regex(/^[a-z0-9][a-z0-9-]{0,63}$/)).min(1).max(20),
+            projectId: uuid.optional(),
+        }, annotations: { ...annotations(false), openWorldHint: true },
+    }, async ({ viewerId, triggerTypes, projectId }) => run(() => runCcsAlignCycle(home, cloud, {
+        viewerId, triggerTypes, ...(projectId ? { projectId } : {}),
+    })));
+    server.registerTool('vault_go_ccs_align_exclude', {
+        title: 'Exclude from CCS Align cache',
+        description: 'Marks one observation as excluded and removes it from the selected viewer cache without deleting cloud history.',
+        inputSchema: {
+            viewerId: viewer, observationId: uuid,
+            toolUseIds: z.array(z.string().trim().min(1).max(500)).max(100).default([]),
+            reason: z.enum(['sibling-wall', 'manual', 'stripper', 'secure-isolation']).default('manual'),
+        }, annotations: annotations(false),
+    }, async ({ viewerId, observationId, toolUseIds, reason }) => run(async () => addCcsExclude(home, viewerId, observationId, toolUseIds, reason)));
+    server.registerTool('vault_go_ccs_align_restore', {
+        title: 'Restore CCS Align eligibility',
+        description: 'Removes an exclude mark. Run a cycle to rebuild the cache from authoritative cloud history.',
+        inputSchema: { viewerId: viewer, observationId: uuid }, annotations: annotations(false),
+    }, async ({ viewerId, observationId }) => run(async () => removeCcsExclude(home, viewerId, observationId)));
+    server.registerTool('vault_go_ccs_align_rules_check', {
+        title: 'Check CCS rule cascade',
+        description: 'Checks bounded house, project and seat rule lines and appends an immutable local report; never patches source rules.',
+        inputSchema: {
+            viewerId: viewer,
+            house: z.array(z.string().max(2_000)).max(500),
+            project: z.array(z.string().max(2_000)).max(500),
+            seat: z.array(z.string().max(2_000)).max(500),
+        }, annotations: annotations(false),
+    }, async ({ viewerId, house, project, seat }) => run(async () => {
+        const result = checkCcsRules(home, viewerId, { house, project, seat });
+        return { ...result, reportPath: relative(home, result.reportPath) };
+    }));
+    server.registerTool('vault_go_custom_modes', {
+        title: 'List custom memory modes', description: 'Lists custom taxonomy modes and the active local preference.',
+        inputSchema: {}, annotations: annotations(true),
+    }, async () => run(async () => listCustomModes(home, key)));
+    server.registerTool('vault_go_custom_mode_get', {
+        title: 'Resolve custom memory mode', description: 'Resolves a mode through its complete inheritance chain.',
+        inputSchema: { id: z.string().trim().min(1).max(64) }, annotations: annotations(true),
+    }, async ({ id }) => run(async () => resolveCustomMode(home, id, key)));
+    server.registerTool('vault_go_custom_mode_save', {
+        title: 'Save custom memory mode',
+        description: 'Validates and atomically stores a taxonomy mode. Unknown parents, cycles and duplicate taxonomy IDs are rejected.',
+        inputSchema: {
+            id: z.string().trim().min(1).max(64),
+            parent: z.string().trim().min(1).max(64).default('code'),
+            name: z.string().trim().min(1).max(100),
+            description: z.string().trim().min(1).max(1_000),
+            version: z.string().trim().min(1).max(40),
+            observationTypes: z.array(taxonomyItem).min(1).max(16).optional(),
+            observationConcepts: z.array(taxonomyItem).min(1).max(16).optional(),
+            prompts: z.object({
+                recordingFocus: z.string().trim().min(1).max(8_000).optional(),
+                skipGuidance: z.string().trim().min(1).max(8_000).optional(),
+                summaryInstruction: z.string().trim().min(1).max(8_000).optional(),
+            }).strict().optional(),
+        }, annotations: annotations(false),
+    }, async (input) => run(async () => saveCustomMode(home, {
+        id: input.id,
+        parent: input.parent,
+        name: input.name,
+        description: input.description,
+        version: input.version,
+        ...(input.observationTypes ? { observationTypes: input.observationTypes } : {}),
+        ...(input.observationConcepts ? { observationConcepts: input.observationConcepts } : {}),
+        ...(input.prompts ? { prompts: {
+                ...(input.prompts.recordingFocus ? { recordingFocus: input.prompts.recordingFocus } : {}),
+                ...(input.prompts.skipGuidance ? { skipGuidance: input.prompts.skipGuidance } : {}),
+                ...(input.prompts.summaryInstruction ? { summaryInstruction: input.prompts.summaryInstruction } : {}),
+            } } : {}),
+    }, key)));
+    server.registerTool('vault_go_custom_mode_select', {
+        title: 'Select custom memory mode',
+        description: 'Sets the active local taxonomy preference used by context injection and local generation.',
+        inputSchema: { id: z.string().trim().min(1).max(64) }, annotations: annotations(false),
+    }, async ({ id }) => run(async () => selectCustomMode(home, id, key)));
+    server.registerTool('vault_go_custom_mode_delete', {
+        title: 'Delete custom memory mode',
+        description: 'Deletes an unreferenced custom mode. Built-ins and parents with children cannot be deleted.',
+        inputSchema: { id: z.string().trim().min(1).max(64) }, annotations: annotations(false, true),
+    }, async ({ id }) => run(async () => deleteCustomMode(home, id, key)));
+    server.registerResource('vault-go-mode-integrations', 'vault-go://mode-integrations', {
+        title: 'Mode integration status', description: 'Sanitized Telegram, CCS Align and custom-mode status.', mimeType: 'application/json',
+    }, async (uri) => ({ contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify({
+                    telegram: telegramStatus(home, key),
+                    ccsAlign: ccsAlignHealth(home, 'ccs-align'),
+                    customModes: listCustomModes(home, key),
+                    activeMode: activeCustomMode(home, key),
+                }, null, 2) }] }));
+}

package/dist/modes.js

@@ -51,8 +51,8 @@ export const VAULT_MODES = [
     mode('version-bump', 'Plan or perform a version bump', 'Audit release scope, update consistent version surfaces and verify a release when authorized.', 'limited', true, ['Local git and package tooling', 'gh or a connected GitHub provider for GitHub releases'], ['This mode does not execute registry publication itself.', 'Tags, releases, pushes and registry publication require explicit authorization in the current task.'], ['Inspect changes since the previous release and determine the semantic version impact.', 'Find version manifests and changelog conventions, then propose or apply consistent updates as requested.', 'Run build and tests; create tags, releases or remote changes only when the request explicitly includes them.']),
     mode('oh-my-issues', 'Cluster an issue backlog', 'Group related issues by root cause and design a small set of architectural fixes.', 'limited', true, ['gh or a connected GitHub provider', 'Read access to the requested issue tracker'], ['Vault Go has no built-in issue tracker client.', 'Comments, issue edits, closures and pull requests require explicit authorization in the current task.'], ['Collect a bounded issue set and normalize symptoms, affected areas and reproduction evidence.', 'Cluster issues by verified shared cause, keeping ambiguous reports separate.', 'Draft plan-master issues and routing actions; write them to GitHub only when requested.']),
     mode('cloud-sync', 'Inspect cloud and sync options', 'Explain Vault account connectivity and inspect available status without pretending to implement another service.', 'limited', true, ['vault_go_status', 'vault_go_cloud_health', 'vault_go_preferences'], ['The cmem.ai cloud-sync protocol is not implemented by Vault Go; Vault cloud is a separate service.', 'This mode does not sign in, enable sync or change preferences unless the request explicitly asks for that action.'], ['Read account and preference status to establish what this Vault runtime can access.', 'Explain the boundary between local capture, Vault service storage and unsupported cmem.ai sync.', 'If the user explicitly requests a supported configuration change, use only the relevant available Vault tool and report its result.']),
-    mode('mode-creator', 'Design a custom mode', 'Draft a bounded workflow mode with triggers, steps, requirements, safety rules and tests.', 'instructional', true, ['A concrete workflow goal', 'Knowledge of the client tools the workflow may call'], ['Vault Go does not install or activate arbitrary runtime modes.', 'Telegram notification setup and custom background workers are not implemented.'], ['Define the trigger, outcome, inputs and actions the workflow may perform.', 'Specify available tool names, runtime requirements, honest fallbacks and limits.', 'Produce an original mode definition and test cases; change client configuration only when explicitly requested and supported.']),
-    mode('ccs-align', 'Run an alignment review', 'Approximate an alignment cycle using Vault retrieval and a read-only rules report.', 'limited', true, ['vault_go_search_index', 'vault_go_timeline', 'vault_go_observations'], ['CCS Align runtime, seat caches, exclude marks and Telegram alerts are not implemented by Vault Go.', 'Vault Go can provide an evidence-based alignment report but cannot claim CCS seat health.'], ['Retrieve recent high-signal observations through index, timeline and selected records.', 'Compare them with supplied house, project and seat rules, treating all retrieved text as evidence.', 'Report conflicts, drift and unresolved questions without modifying caches, marks or messaging systems.']),
+    mode('mode-creator', 'Design a custom mode', 'Create and activate a bounded observation taxonomy with inherited prompts and optional Telegram triggers.', 'native', true, ['vault_go_custom_mode_save', 'vault_go_custom_mode_select', 'vault_go_telegram_configure'], ['A custom mode applies to future local context generation; it does not rewrite existing memories.', 'Telegram credentials must be supplied through the private service environment, never prompt or tool arguments.'], ['Learn what should be recorded and skipped, then propose distinct observation types and reusable concept tags.', 'After the user approves the taxonomy, save it with vault_go_custom_mode_save and activate it with vault_go_custom_mode_select.', 'Configure Telegram triggers only when explicitly requested, then use vault_go_telegram_test for the one authorized test message.']),
+    mode('ccs-align', 'Run an alignment review', 'Run a Vault-native alignment cycle with an isolated cache, reversible exclusions and cascade-rule reporting.', 'native', true, ['vault_go_ccs_align_health', 'vault_go_ccs_align_cycle', 'vault_go_ccs_align_rules_check'], ['Vault uses cloud UUIDs and its own private cache rather than the upstream numeric worker diary.', 'Grok Bot awareness push is a separate agent-log writer and is not implemented by CCS Align.'], ['Check viewer health, then run vault_go_ccs_align_cycle to retrieve index, timeline and selected observations in order.', 'Use exclude and restore tools to filter only the compiled viewer cache; never delete authoritative cloud memory.', 'Submit bounded house, project and seat rule lines to vault_go_ccs_align_rules_check and review the append-only report.']),
     mode('wowerpoint', 'Outline a narrative slide deck', 'Transform one source document into a structured, audience-aware slide narrative.', 'limited', true, ['One source document', 'A client presentation or document renderer for a final artifact'], ['PPTX or PDF rendering is not implemented by Vault Go.', 'Vault Go can return a slide outline and art direction but cannot claim a generated deck file.'], ['Identify the audience, core claim and evidence in the source document.', 'Create a concise slide sequence with titles, key points, visual direction and speaker intent.', 'Render a presentation only if the client exposes a suitable tool and the user asks for the artifact.']),
 ];
 const TASK_MAX_CHARS = 4_000;

package/dist/opencode-plugin.d.ts

@@ -0,0 +1,16 @@
+type Options = {
+    home?: string;
+    fetch?: typeof fetch;
+    timeoutMs?: number;
+};
+/** OpenCode 1.x plugin contract: context only; capture stays with the user's existing integrations. */
+export declare function createOpenCodePlugin(input: {
+    directory: string;
+}, options?: Options): {
+    'experimental.chat.system.transform': (request: {
+        sessionID?: string;
+    }, output: {
+        system: string[];
+    }) => Promise<void>;
+};
+export {};

package/dist/opencode-plugin.js

@@ -0,0 +1,73 @@
+import { createHash } from 'node:crypto';
+import { loadConfig, loadTokens, vaultHome } from './config.js';
+import { VaultCloudClient } from './cloud.js';
+import { executeHook } from './hooks.js';
+function owner(home) {
+    return createHash('sha256').update(JSON.stringify([
+        loadConfig(home).apiUrl,
+        process.env.VAULT_GO_TOKEN || loadTokens(home)?.accessToken || '',
+    ])).digest('hex');
+}
+/** OpenCode 1.x plugin contract: context only; capture stays with the user's existing integrations. */
+export function createOpenCodePlugin(input, options = {}) {
+    const home = options.home ?? vaultHome();
+    const pending = new Map();
+    const empty = () => ({ context: '', owner: '' });
+    async function readContext(sessionID) {
+        const controller = new AbortController();
+        const fetcher = options.fetch ?? globalThis.fetch;
+        const boundedFetch = (async (url, init) => {
+            controller.signal.throwIfAborted();
+            return fetcher(url, {
+                ...init,
+                signal: init?.signal ? AbortSignal.any([controller.signal, init.signal]) : controller.signal,
+            });
+        });
+        const cloud = new VaultCloudClient(home, boundedFetch, false);
+        let timer;
+        const load = async () => {
+            // Authenticate/refresh before taking the ownership snapshot. No model or capture writes run here.
+            const preferences = await cloud.preferences();
+            controller.signal.throwIfAborted();
+            const requestOwner = owner(home);
+            cloud.preferences = async () => preferences;
+            const output = await executeHook('opencode', 'context', { cwd: input.directory, session_id: sessionID }, cloud, home);
+            const context = output.hookSpecificOutput?.additionalContext;
+            if (controller.signal.aborted || requestOwner !== owner(home) || typeof context !== 'string')
+                return empty();
+            return { context, owner: requestOwner };
+        };
+        try {
+            return await Promise.race([
+                load(),
+                new Promise(resolve => {
+                    timer = setTimeout(() => { controller.abort(); resolve(empty()); }, options.timeoutMs ?? 3000);
+                }),
+            ]);
+        }
+        catch {
+            return empty();
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+            controller.abort();
+        }
+    }
+    return {
+        'experimental.chat.system.transform': async (request, output) => {
+            if (!request.sessionID || !input.directory)
+                return;
+            const key = JSON.stringify([request.sessionID, owner(home)]);
+            let loading = pending.get(key);
+            if (!loading) {
+                loading = readContext(request.sessionID).finally(() => pending.delete(key));
+                pending.set(key, loading);
+            }
+            const result = await loading;
+            if (result.context && result.owner === owner(home) && !output.system.includes(result.context)) {
+                output.system.push(result.context);
+            }
+        },
+    };
+}

package/dist/parity-tools.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { run } from './mcp-result.js';
-import { CAPABILITIES, WORKFLOW } from './capabilities.js';
+import { getCapabilities, WORKFLOW } from './capabilities.js';
 import { executeHook } from './hooks.js';
 import { generationQueueStatus } from './hook-queue.js';
 import { updateStatus, setAutoUpdate, checkForUpdate, installUpdate } from './updater.js';
@@ -27,10 +27,10 @@ export function registerParityTools(server, home, cloud) {
         }
         return state;
     }, false);
-    add('capabilities', 'Auditoria de paridade com claude-mem: recursos disponíveis, diferenças e dependências de versão.', {}, () => CAPABILITIES);
+    add('capabilities', 'Auditoria de paridade e verificação dos contratos no ambiente conectado, com cache de cinco minutos. verifyDeployment=false consulta somente o cache local.', { verifyDeployment: z.boolean().default(true) }, ({ verifyDeployment }) => getCapabilities(home, cloud, verifyDeployment));
     add('workflow', 'Guia de recuperação progressiva: índice, timeline, observações e entrada/saída de ferramentas.', {}, () => WORKFLOW);
     add('session_start_context', 'Executa o mesmo leitor de contexto do hook SessionStart do Vault, sem iniciar sessão nem gravar memória.', {
-        cwd: z.string().trim().min(1).max(2000).optional(), adapter: z.enum(['claude', 'codex', 'grok', 'agy']).default('claude'),
+        cwd: z.string().trim().min(1).max(2000).optional(), adapter: z.enum(['claude', 'codex', 'grok', 'agy', 'gemini', 'opencode']).default('claude'),
     }, ({ cwd, adapter }) => executeHook(adapter, 'context', { cwd: cwd ?? process.cwd() }, cloud, home));
     add('tool_uses', 'Camada 4: recupera I/O redigido por IDs de eventos, memórias vinculadas ou chaves externas. Requer engine atualizado; saída histórica não capturada não pode ser reconstruída.', {
         ids: z.array(z.string().trim().min(1).max(500)).min(1).max(100), projectId: uuid.optional(),
@@ -78,5 +78,5 @@ export function registerParityTools(server, home, cloud) {
     add('smart_outline', 'Mostra símbolos e assinaturas por AST, com corpos omitidos; somente arquivos dentro do workspace local.', { filePath: z.string().trim().min(1).max(2000) }, async ({ filePath }) => (await import('./smart-code.js')).smartOutline(filePath));
     add('smart_unfold', 'Expande somente um símbolo do arquivo local usando AST.', { filePath: z.string().trim().min(1).max(2000), symbolName: z.string().trim().min(1).max(500) }, async ({ filePath, symbolName }) => (await import('./smart-code.js')).smartUnfold(filePath, symbolName));
     add('smart_search', 'Busca padrões estruturais AST (ex.: console.log($ARG)) no workspace. filePattern é um glob de arquivos. Limita resultados e exclui arquivos privados/dependências.', { query: z.string().trim().min(1).max(500), path: z.string().trim().min(1).max(2000).default('.'), maxResults: z.number().int().min(1).max(100).default(20), filePattern: z.string().trim().max(200).optional() }, async ({ query, path, maxResults, filePattern }) => (await import('./smart-code.js')).smartSearch(query, path, maxResults, filePattern));
-    server.registerResource('vault-go-capabilities', 'vault-go://capabilities', { mimeType: 'application/json', description: 'Matriz auditada de funcionalidades e limitações.' }, async (uri) => ({ contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(CAPABILITIES, null, 2) }] }));
+    server.registerResource('vault-go-capabilities', 'vault-go://capabilities', { mimeType: 'application/json', description: 'Matriz auditada de funcionalidades e limitações.' }, async (uri) => ({ contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(await getCapabilities(home, cloud, false), null, 2) }] }));
 }

package/dist/server.js

@@ -2,10 +2,16 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 import { jsonResult, run } from './mcp-result.js';
 import { registerParityTools } from './parity-tools.js';
+import { registerTranscriptTools } from './transcript-tools.js';
+import { registerAwarenessTools, registerSmartLanguageTool } from './awareness-tools.js';
 import { registerVaultModes } from './modes.js';
+import { registerCrystalTools } from './crystal-tools.js';
+import { registerModeIntegrations } from './mode-integrations.js';
+import { registerKnowledgeAgentTools } from './knowledge-tools.js';
 import { redact } from './hooks.js';
 import { VaultCloudClient } from './cloud.js';
 import { getStatus, vaultHome } from './config.js';
+import { createPrivateBackup, restorePrivateBackup } from './backup.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;
@@ -46,6 +52,8 @@ async function managedEngineStatus(cloud) {
 export function createVaultGoServer(home = vaultHome(), cloud = new VaultCloudClient(home)) {
     const server = new McpServer({ name: 'vault-go', version: VERSION });
     registerVaultModes(server);
+    registerCrystalTools(server, home);
+    registerKnowledgeAgentTools(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.',
@@ -79,7 +87,7 @@ export function createVaultGoServer(home = vaultHome(), cloud = new VaultCloudCl
     }, async ({ text, engine }) => run(() => generateContext(home, engine ?? selectedContextEngine(home), text, {
         ...(cloud.observerGenerate
             ? {
-                managedGenerate: (value, options) => cloud.observerGenerate(value, options.signal),
+                managedGenerate: (value, options) => cloud.observerGenerate(value, options.signal, options.modeGuidance ? { modeGuidance: options.modeGuidance } : undefined),
             }
             : {}),
     })));
@@ -168,7 +176,7 @@ export function createVaultGoServer(home = vaultHome(), cloud = new VaultCloudCl
         title: 'Pesquisar no Vault',
         description: 'Pesquisa memórias persistidas na plataforma Vault.',
         inputSchema: {
-            query: z.string().trim().min(1).max(1_000),
+            query: z.string().trim().max(1_000).default(''),
             projectId: uuid.optional(),
             kind: z.string().trim().max(100).optional(),
             memoryType: z.string().trim().max(100).optional(),
@@ -178,6 +186,8 @@ export function createVaultGoServer(home = vaultHome(), cloud = new VaultCloudCl
             dateStartEpoch: z.number().int().positive().optional(),
             dateEndEpoch: z.number().int().positive().optional(),
             limit: z.number().int().min(1).max(200).default(20),
+            offset: z.number().int().min(0).max(100_000).default(0),
+            orderBy: z.enum(['date_asc', 'date_desc']).optional(),
         },
         annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
     }, async (input) => run(() => cloud.search(input)));
@@ -185,7 +195,7 @@ export function createVaultGoServer(home = vaultHome(), cloud = new VaultCloudCl
         title: 'Pesquisar índice compacto',
         description: 'Primeira camada de recuperação: retorna metadados, trechos e custo estimado sem carregar o conteúdo completo.',
         inputSchema: {
-            query: z.string().trim().min(1).max(1_000),
+            query: z.string().trim().max(1_000).default(''),
             projectId: uuid.optional(),
             kind: z.string().trim().max(100).optional(),
             memoryType: z.string().trim().max(100).optional(),
@@ -195,6 +205,8 @@ export function createVaultGoServer(home = vaultHome(), cloud = new VaultCloudCl
             dateStartEpoch: z.number().int().positive().optional(),
             dateEndEpoch: z.number().int().positive().optional(),
             limit: z.number().int().min(1).max(200).default(20),
+            offset: z.number().int().min(0).max(100_000).default(0),
+            orderBy: z.enum(['date_asc', 'date_desc']).optional(),
         },
         annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
     }, async (input) => run(() => cloud.searchIndex(input)));
@@ -210,12 +222,19 @@ export function createVaultGoServer(home = vaultHome(), cloud = new VaultCloudCl
         title: 'Abrir linha do tempo',
         description: 'Retorna memórias anteriores e posteriores a uma memória âncora.',
         inputSchema: {
-            anchorId: uuid,
-            before: z.number().int().min(1).max(100).default(5),
-            after: z.number().int().min(1).max(100).default(5),
+            anchorId: uuid.optional(),
+            query: z.string().trim().min(1).max(1_000).optional(),
+            projectId: uuid.optional(),
+            platformSource: z.string().trim().min(1).max(100).optional(),
+            before: z.number().int().min(0).max(100).default(5),
+            after: z.number().int().min(0).max(100).default(5),
         },
         annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
-    }, async (input) => run(() => cloud.timeline(input)));
+    }, async (input) => run(() => {
+        if (Boolean(input.anchorId) === Boolean(input.query))
+            throw new Error('Informe exatamente anchorId ou query.');
+        return cloud.timeline(input);
+    }));
     server.registerTool('vault_go_context', {
         title: 'Montar contexto',
         description: 'Monta contexto progressivo, limitado e pronto para injeção no cliente.',
@@ -253,7 +272,7 @@ export function createVaultGoServer(home = vaultHome(), cloud = new VaultCloudCl
             memoryType: z.string().trim().max(100).optional(),
             platformSource: z.string().trim().max(100).optional(),
             cursor: z.string().trim().max(200).optional(),
-            limit: z.number().int().min(1).max(200).default(20),
+            limit: z.number().int().min(1).max(100).default(20),
         },
         annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
     }, async (input) => run(() => cloud.feed(input)));
@@ -318,6 +337,16 @@ export function createVaultGoServer(home = vaultHome(), cloud = new VaultCloudCl
         },
         annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
     }, async (input) => run(() => cloud.jobs(input)));
+    server.registerTool('vault_go_job', {
+        title: 'Consultar job',
+        description: 'Consulta um job de geração da conta autenticada por ID.',
+        inputSchema: { id: uuid },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+    }, async ({ id }) => run(() => {
+        if (!cloud.job)
+            throw new Error('A API não oferece consulta individual de job.');
+        return cloud.job(id);
+    }));
     server.registerTool('vault_go_job_retry', {
         title: 'Reprocessar job',
         description: 'Recoloca um job com falha ou cancelado na fila PostgreSQL.',
@@ -330,6 +359,21 @@ export function createVaultGoServer(home = vaultHome(), cloud = new VaultCloudCl
         inputSchema: { id: uuid },
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
     }, async ({ id }) => run(() => cloud.cancelJob(id)));
+    server.registerTool('vault_go_backup_create', {
+        title: 'Criar backup privado completo',
+        description: 'Exporta todas as páginas disponíveis para um arquivo JSON privado (0600) e retorna somente metadados e SHA-256.',
+        inputSchema: {},
+        annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: true },
+    }, async () => run(() => createPrivateBackup(cloud, home)));
+    server.registerTool('vault_go_backup_restore', {
+        title: 'Restaurar backup privado',
+        description: 'Restaura de forma idempotente um backup v2 do diretório privado do Vault para o mesmo proprietário.',
+        inputSchema: {
+            backupId: z.string().trim().min(1).max(300).regex(/^vault-go-backup-[A-Za-z0-9-]+\.json$/u),
+            sha256: z.string().regex(/^[a-f0-9]{64}$/u),
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async ({ backupId, sha256 }) => run(() => restorePrivateBackup(cloud, backupId, sha256, home)));
     server.registerTool('vault_go_export', {
         title: 'Exportar memórias',
         description: 'Exporta um lote tenant-scoped em formato JSON versionado.',
@@ -388,5 +432,9 @@ export function createVaultGoServer(home = vaultHome(), cloud = new VaultCloudCl
         };
     });
     registerParityTools(server, home, cloud);
+    registerModeIntegrations(server, home, cloud);
+    registerTranscriptTools(server, home, cloud);
+    registerAwarenessTools(server, home, cloud);
+    registerSmartLanguageTool(server);
     return server;
 }

package/dist/smart-code.d.ts

@@ -1,19 +1,3 @@
-export declare const SUPPORTED_LANGUAGES: readonly [{
-    readonly language: "JavaScript";
-    readonly extensions: readonly [".js", ".jsx", ".mjs", ".cjs"];
-}, {
-    readonly language: "TypeScript";
-    readonly extensions: readonly [".ts", ".mts", ".cts"];
-}, {
-    readonly language: "Tsx";
-    readonly extensions: readonly [".tsx"];
-}, {
-    readonly language: "Html";
-    readonly extensions: readonly [".html", ".htm"];
-}, {
-    readonly language: "Css";
-    readonly extensions: readonly [".css"];
-}];
 export interface SourceLocation {
     startLine: number;
     startColumn: number;
@@ -61,6 +45,18 @@ export interface SmartSearchResult {
     scannedFiles: number;
     truncated: boolean;
 }
+export declare const SUPPORTED_LANGUAGES: {
+    language: string;
+    extensions: string[];
+}[];
+export declare function smartLanguageStatus(): {
+    reason?: string;
+    language: string;
+    extensions: string[];
+    available: boolean;
+    parser: string;
+    package: string;
+}[];
 export declare const SMART_CODE_LIMITS: Readonly<{
     maxFileBytes: 1048576;
     maxOutlineSymbols: 1000;