pi-vault-mind 0.16.4 → 0.16.6

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 0.16.6 / 0.6.8 — 2026-07-18
+
+### Fixed
+
+- **First-run personalization handoff.** Configured vaults now remain on a dedicated personalization card until `/vm personalize` durably completes, including the valid all-suggestions-rejected path. The chat feed and composer are revealed only after the persisted completion status is observed.
+- **Live Pi model selection.** The first-run card now loads the active model and catalog from typed Pi RPC state, preserves provider and model ID for selection, and starts Pi only when a configured panel refresh needs that catalog.
+
+### Tests
+
+- Added regression coverage for first-run gating, model selection ordering, delayed personalization completion, and demand-driven Pi model loading.
+
+## 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

package/dist/src/commands.js

@@ -1760,7 +1760,8 @@ export const registerCommands = (pi) => {
                 case "remote":
                     return handleModal(rest, ctx, pi);
                 case "personalize":
-                    return runPersonalize(ctx, pi);
+                    await runPersonalize(ctx, pi);
+                    return;
                 case "setup":
                     return handleSetup(rest, ctx, pi);
                 case "token":

package/dist/src/personalize.d.ts

@@ -44,4 +44,6 @@ export declare const presentAndApplyDiff: (suggestions: SuggestionResult, ctx: E
     rejected: string[];
 }>;
 /** Orchestrate /vm personalize: analyze, suggest, confirm, apply. */
-export declare const runPersonalize: (ctx: ExtensionContext, pi: ExtensionAPI) => Promise<void>;
+export declare const runPersonalize: (ctx: ExtensionContext, pi: ExtensionAPI) => Promise<{
+    completed: boolean;
+}>;

package/dist/src/personalize.js

@@ -2,7 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
 import { getStatus } from "./lance.js";
-import { expandHome, loadConfig, resolveAgentDir } from "./utils.js";
+import { expandHome, getPersonalizedMarkerPath, loadConfig, resolveAgentDir } from "./utils.js";
 /** Resolve the vault path: configured default vault wins, otherwise ctx.cwd. */
 export const resolveVaultPath = (ctx) => {
     const cfg = loadConfig(ctx.cwd);
@@ -359,8 +359,14 @@ export const runPersonalize = async (ctx, pi) => {
     try {
         const suggestions = await generateSuggestions(pi, profile, currentConfig);
         await presentAndApplyDiff(suggestions, ctx, currentConfig);
+        const markerPath = getPersonalizedMarkerPath(vaultPath);
+        await fs.promises.mkdir(path.dirname(markerPath), { recursive: true });
+        await fs.promises.writeFile(markerPath, JSON.stringify({ completed: true, completedAt: new Date().toISOString() }, null, 2));
+        return { completed: true };
     }
     catch (err) {
-        ctx.ui.notify(`Personalization failed: ${err.message}`, "error");
+        const message = err instanceof Error ? err.message : String(err);
+        ctx.ui.notify(`Personalization failed: ${message}`, "error");
+        return { completed: false };
     }
 };

package/dist/src/server.js

@@ -45,7 +45,7 @@ import { readModelProviders } from "./models.js";
 import { scaffoldVaultConfig } from "./scaffold.js";
 import { archiveSession, deleteSession, exportSession, getSession, listSessions, renameSession, resolveSessionsDir, searchSessions, } from "./session-search.js";
 import { listAllTools } from "./tool-catalog.js";
-import { ensureDir, expandHome, findConfig, getConfigPath, loadConfig, resolveVaultFile, resolveVaultMindPaths, shrinkHome, } from "./utils.js";
+import { ensureDir, expandHome, findConfig, getConfigPath, isPersonalized, loadConfig, resolveVaultFile, resolveVaultMindPaths, shrinkHome, } from "./utils.js";
 import { classifySearchMode, normalizeGraphResult, searchVaultNative } from "./vault-tools.js";
 import { createManualDispatch, processQueue, scanFile, startWatcher, stopWatcher, } from "./watcher.js";
 export function createServerState(port = 11435) {
@@ -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,23 @@ 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 personalized = isPersonalized(vaultPath);
     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,
+        personalized,
+        vaultPath,
         watcher: ws?.running ?? false,
         embedding: {
             model,

package/dist/src/utils.d.ts

@@ -13,6 +13,9 @@ export declare const resolveAgentDir: (cwd: string) => string;
 export declare const resolveVaultMindDir: (cwd: string) => string;
 /** Active pi-vault-mind config: `<vault>/.vault-mind/vault-mind.config.json`. */
 export declare const getConfigPath: (cwd: string) => string;
+export declare const getPersonalizedMarkerPath: (cwd: string) => string;
+/** Check if a vault has a valid personalization completion marker. */
+export declare function isPersonalized(cwd: string): boolean;
 /** Token env file: `<vault>/.vault-mind/vault-mind.env`. */
 export declare const getTokenEnvPath: (cwd: string) => string;
 export declare const EXT_ROOT: string;

package/dist/src/utils.js

@@ -18,6 +18,19 @@ export const resolveAgentDir = (cwd) => {
 export const resolveVaultMindDir = (cwd) => path.join(cwd, VAULT_MIND_DIR);
 /** Active pi-vault-mind config: `<vault>/.vault-mind/vault-mind.config.json`. */
 export const getConfigPath = (cwd) => path.join(resolveVaultMindDir(cwd), "vault-mind.config.json");
+export const getPersonalizedMarkerPath = (cwd) => path.join(resolveVaultMindDir(cwd), "personalized.json");
+/** Check if a vault has a valid personalization completion marker. */
+export function isPersonalized(cwd) {
+    const p = getPersonalizedMarkerPath(cwd);
+    try {
+        const content = fs.readFileSync(p, "utf8");
+        const marker = JSON.parse(content);
+        return marker && typeof marker === "object" && marker.completed === true;
+    }
+    catch {
+        return false;
+    }
+}
 /** Token env file: `<vault>/.vault-mind/vault-mind.env`. */
 export const getTokenEnvPath = (cwd) => path.join(resolveVaultMindDir(cwd), "vault-mind.env");
 export const EXT_ROOT = path.join(import.meta.dirname, "..", "..");

package/dist/test/personalize.test.js

@@ -192,6 +192,69 @@ describe("personalize", () => {
         // AGENTS.md was never created, so rejection means it still does not exist.
         assert.equal(fs.existsSync(path.join(testDir, "AGENTS.md")), false);
     });
+    it("persists a completion marker even when all suggestions are rejected or skipped", async () => {
+        const { runPersonalize } = await import("../src/personalize.js");
+        const pi = makePi(JSON.stringify({
+            commentary: "No changes needed.",
+            files: [
+                { path: ".pi/agent/system.md", action: "skip" },
+                { path: "AGENTS.md", action: "skip" },
+            ],
+        }));
+        const ctx = makeCtx(testDir, []);
+        await runPersonalize(ctx, pi);
+        const markerPath = path.join(testDir, ".vault-mind", "personalized.json");
+        assert.ok(fs.existsSync(markerPath), "runPersonalize must write a durable completion marker after the flow finishes, even when every diff is rejected");
+        const marker = JSON.parse(fs.readFileSync(markerPath, "utf-8"));
+        assert.strictEqual(marker.completed, true);
+        assert.ok(typeof marker.completedAt === "string");
+    });
+    it("persists a completion marker after approved suggestions", async () => {
+        const { runPersonalize } = await import("../src/personalize.js");
+        const pi = makePi(JSON.stringify({
+            commentary: "Updated tuning.",
+            files: [{ path: ".pi/agent/system.md", action: "create", content: "# New system" }],
+        }));
+        const ctx = makeCtx(testDir, [true]);
+        await runPersonalize(ctx, pi);
+        const markerPath = path.join(testDir, ".vault-mind", "personalized.json");
+        assert.ok(fs.existsSync(markerPath), "runPersonalize must write a durable completion marker after approved suggestions are applied");
+        const marker = JSON.parse(fs.readFileSync(markerPath, "utf-8"));
+        assert.strictEqual(marker.completed, true);
+        assert.ok(typeof marker.completedAt === "string");
+    });
+    it("returns a successful result when all suggestions are rejected", async () => {
+        const { runPersonalize: raw } = await import("../src/personalize.js");
+        const runPersonalize = raw;
+        const pi = makePi(JSON.stringify({
+            commentary: "No changes needed.",
+            files: [
+                { path: ".pi/agent/system.md", action: "skip" },
+                { path: "AGENTS.md", action: "skip" },
+            ],
+        }));
+        const ctx = makeCtx(testDir, []);
+        const result = await runPersonalize(ctx, pi);
+        assert.ok(result, "runPersonalize must return a result, not void");
+        assert.strictEqual(result.completed, true, "all-rejected personalization must resolve as a successful completion");
+    });
+    it("returns a failed result when suggestion generation fails", async () => {
+        const { runPersonalize: raw } = await import("../src/personalize.js");
+        const runPersonalize = raw;
+        const pi = makePi("not valid JSON");
+        const ctx = makeCtx(testDir, []);
+        const result = await runPersonalize(ctx, pi);
+        assert.ok(result, "runPersonalize must return a result, not void");
+        assert.strictEqual(result.completed, false, "a generation failure must resolve as a failed personalization, distinguishable from success");
+    });
+    it("does not persist a completion marker when suggestion generation fails", async () => {
+        const { runPersonalize } = await import("../src/personalize.js");
+        const pi = makePi("not valid JSON");
+        const ctx = makeCtx(testDir, []);
+        await runPersonalize(ctx, pi);
+        const markerPath = path.join(testDir, ".vault-mind", "personalized.json");
+        assert.strictEqual(fs.existsSync(markerPath), false, "runPersonalize must not leave a completion marker after a failed personalization");
+    });
     it("presentAndApplyDiff creates missing directories for new files", async () => {
         const { presentAndApplyDiff } = await import("../src/personalize.js");
         const ctx = makeCtx(testDir, [true]);

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.4",
+	"version": "0.16.6",
 	"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",