pi-vault-mind 0.7.2 → 0.7.3

package/dist/src/commands.js

@@ -7,7 +7,7 @@ import { DEFAULT_CONFIG } from "./types.js";
 import { CONFIG_FILES, EXT_ROOT, collectionNames, ensureDir, findConfig, getPiContextConfig, hasPiContextTools, loadConfig, } from "./utils.js";
 import { updateActiveCollectionWidget } from "./widget.js";
 import { connect, pullOllamaModel, testOllamaConnection } from "./lance.js";
-import { MODAL_TOKEN_ENV, createModalClient, isModalConfigured } from "./modal-config.js";
+import { MODAL_TOKEN_ENV, createModalClient, isModalConfigured, resolveBaseUrl, resolveModalToken, resolveWorkspace, } from "./modal-config.js";
 import { createServerState } from "./server.js";
 import { createCollectionWizard, createInjectorWizard, openSettingsDashboard, setupWizard, } from "./settings-ui.js";
 import { reindexRemote, syncAll, syncCollection } from "./sync.js";
@@ -649,6 +649,7 @@ const MODAL_CONFIG_USAGE = [
     "**/wiki modal config**",
     "",
     "  /wiki modal config baseUrl <url>        Set the Modal ASGI base URL",
+    "  /wiki modal config workspace <name>     Derive the Modal URL from workspace slug",
     "  /wiki modal config model <name>         Set the canonical embedder (default embeddinggemma)",
     "  /wiki modal config dim <n>              Set output dimension (omit for native)",
     "  /wiki modal config fallback ollama|none  Set offline fallback provider",
@@ -692,15 +693,17 @@ const handleModalConfig = async (args, ctx) => {
     const key = parts[0]?.toLowerCase();
     const modal = cfg.wiki.embedding.modal ?? {};
     if (!key) {
-        const tokenSrc = process.env[MODAL_TOKEN_ENV]
-            ? `env ${MODAL_TOKEN_ENV} ✅`
+        const tokenSrc = resolveModalToken(cfg.wiki)
+            ? "env or ~/.pi/agent/vault-mind.env ✅"
             : modal.apiToken
-                ? "config (set PVM_API_TOKEN env to override)"
-                : "❌ none (set PVM_API_TOKEN env)";
+                ? "config (set PVM_API_TOKEN env/dotenv to override)"
+                : "❌ none (set PVM_API_TOKEN env or ~/.pi/agent/vault-mind.env)";
+        const derivedUrl = resolveBaseUrl(cfg.wiki);
         const lines = [
             "**Modal Config:**",
             "",
-            `  baseUrl: ${modal.baseUrl || "❌ not set"}`,
+            `  workspace: ${resolveWorkspace(cfg.wiki) || "(not set)"}`,
+            `  baseUrl: ${modal.baseUrl || (derivedUrl ? `${derivedUrl} (derived)` : "❌ not set")}`,
             `  model: ${modal.model || "(default embeddinggemma)"}`,
             `  dim: ${modal.dim ?? "(native)"}`,
             `  token: ${tokenSrc}`,
@@ -837,16 +840,18 @@ const handleModal = async (args, ctx, pi) => {
     switch (sub) {
         case "status": {
             const modal = cfg.wiki.embedding.modal;
-            const tokenSrc = process.env[MODAL_TOKEN_ENV]
-                ? `env ${MODAL_TOKEN_ENV} ✅`
+            const tokenSrc = resolveModalToken(cfg.wiki)
+                ? "env or ~/.pi/agent/vault-mind.env ✅"
                 : modal?.apiToken
                     ? "config"
                     : "❌ none";
+            const derivedUrl = resolveBaseUrl(cfg.wiki);
             const lines = [
                 "**Modal Status**",
                 "",
                 `Configured: ${isModalConfigured(cfg.wiki) ? "✅" : "❌"}`,
-                `  baseUrl: ${modal?.baseUrl || "(not set)"}`,
+                `  workspace: ${resolveWorkspace(cfg.wiki) || "(not set)"}`,
+                `  baseUrl: ${modal?.baseUrl || (derivedUrl ? `${derivedUrl} (derived)` : "(not set)")}`,
                 `  model: ${modal?.model || "(default embeddinggemma)"}`,
                 `  dim: ${modal?.dim ?? "(native)"}`,
                 `  token: ${tokenSrc}`,
@@ -928,6 +933,78 @@ const handleModal = async (args, ctx, pi) => {
             }
             return;
         }
+        case "auto": {
+            const cfgPath = findConfig(ctx.cwd).project;
+            if (!cfgPath) {
+                ctx.ui.notify("No project config found. Run /wiki init first.", "error");
+                return;
+            }
+            const workspace = resolveWorkspace(cfg.wiki);
+            if (!workspace && !cfg.wiki.embedding.modal?.baseUrl) {
+                ctx.ui.notify("Modal workspace or baseUrl not configured. Run:\n  /wiki modal config workspace <name>", "error");
+            }
+            const token = resolveModalToken(cfg.wiki);
+            if (!token) {
+                ctx.ui.notify("Modal token not found. Set PVM_API_TOKEN env or write it to ~/.pi/agent/vault-mind.env", "error");
+                return;
+            }
+            ctx.ui.notify("🔄 Auto-configuring Modal...", "info");
+            const client = createModalClient(cfg.wiki);
+            if (!client) {
+                ctx.ui.notify("Could not create Modal client (missing workspace/baseUrl or token).", "error");
+                return;
+            }
+            let health;
+            let models;
+            try {
+                health = await client.health();
+                ctx.ui.notify(`✅ Modal reachable (default model: ${health.default_model})`, "info");
+            }
+            catch (err) {
+                ctx.ui.notify(`❌ Modal health check failed: ${err.message}`, "error");
+                return;
+            }
+            try {
+                models = await client.models();
+            }
+            catch (err) {
+                ctx.ui.notify(`❌ Could not fetch model registry: ${err.message}`, "error");
+                return;
+            }
+            const defaultModel = models.default || health.default_model || "embeddinggemma";
+            const obj = readProjectConfig(cfgPath);
+            const wiki = obj.wiki || {};
+            const emb = wiki.embedding || {};
+            emb.provider = "modal";
+            const modalSec = emb.modal || {};
+            if (workspace)
+                modalSec.workspace = workspace;
+            modalSec.model = defaultModel;
+            if (models.default_dim != null)
+                modalSec.dim = models.default_dim;
+            modalSec.fallback = modalSec.fallback || {
+                enabled: true,
+                provider: "ollama",
+            };
+            modalSec.sync = modalSec.sync || {
+                autoSync: false,
+                autoSyncIntervalMs: 300000,
+            };
+            emb.modal = modalSec;
+            wiki.embedding = emb;
+            obj.wiki = wiki;
+            writeProjectConfig(cfgPath, obj);
+            const lines = [
+                "✅ Modal auto-configured:",
+                `   baseUrl: ${resolveBaseUrl(cfg.wiki)}`,
+                `   model: ${defaultModel}`,
+                `   dim: ${models.default_dim ?? "native"}`,
+                "",
+                "Run /wiki modal status to verify.",
+            ];
+            ctx.ui.notify(lines.join("\n"), "info");
+            return;
+        }
         case "migrate": {
             const newModel = parts[1];
             if (!newModel) {
@@ -1133,7 +1210,7 @@ const handleWatcher = async (args, ctx, pi) => {
 };
 // ── Setup ────────────────────────────────────────────────────────────────────
 const handleSetup = async (args, ctx) => {
-    // Parse optional CLI-style args: --vault <path> --provider <name> --model <name>
+    // Parse optional CLI-style args: --vault <path> --provider <name> --model <name> --workspace <name>
     const cliArgs = {};
     const parts = args.trim().split(/\s+--/);
     for (const part of parts) {
@@ -1147,8 +1224,10 @@ const handleSetup = async (args, ctx) => {
             cliArgs.provider = trimmed.slice(9).trim();
         else if (trimmed.startsWith("model "))
             cliArgs.model = trimmed.slice(6).trim();
+        else if (trimmed.startsWith("workspace "))
+            cliArgs.workspace = trimmed.slice(10).trim();
     }
-    const hasCliArgs = cliArgs.vault || cliArgs.provider || cliArgs.model;
+    const hasCliArgs = cliArgs.vault || cliArgs.provider || cliArgs.model || cliArgs.workspace;
     await setupWizard(ctx, hasCliArgs ? cliArgs : undefined);
 };
 // ── Main /wiki command ───────────────────────────────────────────────────────

package/dist/src/modal-config.d.ts

@@ -12,13 +12,25 @@ import { ModalEmbeddingClient } from "./modal-client.js";
 import type { WikiConfig } from "./types.js";
 /** Env var name for the Modal bearer token (preferred over config). */
 export declare const MODAL_TOKEN_ENV = "PVM_API_TOKEN";
+/** Dotenv-style fallback path for the Modal token. */
+export declare const MODAL_TOKEN_ENV_PATH: string;
+/** Canonical deployed Modal app name. */
+export declare const MODAL_APP_NAME = "pi-vault-mind-embed";
+/** Derive the Modal service URL from a workspace slug and canonical app name. */
+export declare const modalUrl: (workspace: string) => string;
 /**
- * Resolve the Modal API token. `PVM_API_TOKEN` env always wins and is
- * preferred; config `wiki.embedding.modal.apiToken` is a fallback. Never log
- * the resolved token.
+ * Resolve the Modal API token. Resolution order:
+ * 1. `PVM_API_TOKEN` env var
+ * 2. `~/.pi/agent/vault-mind.env`
+ * 3. `wiki.embedding.modal.apiToken` in config
+ * Never log the resolved token.
  */
 export declare const resolveModalToken: (cfg: WikiConfig) => string | undefined;
-/** True when Modal is usable: a base URL and a resolvable token are present. */
+/** Resolve the explicit baseUrl or derive it from workspace. */
+export declare const resolveBaseUrl: (cfg: WikiConfig) => string | undefined;
+/** Resolve the configured workspace slug, if any. */
+export declare const resolveWorkspace: (cfg: WikiConfig) => string | undefined;
+/** True when Modal is usable: a base URL (explicit or derived) and a resolvable token are present. */
 export declare const isModalConfigured: (cfg: WikiConfig) => boolean;
 /**
  * Build a `ModalEmbeddingClient` from config. Returns null when Modal is not

package/dist/src/modal-config.js

@@ -8,29 +8,82 @@
  *
  * No HTTP is reimplemented here — `ModalEmbeddingClient` owns that.
  */
+import * as fs from "node:fs";
+import * as path from "node:path";
 import { ModalEmbeddingClient } from "./modal-client.js";
 /** Env var name for the Modal bearer token (preferred over config). */
 export const MODAL_TOKEN_ENV = "PVM_API_TOKEN";
+/** Dotenv-style fallback path for the Modal token. */
+export const MODAL_TOKEN_ENV_PATH = path.join(process.env.HOME || process.env.USERPROFILE || "", ".pi", "agent", "vault-mind.env");
+/** Canonical deployed Modal app name. */
+export const MODAL_APP_NAME = "pi-vault-mind-embed";
 /**
- * Resolve the Modal API token. `PVM_API_TOKEN` env always wins and is
- * preferred; config `wiki.embedding.modal.apiToken` is a fallback. Never log
- * the resolved token.
+ * Read a dotenv-style file and return a record of KEY=VALUE pairs.
+ * Ignores comments, blank lines, and unquoted values.
  */
-export const resolveModalToken = (cfg) => process.env[MODAL_TOKEN_ENV] || cfg.embedding.modal?.apiToken;
-/** True when Modal is usable: a base URL and a resolvable token are present. */
-export const isModalConfigured = (cfg) => cfg.embedding.provider === "modal" && !!cfg.embedding.modal?.baseUrl && !!resolveModalToken(cfg);
+const readDotEnv = (filePath) => {
+    if (!fs.existsSync(filePath))
+        return {};
+    const out = {};
+    for (const line of fs.readFileSync(filePath, "utf-8").split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const eq = trimmed.indexOf("=");
+        if (eq === -1)
+            continue;
+        const key = trimmed.slice(0, eq).trim();
+        let value = trimmed.slice(eq + 1).trim();
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        out[key] = value;
+    }
+    return out;
+};
+/** Derive the Modal service URL from a workspace slug and canonical app name. */
+export const modalUrl = (workspace) => `https://${workspace}--${MODAL_APP_NAME}-embeddingservice-fastapi-app.modal.run`;
+/**
+ * Resolve the Modal API token. Resolution order:
+ * 1. `PVM_API_TOKEN` env var
+ * 2. `~/.pi/agent/vault-mind.env`
+ * 3. `wiki.embedding.modal.apiToken` in config
+ * Never log the resolved token.
+ */
+export const resolveModalToken = (cfg) => {
+    if (process.env[MODAL_TOKEN_ENV])
+        return process.env[MODAL_TOKEN_ENV];
+    const dotenv = readDotEnv(MODAL_TOKEN_ENV_PATH);
+    if (dotenv[MODAL_TOKEN_ENV])
+        return dotenv[MODAL_TOKEN_ENV];
+    return cfg.embedding.modal?.apiToken;
+};
+/** Resolve the explicit baseUrl or derive it from workspace. */
+export const resolveBaseUrl = (cfg) => {
+    const modal = cfg.embedding.modal;
+    if (modal?.baseUrl)
+        return modal.baseUrl;
+    if (modal?.workspace)
+        return modalUrl(modal.workspace);
+    return undefined;
+};
+/** Resolve the configured workspace slug, if any. */
+export const resolveWorkspace = (cfg) => cfg.embedding.modal?.workspace;
+/** True when Modal is usable: a base URL (explicit or derived) and a resolvable token are present. */
+export const isModalConfigured = (cfg) => cfg.embedding.provider === "modal" && !!resolveBaseUrl(cfg) && !!resolveModalToken(cfg);
 /**
  * Build a `ModalEmbeddingClient` from config. Returns null when Modal is not
  * configured (no base URL / token) so callers can degrade gracefully.
  */
 export const createModalClient = (cfg) => {
-    const modal = cfg.embedding.modal;
-    if (!modal?.baseUrl)
+    const baseUrl = resolveBaseUrl(cfg);
+    if (!baseUrl)
         return null;
     const apiToken = resolveModalToken(cfg);
     if (!apiToken)
         return null;
-    const clientCfg = { baseUrl: modal.baseUrl, apiToken };
+    const clientCfg = { baseUrl, apiToken };
     return new ModalEmbeddingClient(clientCfg);
 };
 /**

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

@@ -5,12 +5,14 @@ export declare const setupWizard: (ctx: ExtensionContext, cliArgs?: {
     vault?: string;
     provider?: string;
     model?: string;
+    workspace?: string;
 }) => Promise<void>;
 /**
  * Interactive Modal embedding configuration + "Test connection" action.
- * Walks base URL, canonical model, dim, offline fallback, and auto-sync
- * (off by default). Token is read from `PVM_API_TOKEN` env (preferred) — not
- * collected here; only an optional config fallback is offered.
+ * Walks workspace/base URL, canonical model, dim, offline fallback, and auto-sync
+ * (off by default). Token is read from `PVM_API_TOKEN` env or
+ * `~/.pi/agent/vault-mind.env` (preferred) — not collected here; only an optional
+ * config fallback is offered.
  */
 export declare const configureModalWizard: (ctx: ExtensionContext) => Promise<void>;
 export declare const openSettingsDashboard: (ctx: ExtensionContext) => Promise<void>;

package/dist/src/settings-ui.js

@@ -1,8 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { testOllamaConnection } from "./lance.js";
-import { MODAL_TOKEN_ENV, createModalClient } from "./modal-config.js";
-import { GLOBAL_CONFIG_PATH, collectionNames, findConfig, loadConfig, } from "./utils.js";
+import { MODAL_TOKEN_ENV, createModalClient, modalUrl, resolveModalToken } from "./modal-config.js";
+import { GLOBAL_CONFIG_PATH, collectionNames, findConfig, loadConfig, shrinkHome, } from "./utils.js";
 export const createCollectionWizard = async (ctx) => {
     const { project: cfgPath } = findConfig(ctx.cwd);
     if (!cfgPath) {
@@ -86,7 +86,7 @@ export const createInjectorWizard = async (ctx) => {
 export const setupWizard = async (ctx, cliArgs) => {
     const existingGlobal = fs.existsSync(GLOBAL_CONFIG_PATH);
     // ── Non-interactive / CLI mode ──────────────────────────────────────────
-    if (cliArgs && (cliArgs.vault || cliArgs.provider)) {
+    if (cliArgs && (cliArgs.vault || cliArgs.provider || cliArgs.workspace)) {
         const config = existingGlobal
             ? JSON.parse(fs.readFileSync(GLOBAL_CONFIG_PATH, "utf-8"))
             : { wiki: { embedding: {}, vaults: {} } };
@@ -94,7 +94,7 @@ export const setupWizard = async (ctx, cliArgs) => {
         config.wiki.embedding = config.wiki.embedding || {};
         config.wiki.vaults = config.wiki.vaults || {};
         if (cliArgs.vault) {
-            config.wiki.vaults.default = { path: cliArgs.vault };
+            config.wiki.vaults.default = { path: shrinkHome(cliArgs.vault), autoSync: true };
         }
         if (cliArgs.provider && ["ollama", "transformers", "modal"].includes(cliArgs.provider)) {
             config.wiki.embedding.provider = cliArgs.provider;
@@ -102,6 +102,10 @@ export const setupWizard = async (ctx, cliArgs) => {
         if (cliArgs.model) {
             config.wiki.embedding.ollamaModel = cliArgs.model;
         }
+        if (cliArgs.workspace) {
+            config.wiki.embedding.modal = config.wiki.embedding.modal || {};
+            config.wiki.embedding.modal.workspace = cliArgs.workspace;
+        }
         const dir = path.dirname(GLOBAL_CONFIG_PATH);
         if (!fs.existsSync(dir))
             fs.mkdirSync(dir, { recursive: true });
@@ -113,6 +117,8 @@ export const setupWizard = async (ctx, cliArgs) => {
             lines.push(`   Embedding: ${cliArgs.provider}`);
         if (cliArgs.model)
             lines.push(`   Model: ${cliArgs.model}`);
+        if (cliArgs.workspace)
+            lines.push(`   Modal workspace: ${cliArgs.workspace}`);
         ctx.ui.notify(lines.join("\n"), "info");
         return;
     }
@@ -163,8 +169,8 @@ export const setupWizard = async (ctx, cliArgs) => {
         return;
     }
     if (provider.startsWith("modal")) {
-        // Delegate to the dedicated Modal wizard (base URL, model, dim, fallback,
-        // auto-sync, test connection) and return — it writes the project config.
+        // Delegate to the dedicated Modal wizard (workspace/baseUrl, model, dim,
+        // fallback, auto-sync, test connection) and return — it writes the project config.
         await configureModalWizard(ctx);
         return;
     }
@@ -193,7 +199,7 @@ export const setupWizard = async (ctx, cliArgs) => {
         config.wiki.embedding.ollamaModel = ollamaModel;
         config.wiki.embedding.ollamaHost = config.wiki.embedding.ollamaHost || "http://127.0.0.1:11434";
     }
-    config.wiki.vaults.default = { path: vaultPath, autoSync: true };
+    config.wiki.vaults.default = { path: shrinkHome(vaultPath), autoSync: true };
     config.wiki.graph = config.wiki.graph || { enabled: true, canvasSync: true };
     config.wiki.ftsEnabled = config.wiki.ftsEnabled !== false;
     const dir = path.dirname(GLOBAL_CONFIG_PATH);
@@ -215,9 +221,10 @@ export const setupWizard = async (ctx, cliArgs) => {
 };
 /**
  * Interactive Modal embedding configuration + "Test connection" action.
- * Walks base URL, canonical model, dim, offline fallback, and auto-sync
- * (off by default). Token is read from `PVM_API_TOKEN` env (preferred) — not
- * collected here; only an optional config fallback is offered.
+ * Walks workspace/base URL, canonical model, dim, offline fallback, and auto-sync
+ * (off by default). Token is read from `PVM_API_TOKEN` env or
+ * `~/.pi/agent/vault-mind.env` (preferred) — not collected here; only an optional
+ * config fallback is offered.
  */
 export const configureModalWizard = async (ctx) => {
     const { project: cfgPath } = findConfig(ctx.cwd);
@@ -231,10 +238,20 @@ export const configureModalWizard = async (ctx) => {
     }
     const cfg = loadConfig(ctx.cwd);
     const modal = cfg.wiki.embedding.modal ?? {};
-    const baseUrl = await ctx.ui.input("Modal base URL (deployed ASGI app):", modal.baseUrl ||
-        "https://<workspace>--pi-vault-mind-embed-embeddingservice-fastapi-app.modal.run");
-    if (!baseUrl)
+    // Prefer workspace input; fall back to full URL if user already has one.
+    const workspace = await ctx.ui.input("Modal workspace slug (blank if you want to enter the full URL):", modal.workspace || "");
+    if (workspace === undefined)
         return;
+    let baseUrl;
+    if (workspace) {
+        baseUrl = modalUrl(workspace);
+    }
+    else {
+        baseUrl = await ctx.ui.input("Modal base URL (deployed ASGI app):", modal.baseUrl ||
+            "https://<workspace>--pi-vault-mind-embed-embeddingservice-fastapi-app.modal.run");
+        if (!baseUrl)
+            return;
+    }
     const model = await ctx.ui.input("Canonical embedder model:", modal.model || "embeddinggemma");
     if (model === undefined)
         return;
@@ -262,6 +279,11 @@ export const configureModalWizard = async (ctx) => {
         const intervalStr = await ctx.ui.input("Auto-sync interval (ms):", "300000");
         intervalMs = Number.parseInt(intervalStr || "300000", 10) || 300000;
     }
+    // Token guidance (env/dotenv preferred; config apiToken is a fallback)
+    const tokenEnv = resolveModalToken(loadConfig(ctx.cwd).wiki);
+    if (!tokenEnv) {
+        ctx.ui.notify(`⚠️  No ${MODAL_TOKEN_ENV} env var or ~/.pi/agent/vault-mind.env found. Set it in your shell:\n  export ${MODAL_TOKEN_ENV}=<bearer token>\nOr write it to ~/.pi/agent/vault-mind.env. (Env/dotenv preferred; config apiToken is a fallback only.)`, "warning");
+    }
     // Persist
     const existing = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
     existing.wiki = existing.wiki || {};
@@ -269,6 +291,7 @@ export const configureModalWizard = async (ctx) => {
     existing.wiki.embedding.provider = "modal";
     existing.wiki.embedding.modal = {
         ...(existing.wiki.embedding.modal || {}),
+        ...(workspace ? { workspace } : {}),
         baseUrl: baseUrl.replace(/\/$/, ""),
         model: model || "embeddinggemma",
         ...(dim != null ? { dim } : {}),
@@ -280,11 +303,6 @@ export const configureModalWizard = async (ctx) => {
         },
     };
     fs.writeFileSync(cfgPath, `${JSON.stringify(existing, null, 2)}\n`, "utf-8");
-    // Token guidance + optional config fallback (env always wins)
-    const tokenEnv = process.env[MODAL_TOKEN_ENV];
-    if (!tokenEnv) {
-        ctx.ui.notify(`⚠️  No ${MODAL_TOKEN_ENV} env var detected. Set it in your shell:\n  export ${MODAL_TOKEN_ENV}=<bearer token>\n(Env is preferred; config apiToken is a fallback only.)`, "warning");
-    }
     // Test connection against /health
     const test = await ctx.ui.confirm("Test connection", "Call /health now to verify the Modal service?");
     if (test) {

package/dist/src/types.d.ts

@@ -24,7 +24,12 @@ export interface InjectorDef {
  */
 export interface ModalEmbeddingConfig {
     /** Base URL of the deployed Modal ASGI app (no trailing slash needed). */
-    baseUrl: string;
+    baseUrl?: string;
+    /**
+     * Modal workspace slug. When set, the extension derives `baseUrl` from the
+     * canonical app name if `baseUrl` itself is not set.
+     */
+    workspace?: string;
     /**
      * Bearer token matching the `pi-vault-mind-auth` Modal secret. Prefer
      * setting via the `PVM_API_TOKEN` env var over committing it to config;

package/dist/src/utils.d.ts

@@ -4,6 +4,10 @@ export declare const CONFIG_FILES: string[];
 export declare const GLOBAL_CONFIG_DIR: string;
 export declare const GLOBAL_CONFIG_PATH: string;
 export declare const EXT_ROOT: string;
+/** Expand a leading `~` to the user's home directory. */
+export declare const expandHome: (p: string) => string;
+/** Store a path as `~/...` when it lives under the user's home directory. */
+export declare const shrinkHome: (p: string) => string;
 export declare const resolvePath: (cwd: string, p: string) => string;
 export declare const ensureDir: (filePath: string) => void;
 export declare const findConfig: (cwd: string) => {

package/dist/src/utils.js

@@ -6,6 +6,22 @@ export const CONFIG_FILES = ["pi-vault-mind.config.json", ".pi/vault-mind.config
 export const GLOBAL_CONFIG_DIR = path.join(process.env.HOME || process.env.USERPROFILE || "", ".pi", "agent");
 export const GLOBAL_CONFIG_PATH = path.join(GLOBAL_CONFIG_DIR, "vault-mind.config.json");
 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 === "~") {
+        const home = process.env.HOME || process.env.USERPROFILE || "";
+        return home ? path.join(home, p.slice(1)) : p;
+    }
+    return p;
+};
+/** Store a path as `~/...` when it lives under the user's home directory. */
+export const shrinkHome = (p) => {
+    const home = process.env.HOME || process.env.USERPROFILE || "";
+    if (home && p.startsWith(home)) {
+        return `~${p.slice(home.length)}`;
+    }
+    return p;
+};
 export const resolvePath = (cwd, p) => path.isAbsolute(p) ? p : path.join(cwd, p);
 export const ensureDir = (filePath) => {
     const dir = path.dirname(filePath);
@@ -38,6 +54,15 @@ const readConfigFile = (p) => {
         return {};
     }
 };
+/** Expand `~` in all vault paths after loading a config layer. */
+const expandVaultPaths = (layer) => {
+    if (!layer.wiki?.vaults)
+        return;
+    for (const vault of Object.values(layer.wiki.vaults)) {
+        if (vault.path)
+            vault.path = expandHome(vault.path);
+    }
+};
 const mergeConfigLayer = (base, layer, cwd) => {
     const rawLayer = layer;
     const merged = {
@@ -80,6 +105,8 @@ export const loadConfig = (cwd) => {
     const paths = findConfig(cwd);
     const globalCfg = readConfigFile(paths.global);
     const projectCfg = readConfigFile(paths.project);
+    expandVaultPaths(globalCfg);
+    expandVaultPaths(projectCfg);
     let merged = mergeConfigLayer(DEFAULT_CONFIG, globalCfg, cwd);
     merged = mergeConfigLayer(merged, projectCfg, cwd);
     return merged;

package/dist/src/watcher.js

@@ -16,6 +16,7 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { expandHome } from "./utils.js";
 // ── Constants ────────────────────────────────────────────────────────────────────
 const MARKER_REGEX = /@agent-(\w+)(?::(\S+))?\s*(.*)/;
 const WRITEBACK_MARKER_REGEX = /<!--\s*pi-dispatch:(\S+)\s*-->/;
@@ -231,7 +232,7 @@ export function startWatcher(pi, vaults, state) {
         return;
     }
     for (const [name, vault] of vaultEntries) {
-        const vaultPath = vault.path;
+        const vaultPath = expandHome(vault.path);
         if (!fs.existsSync(vaultPath)) {
             console.warn(`[pi-vault-mind] Vault "${name}" path does not exist: ${vaultPath}`);
             continue;

package/dist/test/modal-config.test.js

@@ -1,6 +1,6 @@
 import { strict as assert } from "node:assert";
 import { afterEach, beforeEach, describe, it } from "node:test";
-import { MODAL_TOKEN_ENV, createModalClient, isModalConfigured, namespacedTableName, resolveDim, resolveModalToken, resolveModel, } from "../src/modal-config.js";
+import { MODAL_TOKEN_ENV, MODAL_TOKEN_ENV_PATH, createModalClient, isModalConfigured, modalUrl, namespacedTableName, resolveBaseUrl, resolveDim, resolveModalToken, resolveModel, resolveWorkspace, } from "../src/modal-config.js";
 const wiki = (over = {}) => ({
     dataDir: ".lancedb",
     embedding: { provider: "modal" },
@@ -79,6 +79,59 @@ describe("modal-config", () => {
         assert.equal(resolveDim(cfg, "special"), 128);
         assert.equal(resolveDim(wiki()), undefined);
     });
+    it("resolveModalToken: dotenv file is a fallback when env is unset", async () => {
+        delete process.env[MODAL_TOKEN_ENV];
+        const fs = await import("node:fs");
+        const path = await import("node:path");
+        const dir = path.dirname(MODAL_TOKEN_ENV_PATH);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(MODAL_TOKEN_ENV_PATH, 'PVM_API_TOKEN="dotenv-token"\n', "utf-8");
+        try {
+            const cfg = wiki({ embedding: { provider: "modal", modal: { baseUrl: "https://x" } } });
+            assert.equal(resolveModalToken(cfg), "dotenv-token");
+        }
+        finally {
+            fs.rmSync(MODAL_TOKEN_ENV_PATH, { force: true });
+        }
+    });
+    it("modalUrl derives the canonical service URL from workspace", () => {
+        assert.equal(modalUrl("kylebrodeur"), "https://kylebrodeur--pi-vault-mind-embed-embeddingservice-fastapi-app.modal.run");
+    });
+    it("resolveBaseUrl: explicit baseUrl wins over derived workspace URL", () => {
+        const cfg = wiki({
+            embedding: {
+                provider: "modal",
+                modal: {
+                    baseUrl: "https://explicit.example.com",
+                    workspace: "kylebrodeur",
+                },
+            },
+        });
+        assert.equal(resolveBaseUrl(cfg), "https://explicit.example.com");
+    });
+    it("resolveBaseUrl: derives URL from workspace when baseUrl is missing", () => {
+        const cfg = wiki({
+            embedding: { provider: "modal", modal: { workspace: "kylebrodeur" } },
+        });
+        assert.equal(resolveBaseUrl(cfg), modalUrl("kylebrodeur"));
+    });
+    it("resolveWorkspace returns the configured workspace slug", () => {
+        const cfg = wiki({
+            embedding: { provider: "modal", modal: { workspace: "kylebrodeur" } },
+        });
+        assert.equal(resolveWorkspace(cfg), "kylebrodeur");
+        assert.equal(resolveWorkspace(wiki()), undefined);
+    });
+    it("createModalClient: builds a client from workspace-derived URL", () => {
+        process.env[MODAL_TOKEN_ENV] = "tok";
+        const c = createModalClient(wiki({ embedding: { provider: "modal", modal: { workspace: "kylebrodeur" } } }));
+        assert.ok(c);
+    });
+    it("isModalConfigured: true when workspace + token are present (no explicit baseUrl)", () => {
+        process.env[MODAL_TOKEN_ENV] = "tok";
+        assert.equal(isModalConfigured(wiki({ embedding: { provider: "modal", modal: { workspace: "kylebrodeur" } } })), true);
+    });
     it("namespacedTableName mirrors the server's ADR-3 scheme", () => {
         assert.equal(namespacedTableName("main", "embeddinggemma", 768), "col_main__embeddinggemma__768");
         assert.equal(namespacedTableName("ctx", "minilm-l6", 384), "col_ctx__minilm-l6__384");

package/package.json

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