pi-vault-mind 0.8.4 → 0.8.7

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/index.js

@@ -13,8 +13,7 @@ import { registerIntakeTool } from "./intake.js";
 import { startServer, stopServer } from "./server.js";
 import { clearEngineStatus, clearWatcherStatus, registerStatusCapture, setEngineStatus, } from "./status.js";
 import { registerTools } from "./tools.js";
-import { EXT_ROOT } from "./utils.js";
-import { loadConfig } from "./utils.js";
+import { EXT_ROOT, loadConfig } from "./utils.js";
 import { registerVaultTools } from "./vault-tools.js";
 import { registerAllExtensionTools } from "./vm-handlers.js";
 import { startWatcher, stopWatcher, subscribeJobCompleted } from "./watcher.js";
@@ -80,27 +79,31 @@ export default function (pi) {
         pi.on("turn_end", async (event, ctx) => {
             return handleTurnEnd(pi, event, ctx);
         });
-        /* watcher: auto-start if vaults configured */
+        /* watcher and server: auto-start only for vaults with autoStart: true */
         try {
             const cfg = loadConfig(process.cwd());
-            serverState.port = cfg.vaultMind.httpPort || 11435;
-            startServer(pi, serverState, watcherState);
-            if (cfg.vaultMind.vaults && Object.keys(cfg.vaultMind.vaults).length > 0) {
+            const vaults = cfg.vaultMind.vaults;
+            const autoVaults = vaults
+                ? Object.entries(vaults).filter(([, v]) => v.autoStart === true)
+                : [];
+            if (autoVaults.length > 0) {
+                serverState.port = cfg.vaultMind.httpPort || 11435;
+                startServer(pi, serverState, watcherState);
+                const autoVaultMap = {};
+                for (const [name, v] of autoVaults)
+                    autoVaultMap[name] = v;
                 setTimeout(() => {
-                    console.log("[pi-vault-mind] Auto-starting watcher for", Object.keys(cfg.vaultMind.vaults).length, "vault(s)");
-                    const vaults = cfg.vaultMind.vaults;
-                    if (vaults)
-                        startWatcher(pi, vaults, watcherState);
+                    console.log("[pi-vault-mind] Auto-starting watcher for", autoVaults.length, "vault(s)");
+                    startWatcher(pi, autoVaultMap, watcherState);
                 }, 2000);
             }
-            /* auto-sync: off by default; only starts when modal.sync.autoSync is true */
             if (cfg.vaultMind.embedding.remoteUrl && cfg.vaultMind.embedding.modal?.sync?.autoSync) {
                 stopAutoSync = startAutoSync(cfg.vaultMind.embedding.modal?.sync?.autoSyncIntervalMs ?? 300000);
                 console.log(`[pi-vault-mind] Modal auto-sync enabled (every ${cfg.vaultMind.embedding.modal?.sync?.autoSyncIntervalMs ?? 300000}ms)`);
             }
         }
         catch {
-            /* config may not exist yet; user can start watcher manually via /vm watcher start */
+            /* config may not exist yet */
         }
         /* session_shutdown: stop the watcher, server, and engine */
         pi.on("session_shutdown", async () => {

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,5 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+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

@@ -2,6 +2,15 @@ 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";
+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 +93,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 +102,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 +121,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)
@@ -152,7 +166,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;
@@ -168,28 +187,69 @@ export const setupWizard = async (ctx, cliArgs) => {
         }
     }
     // ── 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 +261,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 +271,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 +298,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 +430,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 +543,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.d.ts

@@ -153,6 +153,8 @@ export interface GraphConfig {
 }
 export interface VaultConfig {
     path: string;
+    /** When true, auto-start the watcher and HTTP server on session_start. Default false. */
+    autoStart?: boolean;
     autoSync?: boolean;
     autoSyncTags?: string[];
     autoSyncMinLength?: number;

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,71 @@
+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 { detectVaultFromCwd, 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 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,87 +1,89 @@
 {
-	"name": "pi-vault-mind",
-	"version": "0.8.4",
-	"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",
-	"type": "module",
-	"files": ["dist", "agents", "skills", "scripts", "CHANGELOG.md", "README.md", "LICENSE"],
-	"keywords": [
-		"pi-package",
-		"pi-extension",
-		"pi-skills",
-		"vault-mind",
-		"jsonl",
-		"lance",
-		"lancedb",
-		"search",
-		"knowledge-base",
-		"agent-tools",
-		"hitl",
-		"semantic-search",
-		"obsidian",
-		"obsidian-vault",
-		"subagent",
-		"subagents",
-		"passive",
-		"file-watcher",
-		"graph",
-		"knowledge-graph",
-		"notebooklm",
-		"pkm"
-	],
-	"author": "Kyle Brodeur",
-	"license": "MIT",
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/kylebrodeur/pi-vault-mind.git"
-	},
-	"bugs": {
-		"url": "https://github.com/kylebrodeur/pi-vault-mind/issues"
-	},
-	"homepage": "https://github.com/kylebrodeur/pi-vault-mind#readme",
-	"engines": {
-		"node": ">=20.6.0"
-	},
-	"pi": {
-		"extensions": ["./dist/index.js"],
-		"skills": ["./skills"]
-	},
-	"scripts": {
-		"prepare": "husky",
-		"check": "biome check --write . && tsc --noEmit",
-		"build": "tsc && tsc -p tsconfig.test.json",
-		"dev": "tsc --watch",
-		"test": "node --test dist/test/*.test.js",
-		"e2e:ws": "node scripts/e2e-ws.mjs",
-		"e2e:modal": "node scripts/modal-e2e-smoke.mjs"
-	},
-	"dependencies": {
-		"@lancedb/lancedb": "latest",
-		"@xenova/transformers": "latest",
-		"apache-arrow": "^21.1.0",
-		"ws": "^8.21.0"
-	},
-	"peerDependencies": {
-		"@earendil-works/pi-coding-agent": ">=0.75.0 <1.0.0"
-	},
-	"devDependencies": {
-		"@biomejs/biome": "^1.9.0",
-		"@earendil-works/pi-coding-agent": "^0.79.0",
-		"@earendil-works/pi-tui": "^0.79.0",
-		"@types/node": "^20.0.0",
-		"@types/ws": "^8.18.1",
-		"husky": "^9.1.6",
-		"typebox": "^1.1.0",
-		"typescript": "^5.0.0"
-	},
-	"pnpm": {
-		"overrides": {
-			"fast-xml-parser": ">=5.7.0",
-			"brace-expansion": ">=5.0.6",
-			"ws@>=8": ">=8.20.1",
-			"protobufjs": ">=8.0.0",
-			"undici": "7.28.0"
-		}
-	}
-}
+  "name": "pi-vault-mind",
+  "version": "0.8.7",
+  "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",
+  "type": "module",
+  "files": [
+    "dist",
+    "agents",
+    "skills",
+    "scripts",
+    "CHANGELOG.md",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "pi-skills",
+    "vault-mind",
+    "jsonl",
+    "lance",
+    "lancedb",
+    "search",
+    "knowledge-base",
+    "agent-tools",
+    "hitl",
+    "semantic-search",
+    "obsidian",
+    "obsidian-vault",
+    "subagent",
+    "subagents",
+    "passive",
+    "file-watcher",
+    "graph",
+    "knowledge-graph",
+    "notebooklm",
+    "pkm"
+  ],
+  "author": "Kyle Brodeur",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kylebrodeur/pi-vault-mind.git"
+  },
+  "bugs": {
+    "url": "https://github.com/kylebrodeur/pi-vault-mind/issues"
+  },
+  "homepage": "https://github.com/kylebrodeur/pi-vault-mind#readme",
+  "engines": {
+    "node": ">=20.6.0"
+  },
+  "pi": {
+    "extensions": [
+      "./dist/index.js"
+    ],
+    "skills": [
+      "./skills"
+    ]
+  },
+  "dependencies": {
+    "@lancedb/lancedb": "latest",
+    "@xenova/transformers": "latest",
+    "apache-arrow": "^21.1.0",
+    "ws": "^8.21.0"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": ">=0.75.0 <1.0.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.0",
+    "@earendil-works/pi-coding-agent": "^0.79.0",
+    "@earendil-works/pi-tui": "^0.79.0",
+    "@types/node": "^20.0.0",
+    "@types/ws": "^8.18.1",
+    "husky": "^9.1.6",
+    "typebox": "^1.1.0",
+    "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "check": "biome check --write . && tsc --noEmit",
+    "build": "tsc && tsc -p tsconfig.test.json",
+    "dev": "tsc --watch",
+    "test": "node --test dist/test/*.test.js",
+    "e2e:ws": "node scripts/e2e-ws.mjs",
+    "e2e:modal": "node scripts/modal-e2e-smoke.mjs"
+  }
+}

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