vault-go 0.29.0 → 0.29.2

package/README.md

@@ -150,6 +150,8 @@ Capture and recall: `vault_go_event`, `vault_go_remember`, `vault_go_forget`, `v
 
 Projects are matched by path first and then by repository: vault-go reads the checkout's `origin` remote, normalizes it to `host/owner/repo` and records it as the project's `repoKey`. A clone on another machine or user joins the oldest project with the same `repoKey` instead of creating a new one, and projects created before this are backfilled the first time a capture matches them by path.
 
+A folder without git joins the nearest existing project above it instead of becoming a project of its own; a git checkout always keeps its own project.
+
 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.

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

@@ -1,7 +1,7 @@
 import { redact } from './capture-privacy.js';
 export { redact } from './capture-privacy.js';
 import { createHash, randomUUID } from "node:crypto";
-import { basename, dirname, isAbsolute, relative, resolve } from "node:path";
+import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { applyCustomModeContext } from './custom-modes.js';
 import { VaultCloudClient } from "./cloud.js";
@@ -67,7 +67,7 @@ function projectRoots(workspace) {
         return fallback;
     }
 }
-function matchWorkspaceProject(projects, roots, key) {
+function matchWorkspaceProject(projects, roots, key, inGit = true) {
     if (!Array.isArray(projects))
         throw new Error("Resposta de projetos inválida");
     const byPath = roots.map((cwd) => projects.find((item) => item &&
@@ -75,16 +75,34 @@ function matchWorkspaceProject(projects, roots, key) {
         typeof item.rootPath === "string" &&
         Boolean(String(item.rootPath).trim()) &&
         resolvedPath(String(item.rootPath)) === cwd)).find(Boolean);
-    if (byPath || !key)
+    if (byPath)
         return byPath;
     // Why: a clone on another machine or user shares the repository, not the path.
     // Projects arrive newest first; the oldest one with this key is the canonical one.
-    return projects.filter((item) => item && typeof item === "object" && item.repoKey === key).at(-1);
+    const byRepo = key
+        ? projects.filter((item) => item && typeof item === "object" && item.repoKey === key).at(-1)
+        : undefined;
+    if (byRepo || inGit)
+        return byRepo;
+    // Why: a folder without git used to become its own project, splitting memories
+    // between an umbrella folder and its subfolders. Prefer the nearest existing ancestor.
+    const cwd = roots[0];
+    return projects
+        .filter((item) => {
+        if (!item || typeof item !== "object" || typeof item.rootPath !== "string")
+            return false;
+        const path = String(item.rootPath).trim();
+        if (!path)
+            return false;
+        const ancestor = relative(resolvedPath(path), cwd);
+        return Boolean(ancestor) && ancestor !== ".." && !ancestor.startsWith(`..${sep}`) && !isAbsolute(ancestor);
+    })
+        .sort((a, b) => resolvedPath(String(b.rootPath)).length - resolvedPath(String(a.rootPath)).length)[0];
 }
 /** The existing project for a working directory (worktrees map to their main checkout); never creates one. */
 export async function findWorkspaceProject(cloud, cwd) {
     const workspace = root(cwd);
-    return matchWorkspaceProject(await cloud.projects(), projectRoots(workspace), repoKey(workspace));
+    return matchWorkspaceProject(await cloud.projects(), projectRoots(workspace), repoKey(workspace), existsSync(resolve(workspace, ".git")));
 }
 function canonicalFile(file, workspace, project) {
     const absolute = resolve(workspace, file);
@@ -194,7 +212,7 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
     if (!Array.isArray(projects))
         throw new Error("Resposta de projetos inválida");
     const key = repoKey(workspace);
-    let project = matchWorkspaceProject(projects, roots, key);
+    let project = matchWorkspaceProject(projects, roots, key, existsSync(resolve(workspace, ".git")));
     const cwd = project ? resolvedPath(String(project.rootPath)) : roots[0];
     if (!project && reading)
         return hookOutput(event, "", adapter);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vault-go",
-  "version": "0.29.0",
+  "version": "0.29.2",
   "description": "MCP server and installer for Vault Memory: search, capture, and use account memory across AI clients.",
   "type": "module",
   "bin": {