pi-vault-mind 0.8.5 → 0.8.8

package/README.md

@@ -84,8 +84,8 @@ obsidian plugin:install id=obsidian-git enable
 obsidian plugin:install id=obsidian-breadcrumbs enable
 obsidian plugin:install id=graph-analysis enable
 obsidian plugin:install id=actions-uri enable
-obsidian plugin:install id=shellcommands enable
-```
+obsidian plugin:install id=obsidian42-brat enable
+obsidian plugin:install id=obsidian-pi-vault-mind enable
 
 Full walkthrough: see [`docs/integrations/OBSIDIAN_SETUP.md`](docs/integrations/OBSIDIAN_SETUP.md).
 
@@ -97,7 +97,7 @@ Full walkthrough: see [`docs/integrations/OBSIDIAN_SETUP.md`](docs/integrations/
 | **Breadcrumbs** | `obsidian-breadcrumbs` | Parses typed edges (`agent:related-to`, `agent:derived-from`) in YAML frontmatter. The recommended way to display the agent-extracted knowledge graph in Obsidian's UI. | Highly recommended |
 | **Graph Analysis** | `graph-analysis` | Co-citation discovery, Jaccard similarity on the native Obsidian graph. Surfaces "always cited together but not yet linked" notes — a key agent discovery signal. | Highly recommended |
 | **Actions URI** | `actions-uri` | `x-callback-url` endpoints so the Manager agent can trigger Obsidian UI commands (open notes, run commands) from pi. | Recommended |
-| **obsidian-shellcommands** | `shellcommands` | Bridge from Obsidian events (e.g., file save) to pi agent workflows. Configure a `curl` to `http://127.0.0.1:11435/vault-mind/scan` on file save. | Recommended |
+| **Vault Mind plugin** | `obsidian-pi-vault-mind` | Native setup/status/chat UI and HTTP bridge integration. | Recommended |
 
 ### Recommended: `notesmd-cli` (headless alternative)
 

package/dist/src/commands.js

@@ -52,10 +52,11 @@ const VM_USAGE = [
     "  /vm watcher cancel <id>    Cancel a pending agent job",
     "  /vm server status          Show HTTP server status + port",
     "  /vm personalize            Analyze vault and suggest personality tuning for system.md + AGENTS.md",
-    "  /vm setup                  Interactive global config wizard",
+    "  /vm setup                  Onboarding flow: config + personalize (auto-uses cwd when it's a vault)",
     "  /vm setup --vault <path>   CLI: set vault path",
     "  /vm setup --remoteUrl <url> CLI: set remote embedding URL",
     "  /vm setup --localUrl <url> CLI: set local embedding URL",
+    "  /vm setup --workspace <slug> CLI: derive Modal URL + set workspace",
     "  /vm token                  Show API token source and masked value",
     "  /vm token show             Show API token source and masked value",
     "  /vm token rotate           Generate + persist a new API token (old token invalidated)",
@@ -237,9 +238,6 @@ const handleInit = async (_args, ctx, pi) => {
             ],
             vaultMind: {
                 dataDir: ".lancedb",
-                embedding: {
-                    model: "embeddinggemma",
-                },
                 ftsEnabled: true,
                 graph: { enabled: true, canvasSync: false },
             },
@@ -289,22 +287,21 @@ const handleInit = async (_args, ctx, pi) => {
     msg.push("", '💡 Tip: Tell the agent "Remember: [fact]" to auto-append to the main collection!');
     if (ctx.hasUI) {
         ctx.ui.notify(msg.join("\n"), "info");
-        if (hasPiContextTools(pi)) {
-            const enable = await ctx.ui.confirm("Enable pi-context integration?", "pi-context tools were detected. Would you like to enable the integration now to capture session context?");
-            if (enable) {
-                const existing = JSON.parse(fs.readFileSync(cfgDest, "utf-8"));
-                existing.extensionCompatibility = existing.extensionCompatibility || {};
-                existing.extensionCompatibility["pi-context"] = {
-                    tagPatterns: [],
-                    enhanceInjectors: false,
-                    autoEnableAcm: true,
-                    indexContextEvents: true,
-                    ...existing.extensionCompatibility["pi-context"],
-                    enabled: true,
-                };
-                fs.writeFileSync(cfgDest, `${JSON.stringify(existing, null, 2)}\n`, "utf-8");
-                ctx.ui.notify("✅ pi-context integration ENABLED in config", "info");
-            }
+    }
+    if (hasPiContextTools(pi)) {
+        const existing = JSON.parse(fs.readFileSync(cfgDest, "utf-8"));
+        existing.extensionCompatibility = existing.extensionCompatibility || {};
+        existing.extensionCompatibility["pi-context"] = {
+            tagPatterns: [],
+            enhanceInjectors: false,
+            autoEnableAcm: true,
+            indexContextEvents: true,
+            ...existing.extensionCompatibility["pi-context"],
+            enabled: true,
+        };
+        fs.writeFileSync(cfgDest, `${JSON.stringify(existing, null, 2)}\n`, "utf-8");
+        if (ctx.hasUI) {
+            ctx.ui.notify("✅ pi-context automation enabled (auto-ACM + event indexing)", "info");
         }
     }
 };
@@ -1360,7 +1357,7 @@ const handleWatcher = async (args, ctx, pi) => {
     }
 };
 // ── Setup ────────────────────────────────────────────────────────────────────
-const handleSetup = async (args, ctx) => {
+const handleSetup = async (args, ctx, pi) => {
     // Parse optional CLI-style args: --vault <path> --remoteUrl <url> --localUrl <url> --model <name> --workspace <name>
     const cliArgs = {};
     const parts = args.trim().split(/\s+--/);
@@ -1382,7 +1379,13 @@ const handleSetup = async (args, ctx) => {
     }
     const hasCliArgs = cliArgs.vault || cliArgs.remoteUrl || cliArgs.localUrl || cliArgs.model || cliArgs.workspace;
     await setupWizard(ctx, hasCliArgs ? cliArgs : undefined);
-    ctx.ui.notify("Vault is configured. Run /vm personalize to tune the agent personality for this vault.", "info");
+    if (ctx.hasUI) {
+        ctx.ui.notify("Vault configured. Running personalization as part of onboarding...", "info");
+        await runPersonalize(ctx, pi);
+    }
+    else {
+        ctx.ui.notify("Vault is configured. Run /vm personalize in a TUI session to tune agent personality.", "info");
+    }
 };
 // ── /vm intake ─────────────────────────────────────────────────────────────
 const handleIntake = async (args, ctx) => {
@@ -1671,7 +1674,7 @@ export const registerCommands = (pi) => {
                 case "personalize":
                     return runPersonalize(ctx, pi);
                 case "setup":
-                    return handleSetup(rest, ctx);
+                    return handleSetup(rest, ctx, pi);
                 case "token":
                     return handleToken(rest, ctx);
                 default:

package/dist/src/events.js

@@ -51,12 +51,8 @@ export const handleBeforeAgentStart = async (pi, event, ctx) => {
     }
     // 2. pi-context integration: auto-ACM and tag-based triggers
     const piContextCfg = getPiContextConfig(cfg);
-    if (!piContextCfg.enabled) {
-        // pi-context explicitly disabled — nothing to do
-    }
-    else if (!hasPiContextTools(pi)) {
-        // pi-context enabled in config but tools not available — log once per turn_start
-        console.warn("[pi-vault-mind] pi-context enabled but tools not found. Install pi-context extension.");
+    if (!piContextCfg.enabled || !hasPiContextTools(pi)) {
+        // pi-context is disabled or unavailable — skip integration silently.
     }
     else {
         if (piContextCfg.autoEnableAcm) {

package/dist/src/server.d.ts

@@ -11,8 +11,8 @@
  * Binds 127.0.0.1 only — no network exposure. Port defaults to 11435,
  * configurable via vaultMind.httpPort in pi-vault-mind.config.json.
  *
- * Used by the obsidian-shellcommands plugin to notify pi of file saves,
- * replacing fs.watch reliance with explicit push notifications.
+ * Used by the Vault Mind Obsidian plugin and local automation scripts to notify
+ * pi of file saves via explicit push notifications.
  *
  * New Stage-1 routes (auth-gated by `PVM_API_TOKEN`):
  *   GET  /vm/status, POST /vm/init, POST /vm/setup, POST /server/start,

package/dist/src/server.js

@@ -11,8 +11,8 @@
  * Binds 127.0.0.1 only — no network exposure. Port defaults to 11435,
  * configurable via vaultMind.httpPort in pi-vault-mind.config.json.
  *
- * Used by the obsidian-shellcommands plugin to notify pi of file saves,
- * replacing fs.watch reliance with explicit push notifications.
+ * Used by the Vault Mind Obsidian plugin and local automation scripts to notify
+ * pi of file saves via explicit push notifications.
  *
  * New Stage-1 routes (auth-gated by `PVM_API_TOKEN`):
  *   GET  /vm/status, POST /vm/init, POST /vm/setup, POST /server/start,

package/dist/src/settings-ui.d.ts

@@ -1,4 +1,13 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+export interface ObsidianPluginRequirement {
+    id: string;
+    label: string;
+    required: boolean;
+    reason: string;
+}
+export declare const getMissingOnboardingPlugins: (vaultPath: string) => ObsidianPluginRequirement[];
+export declare const buildPluginInstallGuidance: (plugins: ObsidianPluginRequirement[]) => string;
+export declare const detectVaultFromCwd: (cwd: string) => string | null;
 export declare const createCollectionWizard: (ctx: ExtensionContext) => Promise<void>;
 export declare const createInjectorWizard: (ctx: ExtensionContext) => Promise<void>;
 export declare const setupWizard: (ctx: ExtensionContext, cliArgs?: {

package/dist/src/settings-ui.js

@@ -1,7 +1,149 @@
+import { execFileSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { MODAL_TOKEN_ENV, createModalClient, modalUrl, resolveModalToken } from "./modal-config.js";
 import { collectionNames, findConfig, getGlobalConfigPath, loadConfig, shrinkHome, } from "./utils.js";
+const ONBOARDING_PLUGIN_REQUIREMENTS = [
+    {
+        id: "obsidian-pi-vault-mind",
+        label: "Vault Mind plugin",
+        required: true,
+        reason: "native setup/status/chat UI and local bridge controls",
+    },
+    {
+        id: "actions-uri",
+        label: "Actions URI",
+        required: false,
+        reason: "deep-link automation and capture shortcuts",
+    },
+    {
+        id: "obsidian-git",
+        label: "Obsidian Git",
+        required: false,
+        reason: "vault backup and change history safety net",
+    },
+];
+const readEnabledCommunityPlugins = (vaultPath) => {
+    const communityPluginsPath = path.join(vaultPath, ".obsidian", "community-plugins.json");
+    try {
+        const parsed = JSON.parse(fs.readFileSync(communityPluginsPath, "utf-8"));
+        if (!Array.isArray(parsed))
+            return new Set();
+        return new Set(parsed.filter((value) => typeof value === "string"));
+    }
+    catch {
+        return new Set();
+    }
+};
+export const getMissingOnboardingPlugins = (vaultPath) => {
+    const enabled = readEnabledCommunityPlugins(vaultPath);
+    return ONBOARDING_PLUGIN_REQUIREMENTS.filter((plugin) => !enabled.has(plugin.id));
+};
+const hasObsidianCli = () => {
+    try {
+        execFileSync("obsidian", ["help"], {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const formatExecError = (err) => {
+    if (err && typeof err === "object" && "stderr" in err) {
+        const stderr = err.stderr;
+        if (typeof stderr === "string" && stderr.trim())
+            return stderr.trim();
+        if (stderr instanceof Buffer && stderr.length > 0)
+            return stderr.toString("utf-8").trim();
+    }
+    return err instanceof Error ? err.message : String(err);
+};
+const installObsidianPlugin = (pluginId) => {
+    try {
+        execFileSync("obsidian", ["plugin:install", `id=${pluginId}`, "enable"], {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return { ok: true };
+    }
+    catch (err) {
+        return { ok: false, error: formatExecError(err) };
+    }
+};
+export const buildPluginInstallGuidance = (plugins) => {
+    const lines = [
+        "Install missing Obsidian plugins:",
+        "",
+        "CLI (when Obsidian CLI is available):",
+        ...plugins.map((plugin) => `obsidian plugin:install id=${plugin.id} enable`),
+        "",
+        "Deep links (open each URI):",
+        ...plugins.map((plugin) => `obsidian://show-plugin?id=${encodeURIComponent(plugin.id)}`),
+        "",
+        "GUI fallback: Obsidian → Settings → Community plugins → Browse",
+    ];
+    return lines.join("\n");
+};
+const runPluginOnboarding = async (ctx, vaultPath) => {
+    const missingPlugins = getMissingOnboardingPlugins(vaultPath);
+    if (missingPlugins.length === 0) {
+        ctx.ui.notify("Obsidian plugin check: required integration plugins already enabled.", "info");
+        return;
+    }
+    ctx.ui.notify([
+        "Missing Obsidian plugins detected:",
+        ...missingPlugins.map((plugin) => `- ${plugin.label} (${plugin.id})${plugin.required ? " [required]" : " [recommended]"} — ${plugin.reason}`),
+    ].join("\n"), "warning");
+    const cliAvailable = hasObsidianCli();
+    const options = cliAvailable
+        ? [
+            "Install missing plugins now (Obsidian CLI)",
+            "I'll install manually (show commands + URIs)",
+            "Skip plugin setup for now",
+        ]
+        : ["I'll install manually (show commands + URIs)", "Skip plugin setup for now"];
+    const choice = await ctx.ui.select("Obsidian plugin onboarding", options);
+    if (!choice || choice === "Skip plugin setup for now")
+        return;
+    if (choice === "Install missing plugins now (Obsidian CLI)") {
+        const installed = [];
+        const failed = [];
+        for (const plugin of missingPlugins) {
+            const result = installObsidianPlugin(plugin.id);
+            if (result.ok) {
+                installed.push(plugin.id);
+            }
+            else {
+                failed.push({ plugin, error: result.error || "Unknown error" });
+            }
+        }
+        if (installed.length > 0) {
+            ctx.ui.notify([`Installed plugins (${installed.length}):`, ...installed.map((id) => `- ${id}`)].join("\n"), "info");
+        }
+        if (failed.length > 0) {
+            ctx.ui.notify([
+                "Some plugin installs failed:",
+                ...failed.map(({ plugin, error }) => `- ${plugin.id}: ${error}`),
+                "",
+                buildPluginInstallGuidance(failed.map(({ plugin }) => plugin)),
+            ].join("\n"), "warning");
+        }
+        return;
+    }
+    ctx.ui.notify(buildPluginInstallGuidance(missingPlugins), "info");
+};
+export const detectVaultFromCwd = (cwd) => {
+    const obsidianDir = path.join(cwd, ".obsidian");
+    try {
+        return fs.statSync(obsidianDir).isDirectory() ? cwd : null;
+    }
+    catch {
+        return null;
+    }
+};
 export const createCollectionWizard = async (ctx) => {
     const { project: cfgPath } = findConfig(ctx.cwd);
     if (!cfgPath) {
@@ -84,6 +226,7 @@ export const createInjectorWizard = async (ctx) => {
 };
 export const setupWizard = async (ctx, cliArgs) => {
     const existingGlobal = fs.existsSync(getGlobalConfigPath());
+    const detectedVaultPath = detectVaultFromCwd(ctx.cwd);
     // ── Non-interactive / CLI mode ──────────────────────────────────────────
     if (cliArgs && (cliArgs.vault || cliArgs.remoteUrl || cliArgs.localUrl || cliArgs.workspace)) {
         const config = existingGlobal
@@ -92,8 +235,9 @@ export const setupWizard = async (ctx, cliArgs) => {
         config.vaultMind = config.vaultMind || {};
         config.vaultMind.embedding = config.vaultMind.embedding || {};
         config.vaultMind.vaults = config.vaultMind.vaults || {};
-        if (cliArgs.vault) {
-            config.vaultMind.vaults.default = { path: shrinkHome(cliArgs.vault), autoSync: true };
+        const effectiveVaultPath = cliArgs.vault || detectedVaultPath || undefined;
+        if (effectiveVaultPath) {
+            config.vaultMind.vaults.default = { path: shrinkHome(effectiveVaultPath), autoSync: true };
         }
         if (cliArgs.remoteUrl) {
             config.vaultMind.embedding.remoteUrl = cliArgs.remoteUrl;
@@ -110,16 +254,19 @@ export const setupWizard = async (ctx, cliArgs) => {
         if (cliArgs.workspace) {
             config.vaultMind.embedding.modal = config.vaultMind.embedding.modal || {};
             config.vaultMind.embedding.modal.workspace = cliArgs.workspace;
+            if (!cliArgs.remoteUrl) {
+                config.vaultMind.embedding.remoteUrl = modalUrl(cliArgs.workspace);
+            }
         }
         const dir = path.dirname(getGlobalConfigPath());
         if (!fs.existsSync(dir))
             fs.mkdirSync(dir, { recursive: true });
         fs.writeFileSync(getGlobalConfigPath(), `${JSON.stringify(config, null, 2)}\n`, "utf-8");
         const lines = ["✅ Global config written:", `   ${getGlobalConfigPath()}`, ""];
-        if (cliArgs.vault)
-            lines.push(`   Vault: ${cliArgs.vault}`);
-        if (cliArgs.remoteUrl)
-            lines.push(`   Remote URL: ${cliArgs.remoteUrl}`);
+        if (effectiveVaultPath)
+            lines.push(`   Vault: ${effectiveVaultPath}`);
+        if (config.vaultMind.embedding.remoteUrl)
+            lines.push(`   Remote URL: ${config.vaultMind.embedding.remoteUrl}`);
         if (cliArgs.localUrl)
             lines.push(`   Local URL: ${cliArgs.localUrl}`);
         if (cliArgs.model)
@@ -128,6 +275,21 @@ export const setupWizard = async (ctx, cliArgs) => {
             lines.push(`   Dim: ${cliArgs.dim}`);
         if (cliArgs.workspace)
             lines.push(`   Modal workspace: ${cliArgs.workspace}`);
+        if (effectiveVaultPath) {
+            const obsidianDir = path.join(effectiveVaultPath, ".obsidian");
+            if (fs.existsSync(obsidianDir)) {
+                const missingPlugins = getMissingOnboardingPlugins(effectiveVaultPath);
+                if (missingPlugins.length === 0) {
+                    lines.push("", "Obsidian plugin check: required integration plugins already enabled.");
+                }
+                else {
+                    lines.push("", "Missing Obsidian plugins:", ...missingPlugins.map((plugin) => `- ${plugin.label} (${plugin.id})`), "", buildPluginInstallGuidance(missingPlugins));
+                }
+            }
+            else {
+                lines.push("", "Obsidian plugin check skipped: .obsidian/ not found.", "Open the vault in Obsidian once, then re-run /vm setup for plugin guidance.");
+            }
+        }
         ctx.ui.notify(lines.join("\n"), "info");
         return;
     }
@@ -152,7 +314,12 @@ export const setupWizard = async (ctx, cliArgs) => {
         }
     }
     // ── Step 1: Vault path ─────────────────────────────────────────────────
-    const vaultPath = await ctx.ui.input("Obsidian vault path (absolute):", `/home/${process.env.USER || "you"}/Obsidian/`);
+    const autoVaultPath = cliArgs?.vault?.trim() || detectedVaultPath || "";
+    if (autoVaultPath) {
+        ctx.ui.notify(`Using current vault path: ${autoVaultPath}`, "info");
+    }
+    const vaultPath = autoVaultPath ||
+        (await ctx.ui.input("Obsidian vault path (absolute):", `/home/${process.env.USER || "you"}/Obsidian/`));
     if (!vaultPath) {
         ctx.ui.notify("Setup cancelled — vault path is required.", "warning");
         return;
@@ -167,29 +334,72 @@ export const setupWizard = async (ctx, cliArgs) => {
             return;
         }
     }
+    // ── Step 1.5: Obsidian plugin readiness ────────────────────────────────
+    await runPluginOnboarding(ctx, vaultPath);
     // ── Step 2: Embedding config ──────────────────────────────────────────
-    const remoteUrl = await ctx.ui.input("Remote Embedding URL (e.g. https://.../v1, optional):", "");
+    let remoteUrl = await ctx.ui.input("Remote Embedding URL (e.g. https://.../v1, optional):", "");
     const localUrl = await ctx.ui.input("Local Embedding URL (e.g. http://127.0.0.1:11434/v1, optional):", "");
     let useTransformers = false;
+    let guidedModalWorkspace;
     if (!remoteUrl && !localUrl) {
-        const useTF = await ctx.ui.confirm("Use Transformers", "No embedding URLs configured. Use local transformers (all-MiniLM-L6-v2, 384 dims, offline)?");
-        if (!useTF) {
+        const route = await ctx.ui.select("No embedding URL configured", [
+            "Use local transformers (offline)",
+            "Guide me through Modal setup",
+            "Cancel setup",
+        ]);
+        if (!route || route === "Cancel setup") {
             ctx.ui.notify("Setup cancelled — at least one URL or transformers is required.", "warning");
             return;
         }
-        useTransformers = true;
+        if (route === "Use local transformers (offline)") {
+            useTransformers = true;
+        }
+        else {
+            const workspaceSlug = await ctx.ui.input("Modal workspace slug:", "");
+            if (!workspaceSlug) {
+                ctx.ui.notify("Setup cancelled — workspace is required for Modal guidance.", "warning");
+                return;
+            }
+            guidedModalWorkspace = workspaceSlug.trim();
+            remoteUrl = modalUrl(guidedModalWorkspace);
+            ctx.ui.notify([
+                "Modal endpoint discovery:",
+                `- Derived remote URL: ${remoteUrl}`,
+                "- Set token now with one of:",
+                "  /vm remote token",
+                "  ./scripts/fetch-modal-token.sh --write",
+                "- Reference docs:",
+                "  docs/getting-started/NEW_VAULT_WALKTHROUGH.md",
+                "  docs/integrations/MODAL_EMBEDDING.md",
+            ].join("\n"), "info");
+        }
     }
-    const model = await ctx.ui.input("Model name:", "embeddinggemma");
-    if (!model) {
-        ctx.ui.notify("Setup cancelled — model name is required.", "warning");
+    const model = (await ctx.ui.input("Embedding model key (optional):", ""))?.trim();
+    if (model === undefined) {
+        ctx.ui.notify("Setup cancelled.", "warning");
         return;
     }
     const dimStr = await ctx.ui.input("Dimensions (optional):", "");
     const dim = dimStr ? Number.parseInt(dimStr, 10) : undefined;
-    let workspace;
-    if (remoteUrl?.includes("modal.run")) {
+    let workspace = guidedModalWorkspace;
+    if (!workspace && remoteUrl?.includes("modal.run")) {
         workspace = await ctx.ui.input("Modal workspace (optional):", "");
     }
+    // ── Step 3: Deterministic runtime settings ──────────────────────────────
+    const enableContextAutomation = await ctx.ui.confirm("Context automation", "Enable pi-context integration with auto-/acm trigger and event indexing?");
+    const enableAutoStart = await ctx.ui.confirm("Vault auto-start", "Auto-start watcher/server for this vault when pi session starts?");
+    const apply = await ctx.ui.confirm("Apply setup", [
+        `Vault: ${vaultPath}`,
+        `Remote URL: ${remoteUrl || "none"}`,
+        `Local URL: ${localUrl || "none"}`,
+        `Model: ${model || "(auto/server default)"}`,
+        `Context automation: ${enableContextAutomation ? "enabled" : "disabled"}`,
+        `Vault auto-start: ${enableAutoStart ? "enabled" : "disabled"}`,
+    ].join("\n"));
+    if (!apply) {
+        ctx.ui.notify("Setup cancelled — no changes written.", "warning");
+        return;
+    }
     // ── Write config ────────────────────────────────────────────────────────
     const config = existingGlobal
         ? JSON.parse(fs.readFileSync(getGlobalConfigPath(), "utf-8"))
@@ -201,7 +411,8 @@ export const setupWizard = async (ctx, cliArgs) => {
         config.vaultMind.embedding.remoteUrl = remoteUrl;
     if (localUrl)
         config.vaultMind.embedding.localUrl = localUrl;
-    config.vaultMind.embedding.model = model;
+    if (model)
+        config.vaultMind.embedding.model = model;
     if (useTransformers)
         config.vaultMind.embedding.useTransformers = true;
     if (dim)
@@ -210,9 +421,22 @@ export const setupWizard = async (ctx, cliArgs) => {
         config.vaultMind.embedding.modal = config.vaultMind.embedding.modal || {};
         config.vaultMind.embedding.modal.workspace = workspace;
     }
-    config.vaultMind.vaults.default = { path: shrinkHome(vaultPath), autoSync: true };
+    config.vaultMind.vaults.default = {
+        path: shrinkHome(vaultPath),
+        autoSync: true,
+        autoStart: enableAutoStart,
+    };
     config.vaultMind.graph = config.vaultMind.graph || { enabled: true, canvasSync: true };
     config.vaultMind.ftsEnabled = config.vaultMind.ftsEnabled !== false;
+    config.extensionCompatibility = config.extensionCompatibility || {};
+    config.extensionCompatibility["pi-context"] = {
+        tagPatterns: [],
+        enhanceInjectors: false,
+        autoEnableAcm: true,
+        indexContextEvents: true,
+        ...(config.extensionCompatibility["pi-context"] || {}),
+        enabled: enableContextAutomation,
+    };
     const dir = path.dirname(getGlobalConfigPath());
     if (!fs.existsSync(dir))
         fs.mkdirSync(dir, { recursive: true });
@@ -224,10 +448,19 @@ export const setupWizard = async (ctx, cliArgs) => {
         `   Vault: ${vaultPath}`,
         `   Remote: ${remoteUrl || "none"}`,
         `   Local: ${localUrl || "none"}`,
-        `   Model: ${model}`,
+        `   Model: ${model || "(auto/server default)"}`,
+        `   Context automation: ${enableContextAutomation ? "enabled" : "disabled"}`,
+        `   Vault auto-start: ${enableAutoStart ? "enabled" : "disabled"}`,
         "",
         "Next: /vm watcher start  (or restart pi for auto-start)",
     ].join("\n"), "info");
+    if (remoteUrl?.includes("modal.run")) {
+        ctx.ui.notify([
+            "Modal token reminder:",
+            "- /vm remote token",
+            "- ./scripts/fetch-modal-token.sh --write",
+        ].join("\n"), "info");
+    }
 };
 /**
  * Interactive Modal embedding configuration + "Test connection" action.
@@ -347,30 +580,68 @@ export const openSettingsDashboard = async (ctx) => {
     let running = true;
     while (running) {
         const choice = await ctx.ui.select("pi-vault-mind Settings", [
-            "Manage Collections",
-            "Manage Injectors",
-            "Modal Embedding",
-            "Extension Integrations",
+            "Collections (storage + search targets)",
+            "Injectors (regex capture rules)",
+            "Embedding + remote provider",
+            "Context automation (pi-context)",
+            "Config (view active values)",
+            "Obsidian plugin settings (what to configure)",
             "Exit",
         ]);
         if (!choice || choice === "Exit") {
             running = false;
             break;
         }
-        if (choice === "Manage Collections") {
+        if (choice === "Collections (storage + search targets)") {
             await manageCollections(ctx, cfgPath);
         }
-        else if (choice === "Manage Injectors") {
+        else if (choice === "Injectors (regex capture rules)") {
             await manageInjectors(ctx, cfgPath);
         }
-        else if (choice === "Modal Embedding") {
+        else if (choice === "Embedding + remote provider") {
             await configureModalWizard(ctx);
         }
-        else if (choice === "Extension Integrations") {
+        else if (choice === "Context automation (pi-context)") {
             await manageExtensions(ctx, cfgPath);
         }
+        else if (choice === "Config (view active values)") {
+            await showConfigSettings(ctx, cfgPath);
+        }
+        else if (choice === "Obsidian plugin settings (what to configure)") {
+            showObsidianSettingsHelp(ctx);
+        }
     }
 };
+const showConfigSettings = async (ctx, cfgPath) => {
+    const merged = loadConfig(ctx.cwd);
+    const paths = findConfig(ctx.cwd);
+    const lines = [
+        "Config sources:",
+        `- Global: ${paths.global || "(none)"}`,
+        `- Project: ${paths.project || "(none)"}`,
+        "",
+        "Merged runtime config:",
+        JSON.stringify(merged.vaultMind, null, 2),
+    ];
+    ctx.ui.notify(lines.join("\n"), "info");
+    const projectRaw = fs.readFileSync(cfgPath, "utf-8");
+    ctx.ui.notify(["Project config JSON:", projectRaw].join("\n"), "info");
+};
+const showObsidianSettingsHelp = (ctx) => {
+    ctx.ui.notify([
+        "Obsidian plugin settings (Vault Mind):",
+        "- Host / Port",
+        "- Pi binary path",
+        "- Check extension on startup",
+        "- Include editor context",
+        "- Include file picker",
+        "- Include slash commands",
+        "- Folder layout: Inbox / Library / Presentations / Journal",
+        "- API token (Import from dotenv)",
+        "",
+        "Location: Obsidian → Settings → Community plugins → Vault Mind",
+    ].join("\n"), "info");
+};
 const manageCollections = async (ctx, cfgPath) => {
     const existing = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
     const names = Object.keys(existing.collections || {});
@@ -422,22 +693,27 @@ const manageInjectors = async (ctx, cfgPath) => {
 const manageExtensions = async (ctx, cfgPath) => {
     const existing = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
     existing.extensionCompatibility = existing.extensionCompatibility || {};
-    const piCtx = existing.extensionCompatibility["pi-context"] || {};
-    const choice = await ctx.ui.select("pi-context Integration", [
-        `Toggle Enabled (currently ${piCtx.enabled ? "ON" : "OFF"})`,
-        `Toggle Auto-ACM (currently ${piCtx.autoEnableAcm !== false ? "ON" : "OFF"})`,
-        `Toggle Event Indexing (currently ${piCtx.indexContextEvents !== false ? "ON" : "OFF"})`,
+    const piCtx = {
+        enabled: true,
+        autoEnableAcm: true,
+        indexContextEvents: true,
+        ...(existing.extensionCompatibility["pi-context"] || {}),
+    };
+    const choice = await ctx.ui.select("Context automation (pi-context)", [
+        `Toggle integration (currently ${piCtx.enabled ? "ON" : "OFF"})`,
+        `Toggle auto-/acm trigger (currently ${piCtx.autoEnableAcm !== false ? "ON" : "OFF"})`,
+        `Toggle context event indexing (currently ${piCtx.indexContextEvents !== false ? "ON" : "OFF"})`,
         "Back",
     ]);
     if (!choice || choice === "Back")
         return;
-    if (choice.startsWith("Toggle Enabled")) {
+    if (choice.startsWith("Toggle integration")) {
         piCtx.enabled = !piCtx.enabled;
     }
-    else if (choice.startsWith("Toggle Auto-ACM")) {
+    else if (choice.startsWith("Toggle auto-/acm trigger")) {
         piCtx.autoEnableAcm = piCtx.autoEnableAcm === false;
     }
-    else if (choice.startsWith("Toggle Event Indexing")) {
+    else if (choice.startsWith("Toggle context event indexing")) {
         piCtx.indexContextEvents = piCtx.indexContextEvents === false;
     }
     existing.extensionCompatibility["pi-context"] = piCtx;

package/dist/src/types.js

@@ -32,7 +32,6 @@ export const DEFAULT_CONFIG = {
         },
         embedding: {
             useTransformers: true,
-            model: "embeddinggemma",
             localUrl: "http://127.0.0.1:11434",
         },
         graph: {
@@ -45,7 +44,7 @@ export const DEFAULT_CONFIG = {
     },
     extensionCompatibility: {
         "pi-context": {
-            enabled: false,
+            enabled: true,
             tagPatterns: [],
             enhanceInjectors: false,
             autoEnableAcm: true,

package/dist/src/utils.js

@@ -7,7 +7,7 @@ export const CONFIG_FILES = ["pi-vault-mind.config.json", ".pi/vault-mind.config
 export const getGlobalConfigDir = () => path.join(process.env.HOME || process.env.USERPROFILE || "", ".pi", "agent");
 /** Lazy — recomputes HOME each call so tests can override it. */
 export const getGlobalConfigPath = () => path.join(getGlobalConfigDir(), "vault-mind.config.json");
-export const EXT_ROOT = path.join(import.meta.dirname, "..");
+export const EXT_ROOT = path.join(import.meta.dirname, "..", "..");
 /** Expand a leading `~` to the user's home directory. */
 export const expandHome = (p) => {
     if (p.startsWith("~/") || p === "~") {
@@ -123,7 +123,7 @@ export const hasPiContextTools = (pi) => {
 };
 export const isPiContextEnabled = (cfg) => cfg.extensionCompatibility?.["pi-context"]?.enabled === true;
 export const getPiContextConfig = (cfg) => ({
-    enabled: false,
+    enabled: true,
     tagPatterns: [],
     enhanceInjectors: false,
     autoEnableAcm: true,

package/dist/test/index.test.js

@@ -99,7 +99,7 @@ describe("pi-vault-mind", () => {
             assert.equal(types.DEFAULT_CONFIG.version, 2);
             assert.ok(types.DEFAULT_CONFIG.collections, "collections should exist");
             assert.ok(types.DEFAULT_CONFIG.collections.main, "should have main collection");
-            assert.equal(types.DEFAULT_CONFIG.vaultMind.embedding.model, "embeddinggemma");
+            assert.equal(types.DEFAULT_CONFIG.vaultMind.embedding.model, undefined);
         }
         finally {
             process.chdir(cwd);

package/dist/test/settings-ui.test.js

@@ -0,0 +1,91 @@
+import { strict as assert } from "node:assert";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, describe, it } from "node:test";
+import { buildPluginInstallGuidance, detectVaultFromCwd, getMissingOnboardingPlugins, setupWizard, } from "../src/settings-ui.js";
+import { modalUrl } from "../src/modal-config.js";
+import { getGlobalConfigPath } from "../src/utils.js";
+const savedHome = process.env.HOME;
+const mkTmpDir = (prefix) => fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+const makeCtx = (cwd) => ({
+    cwd,
+    hasUI: false,
+    ui: {
+        notify: () => undefined,
+    },
+});
+const expandMaybeHome = (p, home) => p.startsWith("~/") ? path.join(home, p.slice(2)) : p;
+afterEach(() => {
+    if (savedHome === undefined) {
+        Reflect.deleteProperty(process.env, "HOME");
+    }
+    else {
+        process.env.HOME = savedHome;
+    }
+});
+describe("settings-ui vault detection", () => {
+    it("detectVaultFromCwd returns cwd when .obsidian exists", () => {
+        const vault = mkTmpDir("pvm-vault-detect-");
+        fs.mkdirSync(path.join(vault, ".obsidian"), { recursive: true });
+        assert.equal(detectVaultFromCwd(vault), vault);
+        fs.rmSync(vault, { recursive: true, force: true });
+    });
+    it("detectVaultFromCwd returns null when .obsidian missing", () => {
+        const dir = mkTmpDir("pvm-nonvault-detect-");
+        assert.equal(detectVaultFromCwd(dir), null);
+        fs.rmSync(dir, { recursive: true, force: true });
+    });
+});
+describe("setupWizard plugin onboarding helpers", () => {
+    it("reports only missing community plugins", () => {
+        const vault = mkTmpDir("pvm-plugin-check-");
+        const obsidianDir = path.join(vault, ".obsidian");
+        fs.mkdirSync(obsidianDir, { recursive: true });
+        fs.writeFileSync(path.join(obsidianDir, "community-plugins.json"), JSON.stringify(["obsidian-pi-vault-mind"], null, 2), "utf-8");
+        const missing = getMissingOnboardingPlugins(vault).map((plugin) => plugin.id);
+        assert.equal(missing.includes("obsidian-pi-vault-mind"), false);
+        assert.equal(missing.includes("actions-uri"), true);
+        assert.equal(missing.includes("obsidian-git"), true);
+        fs.rmSync(vault, { recursive: true, force: true });
+    });
+    it("builds manual guidance with CLI commands and Obsidian URIs", () => {
+        const vault = mkTmpDir("pvm-plugin-guide-");
+        const guidance = buildPluginInstallGuidance(getMissingOnboardingPlugins(vault));
+        assert.match(guidance, /obsidian plugin:install id=actions-uri enable/);
+        assert.match(guidance, /obsidian:\/\/show-plugin\?id=obsidian-pi-vault-mind/);
+        fs.rmSync(vault, { recursive: true, force: true });
+    });
+});
+describe("setupWizard CLI defaults", () => {
+    it("auto-uses cwd as vault when cwd is an Obsidian vault", async () => {
+        const home = mkTmpDir("pvm-home-");
+        const vault = path.join(home, "Vault");
+        fs.mkdirSync(path.join(vault, ".obsidian"), { recursive: true });
+        process.env.HOME = home;
+        await setupWizard(makeCtx(vault), {
+            remoteUrl: "https://example.com/v1",
+            model: "embeddinggemma",
+        });
+        const cfg = JSON.parse(fs.readFileSync(getGlobalConfigPath(), "utf-8"));
+        const stored = cfg.vaultMind?.vaults?.default?.path;
+        assert.ok(stored, "default vault path should be written");
+        assert.equal(expandMaybeHome(stored, home), vault);
+        assert.equal(cfg.vaultMind?.embedding?.remoteUrl, "https://example.com/v1");
+        fs.rmSync(home, { recursive: true, force: true });
+    });
+    it("derives remoteUrl from workspace in CLI mode", async () => {
+        const home = mkTmpDir("pvm-home-");
+        const vault = path.join(home, "Vault");
+        fs.mkdirSync(path.join(vault, ".obsidian"), { recursive: true });
+        process.env.HOME = home;
+        await setupWizard(makeCtx(vault), {
+            workspace: "acme-workspace",
+            model: "embeddinggemma",
+        });
+        const cfg = JSON.parse(fs.readFileSync(getGlobalConfigPath(), "utf-8"));
+        assert.equal(cfg.vaultMind?.embedding?.modal?.workspace, "acme-workspace");
+        assert.equal(cfg.vaultMind?.embedding?.remoteUrl, modalUrl("acme-workspace"));
+        fs.rmSync(home, { recursive: true, force: true });
+    });
+});

package/package.json

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

package/scripts/setup-vault-pi.sh

@@ -0,0 +1,32 @@
+#!/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/.
+#
+# Usage:
+#   cd /path/to/vault
+#   bash scripts/setup-vault-pi.sh
+#
+# After setup, start pi with:
+#   PI_CODING_AGENT_DIR="$(pwd)/.pi/agent" pi
+
+set -euo pipefail
+
+VAULT_ROOT="${1:-$(pwd)}"
+PI_DIR="${VAULT_ROOT}/.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
+
+echo ""
+echo "==> Done. Start pi for this vault with:"
+echo "    PI_CODING_AGENT_DIR=\"${PI_DIR}\" pi"
+echo ""
+echo "    Or from Obsidian Shell Commands:"
+echo "    PI_CODING_AGENT_DIR=${PI_DIR} pi"

package/scripts/vault-pi.sh

@@ -0,0 +1,50 @@
+#!/usr/bin/env bash
+# vault-pi.sh — Start pi for a vault, ensuring only one instance runs.
+#
+# Usage:
+#   bash scripts/vault-pi.sh /path/to/vault
+#
+# Obsidian Shell Commands integration:
+#   Command: bash /path/to/pi-vault-mind/scripts/vault-pi.sh {{vault_path}}
+#
+# The script:
+#   1. Checks for an existing PID file at <vault>/.pi/agent/daemon.pid
+#   2. If the PID is alive → exits silently (already running)
+#   3. If stale/dead → cleans up and starts fresh
+#   4. Opens a new terminal window with pi using the vault-local config dir
+
+set -euo pipefail
+
+VAULT="${1:?Usage: vault-pi.sh <vault-path>}"
+PI_DIR="${VAULT}/.pi/agent"
+PID_FILE="${PI_DIR}/daemon.pid"
+
+# Ensure the vault-local agent dir exists
+mkdir -p "${PI_DIR}"
+
+# Check for existing process
+if [ -f "${PID_FILE}" ]; then
+	PID=$(cat "${PID_FILE}")
+	if kill -0 "${PID}" 2>/dev/null; then
+		echo "[vault-pi] pi already running for ${VAULT} (PID ${PID})"
+		exit 0
+	fi
+	echo "[vault-pi] Stale PID file (${PID} is dead), cleaning up"
+	rm -f "${PID_FILE}"
+fi
+
+# Start pi in a new terminal window.
+# macOS: open -a Terminal or open -a iTerm
+# The trap writes the PID and cleans up on exit.
+PI_CMD="PI_CODING_AGENT_DIR='${PI_DIR}' pi; rm -f '${PID_FILE}'"
+
+if [ -d "/Applications/iTerm.app" ]; then
+	open -a iTerm --args --detach bash -c "echo \$\$ > '${PID_FILE}'; cd '${VAULT}'; ${PI_CMD}"
+elif [ -d "/Applications/Utilities/Terminal.app" ]; then
+	osascript -e "tell application \"Terminal\" to do script \"echo \$\$ > '${PID_FILE}'; cd '${VAULT}'; ${PI_CMD}\""
+else
+	echo "[vault-pi] No supported terminal found (iTerm or Terminal.app)"
+	exit 1
+fi
+
+echo "[vault-pi] Started pi for ${VAULT}"

package/skills/vault-mind/SKILL.md

@@ -83,15 +83,15 @@ Uses `all-MiniLM-L6-v2` (384 dimensions). Downloads ONNX model on first use.
 ## Obsidian Bridge
 
 pi-vault-mind runs an HTTP server on `http://127.0.0.1:11435` (configurable
-via `vaultMind.httpPort`). The `obsidian-shellcommands` plugin can POST file-save
-events to `/vault-mind/scan` for explicit, reliable file-watching instead of
-relying solely on `fs.watch`.
+via `vaultMind.httpPort`). The Vault Mind plugin (or any local automation)
+can POST file-save events to `/vault-mind/scan` for explicit, reliable
+file-watching instead of relying solely on `fs.watch`.
 
 ```bash
-# Shell command config in Obsidian:
+# Manual local-bridge trigger:
 curl -s -X POST http://127.0.0.1:11435/vault-mind/scan \
   -H "Content-Type: application/json" \
-  -d '{"file":"{{file_path:absolute}}"}'
+  -d '{"file":"/absolute/path/to/note.md"}'
 ```
 
 Endpoints:

package/skills/vault-mind-setup/references/obsidian-cli-and-plugins.md

@@ -73,7 +73,7 @@ obsidian plugin:install id=obsidian-git enable
 obsidian plugin:install id=obsidian-breadcrumbs enable
 obsidian plugin:install id=graph-analysis enable
 obsidian plugin:install id=actions-uri enable
-obsidian plugin:install id=shellcommands enable
+obsidian plugin:install id=obsidian-pi-vault-mind enable
 obsidian plugin:install id=obsidian42-brat enable   # for beta plugins
 
 # Verify

package/skills/vault-mind-setup/references/obsidian-vault-structure.md

@@ -103,4 +103,4 @@ Community plugins to install:
 - `Breadcrumbs` — typed-edge graph
 - `Graph Analysis` — co-citation discovery
 - `Actions URI` — cross-app automation
-- `obsidian-shellcommands` — bridge to pi
+- `Vault Mind plugin` — native setup/status/chat + local bridge trigger