pi-vault-mind 0.16.3 → 0.16.5

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 0.16.5 / 0.6.7 — 2026-07-18
+
+### Fixed
+
+- **Vault-scoped runtime ownership.** The plugin serializes startup per vault, adopts only a healthy bridge for the same canonical vault, and uses the configured `vaultMind.files.serverState` discovery path. This prevents duplicate Pi runtime launches across plugin instances and reloads.
+- **Post-setup chat handoff.** A successful setup refreshes the shared panel controller before revealing an existing Vault Mind leaf. The panel remains available with its retained status if that refresh transiently fails.
+- **Setup REST identity.** `GET /vm/status` now returns the configured vault identity so the plugin can verify runtime ownership.
+
+### Tests
+
+- Added focused coverage for same-vault startup serialization, custom runtime discovery paths, setup-to-chat refresh ordering, and mount-on-refresh-failure behavior.
+
+## 0.16.4 / 0.6.6 — 2026-07-17
+
+### Fixed
+
+- **Obsidian-contained popovers.** Shared folder pickers now convert viewport anchor coordinates into the workspace leaf's fixed containing block, so their menus stay aligned with their input fields in the real Obsidian shell.
+- **Cloud-only default chat routing.** New vault model-router configurations use `ollama/gemma4:31b-cloud` for every auto profile tier and explicit cloud fallbacks only. ReturnVape's active vault-local runtime configuration was migrated to remove local Gemma chat routes; local embedding models remain unchanged.
+
+### Tests
+
+- Added focused regression coverage for contained popover placement and cloud-only model-router defaults/profiles.
+
 ## 0.16.3 / 0.6.5 — 2026-07-16
 
 ### Added

package/dist/src/model-router.js

@@ -14,12 +14,14 @@ import * as fs from "node:fs";
 import { ensureDir, resolveVaultMindPaths } from "./utils.js";
 /** Tuned default primary model + fallback sequence for the `auto` router profile. */
 export const defaultModelRouterChoices = () => {
-    const isMacOS = process.platform === "darwin";
     return {
         primary: "ollama/gemma4:31b-cloud",
-        fallbackSequence: isMacOS
-            ? ["ollama/gemma4:e4b", "ollama/gemma4:12b-mlx", "ollama/gemma3:4b", "ollama/*"]
-            : ["ollama/gemma4:e4b", "ollama/gemma4:12b", "ollama/gemma3:4b", "ollama/*"],
+        fallbackSequence: [
+            "ollama/gemma4:31b-cloud",
+            "ollama/deepseek-v4-flash:cloud",
+            "ollama/minimax-m3:cloud",
+            "ollama/kimi-k2.7-code:cloud",
+        ],
     };
 };
 /**
@@ -32,7 +34,7 @@ export const scaffoldModelRouterConfig = (cwd) => {
     const { modelRouter: configPath } = resolveVaultMindPaths(cwd);
     if (fs.existsSync(configPath))
         return { created: false, path: configPath };
-    const { primary: mediumModel, fallbackSequence } = defaultModelRouterChoices();
+    const { primary, fallbackSequence } = defaultModelRouterChoices();
     const config = {
         defaultProfile: "auto",
         features: {
@@ -55,9 +57,9 @@ export const scaffoldModelRouterConfig = (cwd) => {
         },
         profiles: {
             auto: {
-                high: { model: "ollama/gemma4:31b-cloud", thinking: "medium" },
-                medium: { model: mediumModel, thinking: "low" },
-                low: { model: "ollama/gemma4:e4b", thinking: "off" },
+                high: { model: primary, thinking: "medium" },
+                medium: { model: primary, thinking: "low" },
+                low: { model: primary, thinking: "off" },
             },
         },
     };

package/dist/src/server.js

@@ -98,8 +98,13 @@ export function startServer(pi, serverState, watcherState, readinessCallback) {
     // Resolve the vault path from the loaded config's default vault, else cwd.
     const startupCfg = loadConfig(process.cwd());
     const defaultVault = startupCfg.vaultMind.vaults?.default?.path;
-    const vaultPath = defaultVault && fs.existsSync(defaultVault) ? defaultVault : process.cwd();
-    serverState.vaultPath = vaultPath;
+    const configuredVaultPath = defaultVault && fs.existsSync(defaultVault) ? defaultVault : process.cwd();
+    try {
+        serverState.vaultPath = fs.realpathSync.native(configuredVaultPath);
+    }
+    catch {
+        serverState.vaultPath = path.resolve(configuredVaultPath);
+    }
     serverState.server = http.createServer(async (req, res) => {
         applyCorsPolicy(req.headers.origin, serverState.port, res);
         res.setHeader("Content-Type", "application/json");
@@ -750,15 +755,25 @@ export function startServer(pi, serverState, watcherState, readinessCallback) {
             res.end(JSON.stringify({ error: message }));
         }
     });
-    let retriedEphemeral = false;
     serverState.server.on("error", (err) => {
-        if (err.code === "EADDRINUSE" && !retriedEphemeral) {
-            retriedEphemeral = true;
-            console.warn(`[pi-vault-mind] Port ${serverState.port} in use; retrying on ephemeral port.`);
-            serverState.server?.listen(0, "127.0.0.1");
-        }
-        else if (err.code === "EADDRINUSE") {
-            console.warn(`[pi-vault-mind] Port ${serverState.port} in use. HTTP server not started.`);
+        if (err.code === "EADDRINUSE") {
+            console.warn(`[pi-vault-mind] Port ${serverState.port} in use; HTTP server not started.`);
+            if (serverState.unsubQueue) {
+                serverState.unsubQueue();
+                serverState.unsubQueue = undefined;
+            }
+            if (serverState.unsubToolBus) {
+                serverState.unsubToolBus();
+                serverState.unsubToolBus = undefined;
+            }
+            if (serverState.wss) {
+                serverState.wss.close();
+                serverState.wss = null;
+            }
+            if (serverState.server) {
+                serverState.server.close();
+                serverState.server = null;
+            }
         }
         else {
             console.error("[pi-vault-mind] HTTP server error:", err);
@@ -1077,14 +1092,21 @@ function handleVaultMindContextGet(res, serverState) {
 // ── Stage 1 setup routes (auth-gated) ───────────────────────────────────────
 function handleVmStatus(res, serverState) {
     const ws = serverState.watcherState;
-    const cfg = loadConfig(process.cwd());
-    const configured = !!findConfig(process.cwd()).project;
+    const vaultPath = serverState.vaultPath;
+    if (!vaultPath) {
+        res.writeHead(500);
+        res.end(JSON.stringify({ error: "Vault path not set" }));
+        return;
+    }
+    const cfg = loadConfig(vaultPath);
+    const configured = !!findConfig(vaultPath).project;
     const model = cfg.vaultMind.embedding[EMBEDDING_FLAT_KEYS[2]] || "embeddinggemma";
     const dim = cfg.vaultMind.embedding[EMBEDDING_FLAT_KEYS[4]] ?? 768;
     res.writeHead(200);
     res.end(JSON.stringify({
         ok: true,
         configured,
+        vaultPath,
         watcher: ws?.running ?? false,
         embedding: {
             model,

package/dist/test/model-router.test.js

@@ -15,19 +15,21 @@ describe("defaultModelRouterChoices", () => {
         assert.ok(Array.isArray(fallbackSequence));
         assert.equal(fallbackSequence.length, 4);
     });
-    it("includes the common baseline entries regardless of platform", () => {
+    it("selects only explicit cloud fallbacks", () => {
         const { fallbackSequence } = defaultModelRouterChoices();
-        for (const entry of ["ollama/gemma4:e4b", "ollama/gemma3:4b", "ollama/*"]) {
-            assert.ok(fallbackSequence.includes(entry), `expected fallbackSequence to include ${entry}`);
+        assert.ok(fallbackSequence.length > 0);
+        for (const model of fallbackSequence) {
+            assert.match(model, /(?:-cloud|:cloud)$/);
         }
     });
-    it("includes exactly one of the platform-specific mid-tier variants", () => {
+    it("uses the configured cloud fallback sequence", () => {
         const { fallbackSequence } = defaultModelRouterChoices();
-        const macVariant = fallbackSequence.includes("ollama/gemma4:12b-mlx");
-        const otherVariant = fallbackSequence.includes("ollama/gemma4:12b");
-        // Exactly one of the two platform-specific entries is present — never both,
-        // never neither — without hardcoding which platform CI happens to run on.
-        assert.notEqual(macVariant, otherVariant);
+        assert.deepEqual(fallbackSequence, [
+            "ollama/gemma4:31b-cloud",
+            "ollama/deepseek-v4-flash:cloud",
+            "ollama/minimax-m3:cloud",
+            "ollama/kimi-k2.7-code:cloud",
+        ]);
     });
 });
 describe("scaffoldModelRouterConfig", () => {
@@ -83,6 +85,9 @@ describe("scaffoldModelRouterConfig", () => {
             assert.equal(typeof profile.model, "string");
             assert.equal(typeof profile.thinking, "string");
         }
+        for (const tier of ["high", "medium", "low"]) {
+            assert.equal(parsed.profiles.auto[tier].model, "ollama/gemma4:31b-cloud");
+        }
     });
     it("never overwrites an existing model-router.json (idempotent)", () => {
         const expectedPath = resolveVaultMindPaths(testDir).modelRouter;

package/dist/test/rest-setup.test.js

@@ -81,6 +81,13 @@ describe("REST setup routes", () => {
         const { status } = await fetchJson(port, "GET", "/vm/status");
         assert.equal(status, 401);
     });
+    it("GET /vm/status returns the configured vault identity", async () => {
+        writeVaultConfig(vaultPath);
+        const { status, body } = await fetchJson(port, "GET", "/vm/status", { token: TEST_TOKEN });
+        assert.equal(status, 200);
+        const b = body;
+        assert.equal(b.vaultPath, vaultPath, "status must expose the resolved vault path so clients can recheck vault identity");
+    });
     it("POST /vm/setup scaffolds config and vault-named collection file", async () => {
         const { status, body } = await fetchJson(port, "POST", "/vm/setup", {
             body: { vault: vaultPath },

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-vault-mind",
-	"version": "0.16.3",
+	"version": "0.16.5",
 	"description": "Passive Obsidian vault extension for pi. Watches @agent markers, dispatches forked subagents (Miner, Broadcaster, Heavy-Lifter), stores in LanceDB with vector + FTS + graph. Multi-agent 'Drop & Forget' workflow for the pi agent ecosystem.",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",