pi-vault-mind 0.16.5 → 0.16.6

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # 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

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) {
@@ -1100,12 +1100,14 @@ function handleVmStatus(res, serverState) {
     }
     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: {

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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-vault-mind",
-	"version": "0.16.5",
+	"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",