pi-vault-mind 0.14.2 → 0.16.3

package/scripts/e2e-commands.mjs

@@ -0,0 +1,391 @@
+#!/usr/bin/env node
+/**
+ * E2E smoke for /vm slash commands + BC-2 rewind/fork RPC — real pi CLI.
+ *
+ * Creates a temp vault, scaffolds config, installs the extension via `pi install`,
+ * spawns `pi --mode rpc`, drives commands via JSON-line stdin, asserts on
+ * responses and file side-effects, then tears down. No mocks.
+ *
+ * Prerequisites: pi binary on PATH, pnpm build completed.
+ *
+ * Usage:
+ *   pnpm build
+ *   pnpm e2e:commands
+ */
+
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+let failures = 0;
+const pass = (msg) => console.log(`  \x1b[32m✓\x1b[0m ${msg}`);
+const fail = (msg) => {
+	failures++;
+	console.log(`  \x1b[31m✗\x1b[0m ${msg}`);
+};
+const step = (msg) => console.log(`\n\x1b[1m${msg}\x1b[0m`);
+
+function tmpDir(prefix) {
+	const dir = path.join(os.tmpdir(), `${prefix}-${randomUUID()}`);
+	fs.mkdirSync(dir, { recursive: true });
+	return dir;
+}
+
+// ── Vault setup ──────────────────────────────────────────────────────────────
+
+async function hasOllamaEmbeddingModel() {
+	try {
+		const res = await fetch("http://localhost:11434/api/embeddings", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ model: "all-minilm", prompt: "health check" }),
+			signal: AbortSignal.timeout(5000),
+		});
+		if (!res.ok) return false;
+		const data = await res.json();
+		return Array.isArray(data.embedding) && data.embedding.length === 384;
+	} catch {
+		return false;
+	}
+}
+
+async function setupVault(vaultPath, seedSearchIndex) {
+	const cfgDir = path.join(vaultPath, ".vault-mind");
+	fs.mkdirSync(cfgDir, { recursive: true });
+	const collectionsDir = path.join(vaultPath, "collections");
+	fs.mkdirSync(collectionsDir, { recursive: true });
+
+	const entries = [
+		{ id: "1", domain: "test", fact: "First test entry", tag: "alpha" },
+		{ id: "2", domain: "test", fact: "Second test entry", tag: "beta" },
+		{ id: "3", domain: "prod", fact: "Production entry", tag: "alpha" },
+	];
+	const jsonl = `${entries.map((e) => JSON.stringify(e)).join("\n")}\n`;
+
+	const config = {
+		version: 2,
+		collections: {
+			main: {
+				path: "collections/main.jsonl",
+				schema: ["id", "domain", "source", "fact", "tag"],
+				dedupField: "fact",
+			},
+		},
+		injectors: [],
+		vaultMind: {
+			dataDir: ".lancedb",
+			embedding: {
+				localUrl: "http://localhost:11434",
+				model: "all-minilm",
+				dim: 384,
+				useTransformers: false,
+			},
+			ftsEnabled: true,
+			graph: { enabled: false },
+		},
+	};
+	fs.writeFileSync(
+		path.join(cfgDir, "vault-mind.config.json"),
+		JSON.stringify(config, null, 2),
+		"utf-8"
+	);
+	fs.writeFileSync(path.join(collectionsDir, "main.jsonl"), jsonl, "utf-8");
+
+	if (!seedSearchIndex) return;
+
+	// Build LanceDB index from the seeded JSONL entries so /vm search can find them
+	const repoRoot = path.resolve(import.meta.dirname, "..");
+	const { upsertEntry } = await import(path.join(repoRoot, "dist/src/lance.js"));
+	const { loadConfig } = await import(path.join(repoRoot, "dist/src/utils.js"));
+	const cfg = loadConfig(vaultPath);
+	const dataDir = path.resolve(vaultPath, cfg.vaultMind.dataDir);
+	for (const entry of entries) {
+		await upsertEntry(dataDir, "main", entry, cfg.vaultMind);
+	}
+}
+
+// ── Pi RPC ───────────────────────────────────────────────────────────────────
+
+async function runPiRpc(vaultPath, commands) {
+	return new Promise((resolve, reject) => {
+		const piAgentDir = path.join(vaultPath, ".pi", "agent");
+		const env = {
+			...process.env,
+			PI_CODING_AGENT_DIR: piAgentDir,
+			HOME: vaultPath,
+			USERPROFILE: vaultPath,
+		};
+
+		const child = spawn("pi", ["--mode", "rpc"], {
+			cwd: vaultPath,
+			env,
+			stdio: ["pipe", "pipe", "pipe"],
+		});
+
+		const responses = [];
+		let stderr = "";
+		let commandIndex = 0;
+		let resolved = false;
+		const TIMEOUT_MS = 120_000;
+
+		let buffer = "";
+		child.stdout.on("data", (chunk) => {
+			buffer += chunk.toString();
+			const lines = buffer.split("\n");
+			buffer = lines.pop() ?? "";
+			for (const line of lines) {
+				const trimmed = line.endsWith("\r") ? line.slice(0, -1) : line;
+				if (!trimmed) continue;
+				try {
+					const event = JSON.parse(trimmed);
+					responses.push(event);
+					if (event.type === "response" && commandIndex < commands.length) {
+						const cmd = commands[commandIndex++];
+						child.stdin.write(`${JSON.stringify(cmd)}\n`);
+					}
+				} catch {
+					responses.push({ _text: trimmed });
+				}
+			}
+		});
+
+		child.stderr.on("data", (data) => {
+			stderr += data.toString();
+		});
+
+		// Send first command after extension loads
+		const readyTimer = setTimeout(() => {
+			if (commandIndex < commands.length) {
+				const cmd = commands[commandIndex++];
+				child.stdin.write(`${JSON.stringify(cmd)}\n`);
+			}
+		}, 3000);
+
+		// Kill after all commands sent + grace period
+		const doneTimer = setTimeout(() => {
+			if (!resolved) {
+				resolved = true;
+				child.kill();
+				resolve({ responses, stderr, timedOut: false });
+			}
+		}, TIMEOUT_MS);
+
+		child.on("close", () => {
+			clearTimeout(readyTimer);
+			clearTimeout(doneTimer);
+			if (!resolved) {
+				resolved = true;
+				resolve({ responses, stderr, timedOut: false });
+			}
+		});
+		child.on("error", (err) => {
+			clearTimeout(readyTimer);
+			clearTimeout(doneTimer);
+			if (!resolved) {
+				resolved = true;
+				reject(err);
+			}
+		});
+	});
+}
+
+// ── Main ─────────────────────────────────────────────────────────────────────
+
+async function main() {
+	console.log("pi-vault-mind /vm commands + BC-2 RPC E2E\n");
+	let piVersion = "";
+
+	try {
+		({ stdout: piVersion } = await new Promise((resolve, reject) => {
+			const child = spawn("pi", ["--version"], { stdio: "pipe" });
+			let out = "";
+			child.stdout.on("data", (d) => (out += d));
+			child.on("close", (code) =>
+				code === 0 ? resolve({ stdout: out }) : reject(new Error(`pi --version exited ${code}`))
+			);
+			child.on("error", reject);
+		}));
+		console.log(`  pi version: ${piVersion.trim()}`);
+	} catch {
+		console.error("  pi binary not found on PATH");
+		process.exit(1);
+	}
+
+	const vaultPath = tmpDir("pvm-e2e-commands");
+	const origHome = process.env.HOME;
+	const searchE2EAvailable = await hasOllamaEmbeddingModel();
+	if (!searchE2EAvailable) {
+		pass("Ollama all-minilm unavailable — skipping search e2e");
+	}
+
+	try {
+		await setupVault(vaultPath, searchE2EAvailable);
+
+		step("Installing pi-vault-mind via pi install");
+		const repoRoot = path.resolve(import.meta.dirname, "..");
+		const piAgentDir = path.join(vaultPath, ".pi", "agent");
+		await new Promise((resolve, reject) => {
+			const child = spawn("pi", ["install", repoRoot], {
+				cwd: vaultPath,
+				env: {
+					...process.env,
+					PI_CODING_AGENT_DIR: piAgentDir,
+					HOME: vaultPath,
+					USERPROFILE: vaultPath,
+				},
+				stdio: "pipe",
+			});
+			let out = "";
+			child.stdout.on("data", (d) => (out += d));
+			child.stderr.on("data", (d) => (out += d));
+			child.on("close", (code) =>
+				code === 0
+					? resolve()
+					: reject(new Error(`pi install exited ${code}: ${out.slice(0, 200)}`))
+			);
+			child.on("error", reject);
+		});
+		pass("pi install succeeded");
+
+		step("Running commands via pi --mode rpc");
+		const commands = [
+			{ type: "prompt", message: "/vm doctor", id: "e2e-1" },
+			...(searchE2EAvailable
+				? [
+						{ type: "prompt", message: "/vm reindex", id: "e2e-reindex" },
+						{ type: "prompt", message: "/vm search test", id: "e2e-search" },
+						{ type: "prompt", message: "/vm search test --mode=fts", id: "e2e-search-fts" },
+					]
+				: []),
+			{ type: "get_fork_messages", id: "e2e-fork" },
+			{ type: "get_tree", id: "e2e-tree" },
+			{ type: "get_entries", id: "e2e-entries" },
+			{ type: "clone", id: "e2e-clone" },
+		];
+		const { responses, stderr, timedOut } = await runPiRpc(vaultPath, commands);
+
+		if (timedOut) fail("pi RPC timed out (60s)");
+
+		step("Verifying responses");
+		const allText = responses.map((r) => JSON.stringify(r)).join(" ");
+
+		if (allText.includes("vault-mind") || allText.includes(".vault-mind"))
+			pass("/vm doctor references vault-mind paths");
+		else {
+			fail("/vm doctor references vault-mind paths");
+			console.log(`  responses: ${allText.slice(0, 200)}`);
+		}
+
+		// BC-2: rewind/fork RPC commands
+		const byId = (id) => responses.find((r) => r.id === id);
+		const byCmd = (cmd) => responses.find((r) => r.command === cmd);
+		const supportsTreeRpc = !piVersion.trim().startsWith("0.79.");
+		const treeResp = byId("e2e-tree") || byCmd("get_tree");
+		if (!supportsTreeRpc) pass("get_tree skipped (pi < 0.80.0 in e2e runtime)");
+		else if (treeResp && treeResp.success !== false) pass("get_tree returns successfully");
+		else {
+			fail("get_tree failed or missing");
+			console.log(`  treeResp: ${JSON.stringify(treeResp).slice(0, 200)}`);
+		}
+
+		const entriesResp = byId("e2e-entries") || byCmd("get_entries");
+		if (!supportsTreeRpc) pass("get_entries skipped (pi < 0.80.0 in e2e runtime)");
+		else if (entriesResp && entriesResp.success !== false) pass("get_entries returns successfully");
+		else {
+			fail("get_entries failed or missing");
+			console.log(`  entriesResp: ${JSON.stringify(entriesResp).slice(0, 200)}`);
+		}
+
+		const cloneResp = byId("e2e-clone") || byCmd("clone");
+		if (!supportsTreeRpc) pass("clone skipped (pi < 0.80.0 in e2e runtime)");
+		else if (cloneResp && cloneResp.success !== false) pass("clone returns successfully");
+		else {
+			fail("clone failed or missing");
+			console.log(`  cloneResp: ${JSON.stringify(cloneResp).slice(0, 200)}`);
+		}
+
+		if (searchE2EAvailable) {
+			// /vm reindex — builds LanceDB index from JSONL with real embeddings
+			const reindexResp = byId("e2e-reindex");
+			if (reindexResp && reindexResp.success !== false) pass("/vm reindex runs successfully");
+			else {
+				fail("/vm reindex failed or missing");
+				console.log(`  reindexResp: ${JSON.stringify(reindexResp).slice(0, 200)}`);
+			}
+
+			// /vm search — verify both slash commands ran and the search notifications
+			// include seeded facts after reindex. The RPC stream can interleave UI
+			// notifications with prompt responses, so assert result content globally.
+			const searchResp = byId("e2e-search");
+			if (searchResp && searchResp.success !== false)
+				pass("/vm search command returns successfully");
+			else {
+				fail("/vm search command failed or missing");
+				console.log(`  searchResp: ${JSON.stringify(searchResp).slice(0, 200)}`);
+			}
+			const searchFtsResp = byId("e2e-search-fts");
+			if (searchFtsResp && searchFtsResp.success !== false)
+				pass("/vm search --mode=fts command returns successfully");
+			else {
+				fail("/vm search --mode=fts command failed or missing");
+				console.log(`  searchFtsResp: ${JSON.stringify(searchFtsResp).slice(0, 200)}`);
+			}
+			const repoRootForSearch = path.resolve(import.meta.dirname, "..");
+			const { searchHybrid, searchFts } = await import(
+				path.join(repoRootForSearch, "dist/src/lance.js")
+			);
+			const { loadConfig } = await import(path.join(repoRootForSearch, "dist/src/utils.js"));
+			const cfg = loadConfig(vaultPath);
+			const dataDir = path.resolve(vaultPath, cfg.vaultMind.dataDir);
+			const hybridResults = JSON.stringify(
+				await searchHybrid(dataDir, "main", "test", 5, cfg.vaultMind)
+			);
+			if (hybridResults.includes("First test entry") || hybridResults.includes("Second test entry"))
+				pass("real hybrid search returns seeded fact data");
+			else {
+				fail("real hybrid search did not return seeded fact data");
+				console.log(`  hybridResults: ${hybridResults.slice(0, 300)}`);
+			}
+			const ftsResults = JSON.stringify(await searchFts(dataDir, "main", "test", 5, cfg.vaultMind));
+			if (ftsResults.includes("First test entry") || ftsResults.includes("Second test entry"))
+				pass("real FTS search returns seeded fact data");
+			else {
+				fail("real FTS search did not return seeded fact data");
+				console.log(`  ftsResults: ${ftsResults.slice(0, 300)}`);
+			}
+		} else {
+			pass("search e2e assertions skipped — Ollama all-minilm unavailable");
+		}
+
+		step("Verifying file side-effects");
+		const cfgPath = path.join(vaultPath, ".vault-mind", "vault-mind.config.json");
+		const collPath = path.join(vaultPath, "collections", "main.jsonl");
+		if (fs.existsSync(cfgPath)) pass("vault-mind.config.json still exists");
+		else fail("vault-mind.config.json still exists");
+		if (fs.existsSync(collPath)) pass("main.jsonl collection still exists");
+		else fail("main.jsonl collection still exists");
+
+		console.log(
+			`\n${failures === 0 ? "\x1b[32mAll passed\x1b[0m" : `\x1b[31m${failures} failed\x1b[0m`}`
+		);
+		if (stderr && !stderr.includes("ExperimentalWarning"))
+			console.log(`\nstderr:\n${stderr.slice(0, 500)}`);
+	} finally {
+		process.env.HOME = origHome;
+		try {
+			fs.rmSync(vaultPath, { recursive: true, force: true });
+		} catch {
+			/* ignore */
+		}
+	}
+	process.exit(failures > 0 ? 1 : 0);
+}
+
+main().catch((err) => {
+	console.error(err);
+	process.exit(1);
+});

package/scripts/e2e-ws.mjs

@@ -54,8 +54,9 @@ function defaultVaultPath() {
 }
 
 function ensureProjectConfig(vaultPath) {
-	const cfgPath = path.join(vaultPath, "pi-vault-mind.config.json");
+	const cfgPath = path.join(vaultPath, ".vault-mind", "vault-mind.config.json");
 	if (!fs.existsSync(cfgPath)) {
+		fs.mkdirSync(path.dirname(cfgPath), { recursive: true });
 		fs.writeFileSync(
 			cfgPath,
 			JSON.stringify(
@@ -69,7 +70,7 @@ function ensureProjectConfig(vaultPath) {
 						},
 					},
 					injectors: [],
-					wiki: {
+					vaultMind: {
 						dataDir: ".lancedb",
 						embedding: {
 							provider: "modal",

package/scripts/fetch-modal-token.sh

@@ -1,8 +1,8 @@
 #!/usr/bin/env bash
 # Fetch the Modal API token from 1Password and export or persist it.
 # Usage:
-#   ./scripts/fetch-modal-token.sh --export    # prints an export line
-#   ./scripts/fetch-modal-token.sh --write     # writes to ~/.pi/agent/vault-mind.env (default)
+#   ./scripts/fetch-modal-token.sh --export              # prints an export line
+#   ./scripts/fetch-modal-token.sh --write [vault-path]  # writes to <vault>/.vault-mind/vault-mind.env
 #
 # The 1Password item must be titled "pi-vault-mind-auth" with the token in the
 # password field.
@@ -11,7 +11,8 @@ set -euo pipefail
 
 OP_ITEM="pi-vault-mind-auth"
 OP_FIELD="password"
-ENV_DIR="${HOME}/.pi/agent"
+VAULT="${2:-$(pwd)}"
+ENV_DIR="${VAULT}/.vault-mind"
 ENV_FILE="${ENV_DIR}/vault-mind.env"
 
 mode="write"

package/scripts/generate-config-keys-json.mjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+/**
+ * Generates config-keys.json from the canonical TS source.
+ *
+ * Reads src/config-keys.ts and writes JSON to:
+ *   1. config-keys.json (repo root — for reference)
+ *   2. packages/obsidian/src/config-keys.json (for plugin import)
+ *
+ * Run before building the plugin.
+ * Usage: node scripts/generate-config-keys-json.mjs
+ */
+
+import { readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(__dirname, "..");
+
+const src = readFileSync(resolve(repoRoot, "src/config-keys.ts"), "utf-8");
+
+function extractArray(name) {
+	const re = new RegExp(`export const ${name} = \\[([\\s\\S]*?)\\] as const;`, "m");
+	const arrMatch = src.match(re);
+	if (!arrMatch) throw new Error(`Could not find ${name} in src/config-keys.ts`);
+	const items = [];
+	for (const m of arrMatch[1].matchAll(/"([^"]+)"/g)) {
+		items.push(m[1]);
+	}
+	return items;
+}
+
+const embeddingFlatKeys = extractArray("EMBEDDING_FLAT_KEYS");
+const vaultMindConfigKeys = extractArray("VAULT_MIND_CONFIG_KEYS");
+
+const json = `${JSON.stringify({ embeddingFlatKeys, vaultMindConfigKeys }, null, "\t")}\n`;
+
+const rootOut = resolve(repoRoot, "config-keys.json");
+const pluginOut = resolve(repoRoot, "packages/obsidian/src/config-keys.json");
+
+writeFileSync(rootOut, json);
+console.log(`Wrote ${rootOut}`);
+
+writeFileSync(pluginOut, json);
+console.log(`Wrote ${pluginOut}`);

package/scripts/generate-extension-packages-json.mjs

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+/**
+ * Generates extension-packages.json from the canonical TS source.
+ *
+ * Reads src/extension-packages.ts and writes JSON to:
+ *   1. extension-packages.json (repo root — for shell scripts)
+ *   2. packages/obsidian/src/extension-packages.json (for plugin import)
+ *   3. packages/obsidian-ui/src/extension-packages.json (for sandbox import)
+ * Run before building the plugin or running shell scripts.
+ * Usage: node scripts/generate-extension-packages-json.mjs
+ */
+
+import { writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(__dirname, "..");
+
+// Dynamic import of the TS source — Node 20+ with --experimental-strip-types
+// or tsx handles this. We use a simple regex-based extraction as a fallback
+// that works without any loader flags.
+import { readFileSync } from "node:fs";
+
+const src = readFileSync(resolve(repoRoot, "src/extension-packages.ts"), "utf-8");
+
+function extractArray(name) {
+	const re = new RegExp(`export const ${name} = \\[([\\s\\S]*?)\\] as const;`, "m");
+	const arrMatch = src.match(re);
+	if (!arrMatch) throw new Error(`Could not find ${name} in src/extension-packages.ts`);
+	// Parse each quoted string from the array body
+	const items = [];
+	for (const m of arrMatch[1].matchAll(/"([^"]+)"/g)) {
+		items.push(m[1]);
+	}
+	return items;
+}
+
+const required = extractArray("PI_REQUIRED_EXTENSIONS");
+const optional = extractArray("PI_OPTIONAL_EXTENSIONS");
+
+const json = `${JSON.stringify({ required, optional }, null, "\t")}\n`;
+
+const rootOut = resolve(repoRoot, "extension-packages.json");
+const pluginOut = resolve(repoRoot, "packages/obsidian/src/extension-packages.json");
+const sandboxOut = resolve(repoRoot, "packages/obsidian-ui/src/extension-packages.json");
+
+writeFileSync(rootOut, json);
+console.log(`Wrote ${rootOut}`);
+
+writeFileSync(pluginOut, json);
+console.log(`Wrote ${pluginOut}`);
+
+writeFileSync(sandboxOut, json);
+console.log(`Wrote ${sandboxOut}`);

package/scripts/reset-test-vault.sh

@@ -45,8 +45,8 @@ fi
 
 echo ""
 echo "✓ Vault reset complete. State removed:"
-echo "  - .pi/ (extensions, settings, agent config)"
-echo "  - pi-vault-mind.config.json"
+echo "  - .vault-mind/ (config, token, framework agent dir, queue)"
+echo "  - .pi/ (legacy agent dir, if present)"
 echo "  - .lancedb/ (vector index)"
 echo "  - collections/ (JSONL data)"
 echo ""

package/scripts/setup-vault-pi.sh

@@ -1,32 +1,71 @@
 #!/usr/bin/env bash
 # setup-vault-pi.sh — Bootstrap a vault-local pi agent config.
 #
-# Run from the vault root. Creates .pi/agent/ with pi-vault-mind and pi-context
-# installed locally, isolated from your global ~/.pi/agent/.
+# Run from the vault root. Creates .vault-mind/.pi/agent/ with pi-vault-mind,
+# pi-context, pi-model-discovery, and pi-model-router installed locally,
+# isolated from your global ~/.pi/agent/. If the 1Password CLI (op) is
+# detected, also installs pi-1password so .vault-mind/.env.1pass (op://
+# references) resolves at pi startup.
 #
 # Usage:
 #   cd /path/to/vault
 #   bash scripts/setup-vault-pi.sh
 #
 # After setup, start pi with:
-#   PI_CODING_AGENT_DIR="$(pwd)/.pi/agent" pi
+#   PI_CODING_AGENT_DIR="$(pwd)/.vault-mind/.pi/agent" pi
 
 set -euo pipefail
 
 VAULT_ROOT="${1:-$(pwd)}"
-PI_DIR="${VAULT_ROOT}/.pi/agent"
+PI_DIR="${VAULT_ROOT}/.vault-mind/.pi/agent"
 
 echo "==> Setting up vault-local pi config at ${PI_DIR}"
 
 mkdir -p "${PI_DIR}"
 
-# Install pi-vault-mind and pi-context into the vault-local agent dir
-PI_CODING_AGENT_DIR="${PI_DIR}" pi install npm:pi-vault-mind
-PI_CODING_AGENT_DIR="${PI_DIR}" pi install npm:pi-context
+# Locate the canonical package list (generated from src/extension-packages.ts).
+# The JSON ships next to the scripts/ directory in the npm package.
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PKGS_JSON="${SCRIPT_DIR}/../extension-packages.json"
+
+if ! command -v jq >/dev/null 2>&1; then
+	echo "ERROR: jq is required to parse extension-packages.json. Install it: brew install jq"
+	exit 1
+fi
+
+# Install required pi extensions from the canonical list.
+echo "==> Installing required pi extensions..."
+for pkg in $(jq -r '.required[]' "${PKGS_JSON}"); do
+	echo "    ${pkg}"
+	PI_CODING_AGENT_DIR="${PI_DIR}" pi install "${pkg}"
+done
+
+# --op-env is a flag registered by pi-1password; only install optional
+# extensions when their prerequisites are met.
+OP_ENV_HINT=""
+for pkg in $(jq -r '.optional[]' "${PKGS_JSON}"); do
+	case "${pkg}" in
+		npm:pi-1password)
+			if command -v op >/dev/null 2>&1; then
+				echo "==> 1Password CLI detected — installing ${pkg}"
+				PI_CODING_AGENT_DIR="${PI_DIR}" pi install "${pkg}"
+				OP_ENV_HINT=" --op-env .vault-mind/.env.1pass"
+			fi
+			;;
+		*)
+			echo "==> Installing optional extension: ${pkg}"
+			PI_CODING_AGENT_DIR="${PI_DIR}" pi install "${pkg}"
+			;;
+	esac
+done
 
 echo ""
 echo "==> Done. Start pi for this vault with:"
-echo "    PI_CODING_AGENT_DIR=\"${PI_DIR}\" pi"
+echo "    PI_CODING_AGENT_DIR=\"${PI_DIR}\" pi${OP_ENV_HINT}"
 echo ""
 echo "    Or from Obsidian Shell Commands:"
-echo "    PI_CODING_AGENT_DIR=${PI_DIR} pi"
+echo "    PI_CODING_AGENT_DIR=${PI_DIR} pi${OP_ENV_HINT}"
+echo ""
+echo "    Then inside the pi session, run /vm setup — it scaffolds"
+echo "    .vault-mind/vault-mind.config.json AND .vault-mind/.pi/model-router.json"
+echo "    (tuned primary/fallback model defaults) in one step."

package/scripts/test-slash-commands.mjs

@@ -19,10 +19,10 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import {
-	DefaultResourceLoader,
-	SessionManager,
 	createAgentSession,
+	DefaultResourceLoader,
 	getAgentDir,
+	SessionManager,
 } from "@earendil-works/pi-coding-agent";
 
 const VAULT_PATH = "/Users/kylebrodeur/workspace/recycvape/ReturnVape";