vault-go 0.26.0 → 0.28.0

package/README.md

@@ -148,7 +148,9 @@ Projects and sessions: `vault_go_projects`, `vault_go_project_create`, `vault_go
 
 Capture and recall: `vault_go_event`, `vault_go_remember`, `vault_go_forget`, `vault_go_search`, `vault_go_search_index`, `vault_go_retrieve`, `vault_go_observations`, `vault_go_timeline`, `vault_go_context`, `vault_go_file_context`, `vault_go_feed`, `vault_go_memory`, `vault_go_tool_uses`, `vault_go_stats`.
 
-`vault_go_retrieve` lets the central memory engine choose a bounded retrieval path while every explicit retrieval tool remains available. `vault_go_decision_status` reports sanitized rollout/circuit state. Jev and its credential remain in the engine; a healthy deployment does not by itself prove provider availability or decision quality.
+Read tools (`vault_go_search`, `vault_go_search_index`, `vault_go_feed`, `vault_go_retrieve` and query-anchored `vault_go_timeline`) are scoped to the project of the MCP server's working directory when no `projectId` is given; a git worktree maps to its main checkout. Pass `scope: "account"` to search every project of the account. Outside a known project they fall back to the account, and no project is created. Memories marked private stay out of search and feed results unless `includePrivate: true` is set.
+
+`vault_go_retrieve` lets the central memory engine choose a bounded retrieval path while every explicit retrieval tool remains available. `vault_go_decision_status` reports sanitized rollout/circuit state. Jev and its credential remain in the engine; a healthy deployment does not by itself prove provider availability or decision quality. `vault_go_decide` sends a caller-authored state plus up to 8 typed questions (`noul`, `choice`, `score`) to the central Jev and returns probabilities; it runs only in `full` rollout, one call at a time, refuses secrets, e-mails, identifiers, URLs and absolute local paths before anything leaves Vault, and persists nothing. The caller still owns the decision.
 
 Knowledge bases: `vault_go_knowledge_bases`, `vault_go_knowledge_base`, `vault_go_knowledge_build`, `vault_go_knowledge_rebuild`, `vault_go_knowledge_query`, `vault_go_knowledge_delete`, `vault_go_prime_corpus`, `vault_go_query_corpus`, `vault_go_reprime_corpus`.
 

package/dist/capabilities.d.ts

@@ -26,8 +26,8 @@ export declare const CAPABILITIES: {
     }, {
         readonly upstream: readonly ["automatic retrieval routing", "typed memory decisions"];
         readonly status: "available";
-        readonly tools: readonly ["vault_go_retrieve", "vault_go_decision_status"];
-        readonly requires: "Jev runs only in the central memory engine. Status is sanitized; deployment availability does not prove provider health or decision quality. Explicit retrieval tools remain available.";
+        readonly tools: readonly ["vault_go_retrieve", "vault_go_decision_status", "vault_go_decide"];
+        readonly requires: "Jev runs only in the central memory engine. Status is sanitized; deployment availability does not prove provider health or decision quality. vault_go_decide forwards caller-authored typed questions only in full rollout and refuses protected content. Explicit retrieval tools remain available.";
     }, {
         readonly upstream: readonly ["get_tool_uses"];
         readonly status: "available";
@@ -142,8 +142,8 @@ export declare function getCapabilities(home: string, cloud: VaultMemoryApi, ver
     }, {
         readonly upstream: readonly ["automatic retrieval routing", "typed memory decisions"];
         readonly status: "available";
-        readonly tools: readonly ["vault_go_retrieve", "vault_go_decision_status"];
-        readonly requires: "Jev runs only in the central memory engine. Status is sanitized; deployment availability does not prove provider health or decision quality. Explicit retrieval tools remain available.";
+        readonly tools: readonly ["vault_go_retrieve", "vault_go_decision_status", "vault_go_decide"];
+        readonly requires: "Jev runs only in the central memory engine. Status is sanitized; deployment availability does not prove provider health or decision quality. vault_go_decide forwards caller-authored typed questions only in full rollout and refuses protected content. Explicit retrieval tools remain available.";
     }, {
         readonly upstream: readonly ["get_tool_uses"];
         readonly status: "available";

package/dist/capabilities.js

@@ -11,7 +11,7 @@ export const CAPABILITIES = {
     capabilities: [
         { upstream: ['important_workflow'], status: 'available', tools: ['vault_go_workflow'] },
         { upstream: ['search', 'get_observations', 'timeline'], status: 'available', tools: ['vault_go_search_index', 'vault_go_observations', 'vault_go_timeline', 'vault_go_feed'], difference: 'Vault uses UUID identifiers. Search accepts an optional query, offset and date ordering; timeline accepts an explicit UUID or resolves an anchor from a query; feed uses stable cursor pagination.' },
-        { upstream: ['automatic retrieval routing', 'typed memory decisions'], status: 'available', tools: ['vault_go_retrieve', 'vault_go_decision_status'], requires: 'Jev runs only in the central memory engine. Status is sanitized; deployment availability does not prove provider health or decision quality. Explicit retrieval tools remain available.' },
+        { upstream: ['automatic retrieval routing', 'typed memory decisions'], status: 'available', tools: ['vault_go_retrieve', 'vault_go_decision_status', 'vault_go_decide'], requires: 'Jev runs only in the central memory engine. Status is sanitized; deployment availability does not prove provider health or decision quality. vault_go_decide forwards caller-authored typed questions only in full rollout and refuses protected content. Explicit retrieval tools remain available.' },
         { upstream: ['get_tool_uses'], status: 'available', tools: ['vault_go_tool_uses'], requires: 'Verified POST /memory/events/batch contract. Historical output exists only when captured; private fields and secrets are redacted from retrieval.' },
         { upstream: ['session_start_context', 'multi-project context'], status: 'available', tools: ['vault_go_session_start_context', 'vault_go_context', 'vault_go_file_context', 'vault_go_context_chain', 'vault_go_context_chain_configure'], requires: 'Context chains require explicit local configuration and share one bounded character budget. Native hooks cover Claude, Codex, Grok, Agy and Gemini; OpenCode 1.x remains context-only.' },
         { upstream: ['smart_search', 'smart_outline', 'smart_unfold'], status: 'available', tools: ['vault_go_smart_search', 'vault_go_smart_outline', 'vault_go_smart_unfold', 'vault_go_smart_languages'], requires: 'Real grammars for all 24 upstream languages plus HTML. Availability is reported per running platform; SCSS has no Linux ARM64 prebuild. Workspace reads and results are bounded.' },

package/dist/cloud.d.ts

@@ -26,6 +26,7 @@ export interface VaultMemoryApi {
     search(input: Record<string, unknown>): Promise<unknown>;
     retrieve?(input: Record<string, unknown>): Promise<unknown>;
     decisionStatus?(): Promise<unknown>;
+    decide?(input: Record<string, unknown>): Promise<unknown>;
     searchIndex(input: Record<string, unknown>): Promise<unknown>;
     observations(ids: string[]): Promise<unknown>;
     timeline(input: Record<string, unknown>): Promise<unknown>;
@@ -73,6 +74,7 @@ export declare class VaultCloudClient implements VaultMemoryApi {
     search(input: Record<string, unknown>): Promise<unknown>;
     retrieve(input: Record<string, unknown>): Promise<unknown>;
     decisionStatus(): Promise<unknown>;
+    decide(input: Record<string, unknown>): Promise<unknown>;
     searchIndex(input: Record<string, unknown>): Promise<unknown>;
     observations(ids: string[]): Promise<unknown>;
     timeline(input: Record<string, unknown>): Promise<unknown>;

package/dist/cloud.js

@@ -108,6 +108,9 @@ export class VaultCloudClient {
     async decisionStatus() {
         return this.request('/memory/decisions/status');
     }
+    async decide(input) {
+        return this.request('/memory/decisions/evaluate', { method: 'POST', body: input });
+    }
     async searchIndex(input) {
         return this.request('/memory/search/index', { method: 'POST', body: input });
     }

package/dist/hooks.d.ts

@@ -3,6 +3,8 @@ import { type VaultMemoryApi } from "./cloud.js";
 export declare const HOOK_EVENTS: readonly ["context", "session-init", "observation", "file-context", "summarize"];
 export type HookEvent = (typeof HOOK_EVENTS)[number];
 type RecordValue = Record<string, unknown>;
+/** The existing project for a working directory (worktrees map to their main checkout); never creates one. */
+export declare function findWorkspaceProject(cloud: Pick<VaultMemoryApi, "projects">, cwd: string): Promise<RecordValue | undefined>;
 export declare function normalizeHookInput(adapter: string, value: unknown): RecordValue;
 export declare function hookOutput(event: HookEvent, context?: string, adapter?: string): RecordValue;
 export declare function executeHook(adapter: string, event: HookEvent, value: unknown, cloud?: VaultMemoryApi, home?: string, options?: {

package/dist/hooks.js

@@ -66,6 +66,19 @@ function projectRoots(workspace) {
         return fallback;
     }
 }
+function matchWorkspaceProject(projects, roots) {
+    if (!Array.isArray(projects))
+        throw new Error("Resposta de projetos inválida");
+    return roots.map((cwd) => projects.find((item) => item &&
+        typeof item === "object" &&
+        typeof item.rootPath === "string" &&
+        Boolean(String(item.rootPath).trim()) &&
+        resolvedPath(String(item.rootPath)) === cwd)).find(Boolean);
+}
+/** The existing project for a working directory (worktrees map to their main checkout); never creates one. */
+export async function findWorkspaceProject(cloud, cwd) {
+    return matchWorkspaceProject(await cloud.projects(), projectRoots(root(cwd)));
+}
 function canonicalFile(file, workspace, project) {
     const absolute = resolve(workspace, file);
     for (const directory of [workspace, resolvedPath(workspace)]) {
@@ -173,11 +186,7 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
     const projects = await cloud.projects();
     if (!Array.isArray(projects))
         throw new Error("Resposta de projetos inválida");
-    let project = roots.map((cwd) => projects.find((item) => item &&
-        typeof item === "object" &&
-        typeof item.rootPath === "string" &&
-        Boolean(String(item.rootPath).trim()) &&
-        resolvedPath(String(item.rootPath)) === cwd)).find(Boolean);
+    let project = matchWorkspaceProject(projects, roots);
     const cwd = project ? resolvedPath(String(project.rootPath)) : roots[0];
     if (!project && reading)
         return hookOutput(event, "", adapter);

package/dist/knowledge-agent.d.ts

@@ -10,7 +10,7 @@ export declare function primeKnowledgeAgent(home: string, cloud: VaultMemoryApi,
     primed: boolean;
     memoryCount: number;
     conversationReset: boolean;
-    engine: "vault-ai-resume" | "claude-subscription" | "openai-subscription" | "openrouter" | "gemini";
+    engine: "gemini" | "vault-ai-resume" | "claude-subscription" | "openai-subscription" | "openrouter";
     model: string;
 }>;
 export declare function queryKnowledgeAgent(home: string, cloud: VaultMemoryApi, id: string, question: string, dependencies?: Dependencies): Promise<{
@@ -31,7 +31,7 @@ export declare function queryKnowledgeAgent(home: string, cloud: VaultMemoryApi,
         title: string;
     }[];
     generated: boolean;
-    engine: "vault-ai-resume" | "claude-subscription" | "openai-subscription" | "openrouter" | "gemini";
+    engine: "gemini" | "vault-ai-resume" | "claude-subscription" | "openai-subscription" | "openrouter";
     model: string;
     conversationTurns: number;
     contextTruncated: boolean;

package/dist/project-scope.d.ts

@@ -0,0 +1,13 @@
+import type { VaultMemoryApi } from './cloud.js';
+export type ProjectScope = 'project' | 'account';
+type ScopedInput = Record<string, unknown> & {
+    projectId?: string | undefined;
+    scope?: ProjectScope | undefined;
+};
+/**
+ * Why: MCP reads used to span every project of the account, so an agent in one
+ * repository received memories from unrelated clients. Reads now default to the
+ * project of the MCP server's working directory; `scope: "account"` widens them.
+ */
+export declare function createProjectScope(cloud: VaultMemoryApi, cwd?: () => string): (input: ScopedInput) => Promise<Record<string, unknown>>;
+export {};

package/dist/project-scope.js

@@ -0,0 +1,22 @@
+import { findWorkspaceProject } from './hooks.js';
+const CACHE_MS = 60_000;
+/**
+ * Why: MCP reads used to span every project of the account, so an agent in one
+ * repository received memories from unrelated clients. Reads now default to the
+ * project of the MCP server's working directory; `scope: "account"` widens them.
+ */
+export function createProjectScope(cloud, cwd = () => process.cwd()) {
+    let cached;
+    return async (input) => {
+        const { scope = 'project', ...rest } = input;
+        if (rest.projectId || scope === 'account')
+            return rest;
+        const workspace = cwd();
+        if (!cached || cached.cwd !== workspace || Date.now() - cached.at > CACHE_MS) {
+            const project = await findWorkspaceProject(cloud, workspace);
+            cached = { cwd: workspace, at: Date.now(), projectId: typeof project?.id === 'string' ? project.id : undefined };
+        }
+        // Outside a known project there is nothing narrower to scope to.
+        return cached.projectId ? { ...rest, projectId: cached.projectId } : rest;
+    };
+}

package/dist/server.js

@@ -9,6 +9,7 @@ import { registerCrystalTools } from './crystal-tools.js';
 import { registerModeIntegrations } from './mode-integrations.js';
 import { registerKnowledgeAgentTools } from './knowledge-tools.js';
 import { redact } from './hooks.js';
+import { createProjectScope } from './project-scope.js';
 import { VaultCloudClient } from './cloud.js';
 import { getStatus, vaultHome } from './config.js';
 import { createPrivateBackup, restorePrivateBackup } from './backup.js';
@@ -172,12 +173,23 @@ export function createVaultGoServer(home = vaultHome(), cloud = new VaultCloudCl
         inputSchema: { id: uuid },
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
     }, async ({ id }) => run(() => cloud.forget(id)));
+    const scoped = createProjectScope(cloud);
+    const scope = z
+        .enum(['project', 'account'])
+        .default('project')
+        .describe('project (padrão): só o projeto do diretório atual quando projectId não é informado; account: todos os projetos da conta.');
+    const includePrivate = z
+        .boolean()
+        .default(false)
+        .describe('Inclui memórias marcadas como privadas (por padrão ficam de fora).');
     server.registerTool('vault_go_search', {
         title: 'Pesquisar no Vault',
         description: 'Pesquisa memórias persistidas na plataforma Vault.',
         inputSchema: {
             query: z.string().trim().max(1_000).default(''),
             projectId: uuid.optional(),
+            scope,
+            includePrivate,
             kind: z.string().trim().max(100).optional(),
             memoryType: z.string().trim().max(100).optional(),
             platformSource: z.string().trim().max(100).optional(),
@@ -190,23 +202,24 @@ export function createVaultGoServer(home = vaultHome(), cloud = new VaultCloudCl
             orderBy: z.enum(['date_asc', 'date_desc']).optional(),
         },
         annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
-    }, async (input) => run(() => cloud.search(input)));
+    }, async (input) => run(async () => cloud.search(await scoped(input))));
     server.registerTool('vault_go_retrieve', {
         title: 'Recuperação automática do Vault',
         description: 'Delega ao motor central a escolha tipada entre busca, contexto de arquivo, linha do tempo, base de conhecimento, grafo ou nenhum resultado. Falhas usam busca determinística.',
         inputSchema: {
             query: z.string().trim().min(1).max(1_000),
             projectId: uuid.optional(),
+            scope,
             files: z.array(z.string().trim().min(1).max(2_000)).max(50).default([]),
             knowledgeBaseId: uuid.optional(),
             limit: z.number().int().min(1).max(200).default(20),
             maxChars: z.number().int().min(1_000).max(100_000).optional(),
         },
         annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
-    }, async (input) => run(() => {
+    }, async (input) => run(async () => {
         if (!cloud.retrieve)
             throw new Error('Native retrieval is unavailable on this deployment.');
-        return cloud.retrieve(input);
+        return cloud.retrieve(await scoped(input));
     }));
     server.registerTool('vault_go_decision_status', {
         title: 'Status da camada de decisão',
@@ -218,12 +231,48 @@ export function createVaultGoServer(home = vaultHome(), cloud = new VaultCloudCl
             throw new Error('Decision status is unavailable on this deployment.');
         return cloud.decisionStatus();
     }));
+    const decisionText = (max) => z.string().trim().min(1).max(max);
+    const decisionQuestion = z.discriminatedUnion('type', [
+        z.object({
+            type: z.literal('noul'),
+            instructions: decisionText(2_000),
+            criteria: z.object({ true: decisionText(500), false: decisionText(500) }).strict().optional(),
+        }).strict(),
+        z.object({
+            type: z.literal('choice'),
+            instructions: decisionText(2_000),
+            criteria: z.record(z.string().regex(/^[a-z0-9][a-z0-9_-]{0,47}$/), decisionText(500))
+                .refine((options) => Object.keys(options).length >= 2 && Object.keys(options).length <= 32, 'choice needs 2 to 32 options'),
+        }).strict(),
+        z.object({
+            type: z.literal('score'),
+            instructions: decisionText(2_000),
+            criteria: z.array(decisionText(500)).min(2).max(10),
+        }).strict(),
+    ]);
+    server.registerTool('vault_go_decide', {
+        title: 'Decidir com o Jev',
+        description: 'Envia ao Jev central um estado e até 8 perguntas tipadas (noul = probabilidade de sim; choice = uma opção entre 2–32; score = nível entre 2–10) e retorna respostas com probabilidades. '
+            + 'Exige rollout full. Segredos, e-mails, UUIDs, URLs e caminhos locais absolutos são recusados antes de sair do Vault. Nada é persistido; a decisão final continua sendo de quem chama.',
+        inputSchema: {
+            state: z.union([z.string().trim().min(1), z.record(z.string(), z.unknown()), z.array(z.unknown()).min(1)]),
+            questions: z.record(z.string().regex(/^[a-z][a-z0-9_]{0,47}$/), decisionQuestion)
+                .refine((questions) => Object.keys(questions).length >= 1 && Object.keys(questions).length <= 8, 'questions must contain 1 to 8 entries'),
+        },
+        annotations: { readOnlyHint: true, idempotentHint: false, openWorldHint: true },
+    }, async (input) => run(() => {
+        if (!cloud.decide)
+            throw new Error('Jev decisions are unavailable on this deployment.');
+        return cloud.decide(input);
+    }));
     server.registerTool('vault_go_search_index', {
         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().max(1_000).default(''),
             projectId: uuid.optional(),
+            scope,
+            includePrivate,
             kind: z.string().trim().max(100).optional(),
             memoryType: z.string().trim().max(100).optional(),
             platformSource: z.string().trim().max(100).optional(),
@@ -236,7 +285,7 @@ export function createVaultGoServer(home = vaultHome(), cloud = new VaultCloudCl
             orderBy: z.enum(['date_asc', 'date_desc']).optional(),
         },
         annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
-    }, async (input) => run(() => cloud.searchIndex(input)));
+    }, async (input) => run(async () => cloud.searchIndex(await scoped(input))));
     server.registerTool('vault_go_observations', {
         title: 'Carregar observações por ID',
         description: 'Terceira camada de recuperação: carrega em lote somente as observações escolhidas no índice ou na linha do tempo.',
@@ -252,15 +301,18 @@ export function createVaultGoServer(home = vaultHome(), cloud = new VaultCloudCl
             anchorId: uuid.optional(),
             query: z.string().trim().min(1).max(1_000).optional(),
             projectId: uuid.optional(),
+            scope,
             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(() => {
+    }, async (input) => run(async () => {
         if (Boolean(input.anchorId) === Boolean(input.query))
             throw new Error('Informe exatamente anchorId ou query.');
-        return cloud.timeline(input);
+        // An anchor already identifies its project; only query anchors are scoped.
+        const { scope: _scope, ...anchored } = input;
+        return cloud.timeline(input.anchorId ? anchored : await scoped(input));
     }));
     server.registerTool('vault_go_context', {
         title: 'Montar contexto',
@@ -295,6 +347,8 @@ export function createVaultGoServer(home = vaultHome(), cloud = new VaultCloudCl
         description: 'Lista memórias recentes com paginação estável por cursor.',
         inputSchema: {
             projectId: uuid.optional(),
+            scope,
+            includePrivate,
             kind: z.string().trim().max(100).optional(),
             memoryType: z.string().trim().max(100).optional(),
             platformSource: z.string().trim().max(100).optional(),
@@ -302,7 +356,7 @@ export function createVaultGoServer(home = vaultHome(), cloud = new VaultCloudCl
             limit: z.number().int().min(1).max(100).default(20),
         },
         annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
-    }, async (input) => run(() => cloud.feed(input)));
+    }, async (input) => run(async () => cloud.feed(await scoped(input))));
     server.registerTool('vault_go_knowledge_bases', {
         title: 'Listar bases de conhecimento',
         description: 'Lista bases filtradas e persistidas na plataforma Vault.',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vault-go",
-  "version": "0.26.0",
+  "version": "0.28.0",
   "description": "MCP server and installer for Vault Memory: search, capture, and use account memory across AI clients.",
   "type": "module",
   "bin": {
@@ -84,7 +84,9 @@
     "dist/mcp-clients.js",
     "dist/mcp-clients.d.ts",
     "dist/mcp-result.js",
+    "dist/project-scope.js",
     "dist/mcp-result.d.ts",
+    "dist/project-scope.d.ts",
     "dist/parity-tools.js",
     "dist/parity-tools.d.ts",
     "dist/capabilities.js",
@@ -133,7 +135,7 @@
   ],
   "scripts": {
     "clean": "bun -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
-    "build": "bun run clean && tsc -p tsconfig.json",
+    "build": "bun run clean && tsc -p tsconfig.build.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "bun run build && bun test src",
     "pack:check": "npm pack --dry-run",