pi-vault-mind 0.14.2 → 0.16.3

package/dist/src/commands.js

@@ -3,31 +3,34 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { Container, SelectList, Text } from "@earendil-works/pi-tui";
 import * as lancedb from "@lancedb/lancedb";
-import { getActiveCollection, setActiveCollection } from "./state.js";
-import { DEFAULT_CONFIG } from "./types.js";
-import { CONFIG_FILES, EXT_ROOT, collectionNames, ensureDir, findConfig, getPiContextConfig, hasPiContextTools, loadConfig, resolveInitCollectionName, } from "./utils.js";
-import { updateActiveCollectionWidget } from "./widget.js";
-import { cancelJobHelper, listJobs, retryJob, } from "./agent-queue.js";
+import { cancelJobHelper, listJobs, retryJob } from "./agent-queue.js";
 import { revokeToken, rotateToken } from "./auth.js";
+import { EMBEDDING_FLAT_KEYS } from "./config-keys.js";
 import { handleDiscoverSchema } from "./discover-schema.js";
+import { writeEnvEntry } from "./embedding-secrets.js";
+import { queryGraph } from "./graph.js";
 import { runAskIntake } from "./intake.js";
-import { connect, searchHybrid } from "./lance.js";
-import { MODAL_TOKEN_ENV, createModalClient, isModalConfigured, resolveBaseUrl, resolveModalToken, resolveWorkspace, } from "./modal-config.js";
+import { connect, searchFts, searchHybrid, searchHybridRanked } from "./lance.js";
+import { createModalClient, isModalConfigured, MODAL_TOKEN_ENV, modalTokenEnvPath, resolveBaseUrl, resolveModalToken, resolveWorkspace, } from "./modal-config.js";
+import { scaffoldModelRouterConfig } from "./model-router.js";
 import { runPersonalize } from "./personalize.js";
-import { createServerState } from "./server.js";
+import { scaffoldVaultConfig } from "./scaffold.js";
+import { createServerState, startServer } from "./server.js";
 import { createCollectionWizard, createInjectorWizard, openSettingsDashboard, setupWizard, } from "./settings-ui.js";
+import { getActiveCollection, setActiveCollection } from "./state.js";
 import { reindexRemote, syncAll, syncCollection } from "./sync.js";
 import { tombstoneEntryById } from "./tombstone.js";
-import { expandHome } from "./utils.js";
+import { DEFAULT_CONFIG } from "./types.js";
+import { collectionNames, ensureDir, expandHome, findConfig, getConfigPath, getPiContextConfig, hasPiContextTools, isVaultMindReady, loadConfig, resolveVaultMindPaths, } from "./utils.js";
 import { createWatcherState, getWatcherStatus, startWatcher, stopWatcher } from "./watcher.js";
+import { updateActiveCollectionWidget } from "./widget.js";
 // ── Shared helpers ───────────────────────────────────────────────────────────
 const VM_USAGE = [
     "**pi-vault-mind Commands**",
-    "  /vm init [--collection <name>] Scaffold config + collections (default collection path uses vault name)",
     "  /vm validate                Check LanceDB, config, and collection health",
     "  /vm validate --audit         Audit config for missing defaults",
     "  /vm approve [collection]    Batch-review pending entries",
-    "  /vm query <collection> <query>      Hybrid semantic + FTS search",
+    "  /vm search [collection] <query> [--mode=hybrid|semantic|fts|graph|full]  Unified search",
     "  /vm tombstone <collection> <entry-id>  Redact an entry in place",
     "  /vm settings                Open interactive settings dashboard",
     "  /vm collection select       Select active collection",
@@ -51,22 +54,25 @@ const VM_USAGE = [
     "  /vm watcher retry <id>     Retry a failed or cancelled agent job",
     "  /vm watcher cancel <id>    Cancel a pending agent job",
     "  /vm server status          Show HTTP server status + port",
+    "  /vm server start           Start the in-process HTTP server",
     "  /vm personalize            Analyze vault and suggest personality tuning for system.md + AGENTS.md",
     "  /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 setup --remoteApiKey <key> CLI: set remote API key",
+    "  /vm setup --collection <name> CLI: override default collection name (defaults to vault name)",
     "  /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)",
-    "  /vm token revoke \u003cidentity\u003e  Remove PVM_TOKEN_\u003cIDENTITY\u003e from ~/.pi/agent/vault-mind.env",
+    "  /vm token revoke <identity>  Remove PVM_TOKEN_<IDENTITY> from .vault-mind/vault-mind.env",
     "  /vm help                   Show this help",
 ].join("\n");
 export const auditConfig = async (ctx) => {
     const { project: cfgPath } = findConfig(ctx.cwd);
     if (!cfgPath) {
-        ctx.ui.notify("No project config file found to audit. Run /vm init first.", "info");
+        ctx.ui.notify("No project config file found to audit. Run /vm setup first.", "info");
         return;
     }
     const projectCfg = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
@@ -162,44 +168,64 @@ export const selectActiveCollection = async (ctx) => {
         ctx.ui.notify(`Active collection set to: ${result}`, "info");
     }
 };
-// ── /vm init ──────────────────────────────────────────────────────────────
-/**
- * Vault-root `.gitignore` entries that keep pi-vault-mind compatible with
- * `obsidian-git` (and, transitively, Obsidian Sync setups that also back up via
- * git): the LanceDB index is a large, per-device, rebuildable binary and must
- * never be committed; Obsidian's workspace UI state churns constantly. See
- * docs/OBSIDIAN_SETUP.md §6.
- */
-export const GITIGNORE_ENTRIES = [".lancedb/", ".obsidian/workspace*.json"];
-/**
- * Decide what to do with the vault `.gitignore`, given its current contents
- * (`null` if absent). Pure — does no I/O — so it is unit-testable. Creates the
- * file when missing, appends only the entries that aren't already present
- * (line-exact match, trimmed), and skips when everything is covered.
- */
-export const planGitignore = (existing) => {
-    const header = "# pi-vault-mind: keep the rebuildable binary index out of git";
-    if (existing === null) {
-        return {
-            action: "create",
-            content: `${header}\n.lancedb/\n# Obsidian UI workspace state churns constantly\n.obsidian/workspace*.json\n`,
-        };
+// ── /vm doctor ──────────────────────────────────────────────────────────────
+const handleDoctor = (ctx) => {
+    const paths = resolveVaultMindPaths(ctx.cwd);
+    const ready = isVaultMindReady(ctx.cwd);
+    const piAgentDirSet = !!process.env.PI_CODING_AGENT_DIR;
+    const stalePiAgent = fs.existsSync(path.join(ctx.cwd, ".pi", "agent"));
+    const hasGlobalPi = paths.agentDir.startsWith(path.join(process.env.HOME || process.env.USERPROFILE || "", ".pi"));
+    // Count discovered providers/models from models.json
+    let providerCount = 0;
+    let modelCount = 0;
+    if (paths.exists.modelsJson) {
+        try {
+            const modelsJson = JSON.parse(fs.readFileSync(paths.modelsJson, "utf-8"));
+            const providers = modelsJson?.providers ?? {};
+            providerCount = Object.keys(providers).length;
+            for (const p of Object.values(providers)) {
+                modelCount += p.models?.length ?? 0;
+            }
+        }
+        catch {
+            /* ignore parse errors */
+        }
     }
-    // Match leniently: `.lancedb`, `.lancedb/`, and `/.lancedb/` are the same rule,
-    // so we don't append a duplicate when the user already ignores it differently.
-    const normalize = (s) => s.trim().replace(/^\/+|\/+$/g, "");
-    const present = new Set(existing.split(/\r?\n/).map(normalize));
-    const missing = GITIGNORE_ENTRIES.filter((e) => !present.has(normalize(e)));
-    if (missing.length === 0)
-        return { action: "skip", content: "" };
-    const prefix = existing.length === 0 ? "" : existing.endsWith("\n") ? "\n" : "\n\n";
-    return { action: "append", content: `${prefix}# pi-vault-mind\n${missing.join("\n")}\n` };
+    const lines = [
+        "**Vault Mind Doctor**",
+        "",
+        `Vault: ${paths.vaultPath}`,
+        `Agent dir: ${paths.agentDir}`,
+        `Vault-mind dir: ${paths.vaultMindDir}`,
+        "",
+        "── Paths ──",
+        `Config: ${paths.config} ${paths.exists.config ? "✅" : "❌ missing"}`,
+        `Token env: ${paths.tokenEnv} ${paths.exists.tokenEnv ? "✅" : "❌ missing"}`,
+        `Queue: ${paths.queue}`,
+        `Server state: ${paths.serverState}`,
+        `Manual dispatch: ${paths.manualDispatch}`,
+        `Canvas: ${paths.canvasPath}`,
+        `Capture note: ${paths.captureNote ?? "(not configured)"}`,
+        "",
+        "── Framework ──",
+        `models.json: ${paths.modelsJson} ${paths.exists.modelsJson ? `✅ (${providerCount} provider(s), ${modelCount} model(s))` : "❌ missing"}`,
+        `model-router.json: ${paths.modelRouter} ${paths.exists.modelRouter ? "✅" : "❌ missing"}`,
+        "",
+        "── Status ──",
+        `Ready: ${ready ? "✅ yes" : "❌ no (config missing or embedding not configured)"}`,
+        `PI_CODING_AGENT_DIR: ${piAgentDirSet ? "✅ set" : "⚠️  not set"}`,
+        `Stale <vault>/.pi/agent: ${stalePiAgent ? "⚠️  exists (may be legacy)" : "✅ absent"}`,
+        "",
+        "── Auth ──",
+        "Provider auth is managed by pi (`pi` login). No new auth machinery here.",
+        "",
+        hasGlobalPi
+            ? "⚠️  WARN: agentDir resolves under ~/.pi (global pi). Vault isolation may be incomplete."
+            : "✅ PASS: all paths are vault-local (no ~/.pi dependency).",
+    ];
+    ctx.ui.notify(lines.join("\n"), ready ? "info" : "warning");
 };
 const handleInit = async (_args, ctx, pi) => {
-    const cfg = loadConfig(ctx.cwd);
-    const created = [];
-    const updated = [];
-    const skipped = [];
     const initTokens = _args.trim().split(/\s+/).filter(Boolean);
     let requestedCollection;
     for (let i = 0; i < initTokens.length; i++) {
@@ -208,79 +234,7 @@ const handleInit = async (_args, ctx, pi) => {
             i++;
         }
     }
-    const initCollection = resolveInitCollectionName(ctx.cwd, requestedCollection);
-    const ensureFile = (dest, tmpl) => {
-        if (fs.existsSync(dest)) {
-            skipped.push(dest);
-            return;
-        }
-        ensureDir(dest);
-        const src = path.join(EXT_ROOT, "templates", tmpl);
-        fs.writeFileSync(dest, fs.existsSync(src) ? fs.readFileSync(src) : "", "utf-8");
-        created.push(dest);
-    };
-    const cfgDest = path.join(ctx.cwd, CONFIG_FILES[0]);
-    if (!fs.existsSync(cfgDest)) {
-        const tmpl = {
-            version: 2,
-            collections: {
-                main: {
-                    path: `collections/${initCollection}.jsonl`,
-                    schema: ["id", "domain", "source", "fact", "tag", "artifact"],
-                    dedupField: "fact",
-                },
-                pending: { path: "collections/pending.jsonl", schema: "main" },
-                context_events: {
-                    path: "collections/context_events.jsonl",
-                    schema: ["id", "type", "session_entry_id", "content", "timestamp", "tags"],
-                    dedupField: "id",
-                },
-            },
-            injectors: [
-                {
-                    name: "draft-context",
-                    regex: "draft\\s+(\\S+)",
-                    collection: "main",
-                    filterField: "tag",
-                    artifactPath: "collections/artifact.md",
-                },
-            ],
-            vaultMind: {
-                dataDir: ".lancedb",
-                ftsEnabled: true,
-                graph: { enabled: true, canvasSync: false },
-            },
-        };
-        fs.writeFileSync(cfgDest, `${JSON.stringify(tmpl, null, 2)}\n`, "utf-8");
-        created.push(cfgDest);
-    }
-    else {
-        skipped.push(cfgDest);
-    }
-    // Reload the config we just wrote so we scaffold the collections it defines.
-    const effectiveCfg = fs.existsSync(cfgDest) ? loadConfig(ctx.cwd) : cfg;
-    for (const [name, def] of Object.entries(effectiveCfg.collections)) {
-        ensureFile(def.path, name === "pending" ? "PENDING_LEDGER.jsonl" : "UCL_LEDGER.jsonl");
-    }
-    for (const ij of effectiveCfg.injectors) {
-        if (ij.artifactPath)
-            ensureFile(ij.artifactPath, "ARTIFACT.md");
-    }
-    // Keep the rebuildable binary index out of git so obsidian-git (and git-backed
-    // Obsidian Sync setups) never commit it. See docs/OBSIDIAN_SETUP.md §6.
-    const gitignoreDest = path.join(ctx.cwd, ".gitignore");
-    const plan = planGitignore(fs.existsSync(gitignoreDest) ? fs.readFileSync(gitignoreDest, "utf-8") : null);
-    if (plan.action === "create") {
-        fs.writeFileSync(gitignoreDest, plan.content, "utf-8");
-        created.push(gitignoreDest);
-    }
-    else if (plan.action === "append") {
-        fs.appendFileSync(gitignoreDest, plan.content);
-        updated.push(gitignoreDest);
-    }
-    else {
-        skipped.push(gitignoreDest);
-    }
+    const { created, updated, skipped, collectionName } = scaffoldVaultConfig(ctx.cwd, requestedCollection);
     const msg = [
         "Vault-mind scaffolding complete.",
         "",
@@ -293,11 +247,12 @@ const handleInit = async (_args, ctx, pi) => {
     if (skipped.length) {
         msg.push("", "Skipped (already exist):", ...skipped.map((s) => `  • ${path.relative(ctx.cwd, s)}`));
     }
-    msg.push("", `💡 Tip: default collection file is collections/${initCollection}.jsonl (override with /vm init --collection <name>).`);
+    msg.push("", `💡 Tip: default collection file is collections/${collectionName}.jsonl (override with /vm setup --collection <name>).`);
     if (ctx.hasUI) {
         ctx.ui.notify(msg.join("\n"), "info");
     }
     if (hasPiContextTools(pi)) {
+        const cfgDest = getConfigPath(ctx.cwd);
         const existing = JSON.parse(fs.readFileSync(cfgDest, "utf-8"));
         existing.extensionCompatibility = existing.extensionCompatibility || {};
         existing.extensionCompatibility["pi-context"] = {
@@ -341,7 +296,7 @@ const handleValidate = async (_args, ctx, pi) => {
     }
     catch { }
     const { project: cfgPath } = findConfig(ctx.cwd);
-    lines.push(cfgPath ? `✅ Config: ${cfgPath}` : `⚠️  No config file (checked ${CONFIG_FILES.join(", ")}).`);
+    lines.push(cfgPath ? `✅ Config: ${cfgPath}` : `⚠️  No config file (checked ${getConfigPath(ctx.cwd)}).`);
     for (const [name, def] of Object.entries(cfg.collections)) {
         const exists = fs.existsSync(def.path);
         lines.push(`${exists ? "✅" : "⚠️"} Collection "${name}": ${def.path} ${exists ? "" : "(missing)"}`);
@@ -413,54 +368,105 @@ const handleApprove = async (args, ctx) => {
     fs.writeFileSync(pending.path, rejected.join("\n") + (rejected.length > 0 ? "\n" : ""));
     ctx.ui.notify(`Approved ${approved} → "${targetName}". Rejected ${rejected.length}.`, "info");
 };
-// ── /vm query ─────────────────────────────────────────────────────────────
-const handleQuery = async (args, ctx) => {
-    const parts = args.trim().split(/\s+/).filter(Boolean);
+// ── /vm search ─────────────────────────────────────────────────────────────
+const handleSearch = async (args, ctx, defaultMode = "hybrid") => {
+    const modeMatch = args.match(/--mode=(\w+)/);
+    const mode = modeMatch ? modeMatch[1] : defaultMode;
+    const cleanArgs = args.replace(/--mode=\w+/, "").trim();
+    const parts = cleanArgs.split(/\s+/).filter(Boolean);
     if (parts.length === 0) {
-        ctx.ui.notify("Usage: /vm query [collection] <query>", "error");
+        ctx.ui.notify("Usage: /vm search [collection] <query> [--mode=hybrid|semantic|fts|graph|full]", "error");
         return;
     }
     const cfg = loadConfig(ctx.cwd);
     let collection = getActiveCollection(ctx.cwd) || "main";
-    let query = args.trim();
+    let query = cleanArgs;
     if (parts.length > 1 && cfg.collections[parts[0]]) {
         collection = parts[0];
         query = parts.slice(1).join(" ");
     }
     const def = cfg.collections[collection];
     if (!def) {
-        ctx.ui.notify(`Unknown collection "${collection}". Run /vm init first.`, "error");
+        ctx.ui.notify(`Unknown collection "${collection}". Run /vm setup first.`, "error");
         return;
     }
+    const limit = 20;
+    const dataDir = cfg.vaultMind.dataDir;
+    const vmCfg = cfg.vaultMind;
     try {
-        const results = await searchHybrid(cfg.vaultMind.dataDir, collection, query, 20, cfg.vaultMind);
+        let results = [];
+        switch (mode) {
+            case "hybrid":
+                results = await searchHybridRanked(dataDir, collection, query, limit, vmCfg);
+                break;
+            case "semantic":
+                results = await searchHybrid(dataDir, collection, query, limit, vmCfg);
+                break;
+            case "fts":
+                results = await searchFts(dataDir, collection, query, limit, vmCfg);
+                break;
+            case "graph":
+                results = [await queryGraph(dataDir, vmCfg, query, 1, undefined)];
+                break;
+            case "full": {
+                const [hybrid, semantic, fts, graph] = await Promise.all([
+                    searchHybridRanked(dataDir, collection, query, limit, vmCfg).catch(() => []),
+                    searchHybrid(dataDir, collection, query, limit, vmCfg).catch(() => []),
+                    searchFts(dataDir, collection, query, limit, vmCfg).catch(() => []),
+                    queryGraph(dataDir, vmCfg, query, 1, undefined).catch(() => []),
+                ]);
+                const graphResult = Array.isArray(graph) ? graph : graph ? [graph] : [];
+                results = mergeSearchResults([hybrid, semantic, fts, graphResult]);
+                break;
+            }
+            default:
+                ctx.ui.notify(`Unknown search mode "${mode}". Use hybrid, semantic, fts, graph, or full.`, "error");
+                return;
+        }
         if (results.length === 0) {
-            ctx.ui.notify(`No results for "${query}" in "${collection}".`, "info");
+            ctx.ui.notify(`No results for "${query}" in "${collection}" (mode: ${mode}).`, "info");
             return;
         }
         // Rich TUI table when UI is available; plain text fallback for RPC
         if (ctx.hasUI) {
-            await renderQueryResults(ctx, collection, query, results);
+            await renderSearchResults(ctx, collection, query, results);
         }
         else {
             const lines = [
-                `**Search results (${results.length}) for "${query}" in "${collection}":**`,
+                `**Search results (${results.length}) for "${query}" in "${collection}" (mode: ${mode}):**`,
                 "",
             ];
             for (const r of results) {
                 const row = r;
-                const fact = String(row.fact ?? row.text ?? "(no text)");
+                const fact = String(row.fact ??
+                    row.text ??
+                    (typeof row === "object" && row !== null ? JSON.stringify(row) : "(no text)"));
                 lines.push(`- ${fact.slice(0, 120)}${fact.length > 120 ? "..." : ""}`);
             }
             ctx.ui.notify(lines.join("\n"), "info");
         }
     }
     catch (err) {
-        ctx.ui.notify(`Search failed: ${err.message}`, "error");
+        ctx.ui.notify(`Search failed: ${err instanceof Error ? err.message : String(err)}`, "error");
     }
 };
+function mergeSearchResults(sources) {
+    const seen = new Set();
+    const merged = [];
+    for (const source of sources) {
+        for (const r of source) {
+            const row = r;
+            const key = String(row.id ?? row.fact ?? JSON.stringify(row));
+            if (!seen.has(key)) {
+                seen.add(key);
+                merged.push(row);
+            }
+        }
+    }
+    return merged.slice(0, 20);
+}
 /** Render search results as a scrollable TUI table with column headers. */
-async function renderQueryResults(ctx, collection, query, results) {
+async function renderSearchResults(ctx, collection, query, results) {
     // Infer columns from the first result
     const first = results[0];
     const keys = first ? Object.keys(first).filter((k) => !k.startsWith("_")) : [];
@@ -487,7 +493,7 @@ async function renderQueryResults(ctx, collection, query, results) {
         divider,
         ...rows.map((r) => r.join(" ")),
     ];
-    await ctx.ui.custom((tui, theme, _keybindings, done) => {
+    await ctx.ui.custom((_tui, theme, _keybindings, done) => {
         const container = new Container();
         let y = 0;
         container.addChild(new Text(theme.fg("accent", lines[0]), 1, ++y));
@@ -527,7 +533,7 @@ const handleTombstone = async (args, ctx) => {
     ctx.ui.notify(result.message, result.success ? "info" : "error");
 };
 // ── /vm reindex ────────────────────────────────────────────────────────────
-const handleReindex = async (args, ctx, pi) => {
+const handleReindex = async (args, ctx, _pi) => {
     const cfg = loadConfig(ctx.cwd);
     const tokens = args.trim().split(/\s+/).filter(Boolean);
     const flags = new Set(tokens.map((t) => t.toLowerCase()));
@@ -537,7 +543,7 @@ const handleReindex = async (args, ctx, pi) => {
     const collectionFilter = reindexAll || rebuildEmbeddings ? null : (tokens.find((t) => !t.startsWith("--")) ?? null);
     // Remote bulk re-index: read JSONL → submit Modal bulk job → poll → sync down.
     if (remote) {
-        if (!cfg.vaultMind.embedding.remoteUrl) {
+        if (!cfg.vaultMind.embedding[EMBEDDING_FLAT_KEYS[0]]) {
             ctx.ui.notify("--remote requires remoteUrl. Set it up via /vm setup.", "error");
             return;
         }
@@ -552,7 +558,7 @@ const handleReindex = async (args, ctx, pi) => {
                 : Object.keys(cfg.collections);
         ctx.ui.notify(`Remote re-index: submitting Modal bulk job for ${names.join(", ")}...`, "info");
         try {
-            const results = await reindexRemote(cfg, names, {
+            const results = await reindexRemote(cfg, names, ctx.cwd, {
                 onStatus: (s) => ctx.ui.notify(`  ${s.collection || ""}: ${s.status} ${s.processed}/${s.total}`, "info"),
             });
             const lines = ["**Remote Re-index Report:**", ""];
@@ -652,14 +658,14 @@ const handleReindex = async (args, ctx, pi) => {
     ctx.ui.notify(lines.join("\n"), "info");
 };
 // ── /vm embedding ──────────────────────────────────────────────────────────
-const handleEmbedding = async (args, ctx, pi) => {
+const handleEmbedding = async (args, ctx, _pi) => {
     const cfg = loadConfig(ctx.cwd);
     const parts = args.trim().split(/\s+/g);
     const subcommand = parts[0]?.toLowerCase() || "status";
-    const value = parts.slice(1).join(" ");
+    const _value = parts.slice(1).join(" ");
     const { project: cfgPath } = findConfig(ctx.cwd);
     if (!cfgPath) {
-        ctx.ui.notify("No config found. Run /vm init first.", "error");
+        ctx.ui.notify("No config found. Run /vm setup first.", "error");
         return;
     }
     switch (subcommand) {
@@ -677,9 +683,8 @@ const handleEmbedding = async (args, ctx, pi) => {
                 `Graph: ${cfg.vaultMind.graph?.enabled !== false ? "enabled" : "disabled"}`,
                 `Data Dir: ${cfg.vaultMind.dataDir}`,
             ];
-            if (emb.modal) {
-                const modal = emb.modal;
-                lines.push("", "**Remote Provider (Modal):**", `  Workspace: ${modal.workspace || "(default)"}`, `  Fallback: ${modal.fallback?.enabled === false ? "disabled" : modal.fallback?.provider || "(none — degrade to FTS)"}`, `  Sync: auto=${modal.sync?.autoSync ? "on" : "off"}, interval=${modal.sync?.autoSyncIntervalMs ?? 300000}ms`);
+            if (emb.remoteUrl) {
+                lines.push("", "**Remote Provider (Modal):**", `  Workspace: ${emb.workspace || "(default)"}`, `  Fallback: ${emb.fallback?.enabled === false ? "disabled" : "(on — same-space local when unreachable)"}`, `  Sync: auto=${emb.sync?.autoSync ? "on" : "off"}, interval=${emb.sync?.autoSyncIntervalMs ?? 300000}ms`);
                 const co = emb.coalesce;
                 if (co) {
                     lines.push(`  Coalesce: debounce=${co.debounceMs ?? 1000}ms, batch=${co.maxBatchSize ?? 64}, concurrency=${co.maxConcurrentFlushes ?? 2}, dedupe=${co.dedupe ?? true}, searchBypass=${co.searchBypass ?? true}`);
@@ -702,13 +707,13 @@ const MODAL_CONFIG_USAGE = [
     "  /vm remote config workspace <name>     Derive the Modal URL from workspace slug",
     "  /vm remote config model <name>         Set the canonical embedder (default embeddinggemma)",
     "  /vm remote config dim <n>              Set output dimension (omit for native)",
-    "  /vm remote config fallback ollama|none  Set offline fallback provider",
+    "  /vm remote config fallback <openai-compatible|ollama|none>  Set offline fallback provider",
     "  /vm remote config sync auto on|off     Toggle auto-sync",
     "  /vm remote config sync interval <ms>   Auto-sync interval",
     "  /vm remote config pageSize <n>         Sync page size",
     "  /vm remote config coalesce debounce <ms>  Coalescer debounce window",
     "  /vm remote config coalesce batch <n>   Coalescer max batch size",
-    "  /vm remote config token                Show token guidance (use PVM_API_TOKEN env)",
+    "  /vm remote config token                Show token guidance (use PVM_REMOTE_EMBEDDING_API_KEY env)",
     "",
     "  (no args) Show current remote config",
 ].join("\n");
@@ -735,31 +740,31 @@ const modalSection = (obj) => {
 const handleModalConfig = async (args, ctx) => {
     const { project: cfgPath } = findConfig(ctx.cwd);
     if (!cfgPath) {
-        ctx.ui.notify("No config found. Run /vm init first.", "error");
+        ctx.ui.notify("No config found. Run /vm setup first.", "error");
         return;
     }
     const cfg = loadConfig(ctx.cwd);
     const parts = args.trim().split(/\s+/).filter(Boolean);
     const key = parts[0]?.toLowerCase();
-    const modal = cfg.vaultMind.embedding.modal ?? {};
+    const emb = cfg.vaultMind.embedding;
     if (!key) {
         const tokenSrc = resolveModalToken(cfg.vaultMind)
-            ? "env or ~/.pi/agent/vault-mind.env ✅"
-            : modal.apiToken
-                ? "config (set PVM_API_TOKEN env/dotenv to override)"
-                : "❌ none (set PVM_API_TOKEN env or ~/.pi/agent/vault-mind.env)";
+            ? "env or .vault-mind/vault-mind.env ✅"
+            : emb.remoteApiKey
+                ? "config (set PVM_REMOTE_EMBEDDING_API_KEY env/dotenv to override)"
+                : "❌ none (set PVM_REMOTE_EMBEDDING_API_KEY env or .vault-mind/vault-mind.env)";
         const derivedUrl = resolveBaseUrl(cfg.vaultMind);
         const lines = [
             "**Modal Config:**",
             "",
-            `  workspace: ${resolveWorkspace(cfg.vaultMind) || "(not set)"}`,
-            `  baseUrl: ${modal.baseUrl || (derivedUrl ? `${derivedUrl} (derived)` : "❌ not set")}`,
-            `  model: ${modal.model || "(default embeddinggemma)"}`,
-            `  dim: ${modal.dim ?? "(native)"}`,
+            `  workspace: ${emb.workspace || "(not set)"}`,
+            `  baseUrl: ${emb.remoteUrl || (derivedUrl ? `${derivedUrl} (derived)` : "❌ not set")}`,
+            `  model: ${emb.model || "(default embeddinggemma)"}`,
+            `  dim: ${emb.dim ?? "(native)"}`,
             `  token: ${tokenSrc}`,
-            `  fallback: ${modal.fallback?.enabled === false ? "disabled" : modal.fallback?.provider || "(none)"}`,
-            `  sync: ${JSON.stringify(modal.sync ?? {})}`,
-            `  coalesce: ${JSON.stringify(cfg.vaultMind.embedding.coalesce ?? {})}`,
+            `  fallback: ${emb.fallback?.enabled === false ? "disabled" : "(on — same-space local when unreachable)"}`,
+            `  sync: ${JSON.stringify(emb.sync ?? {})}`,
+            `  coalesce: ${JSON.stringify(emb.coalesce ?? {})}`,
         ];
         ctx.ui.notify(lines.join("\n"), "info");
         return;
@@ -810,11 +815,13 @@ const handleModalConfig = async (args, ctx) => {
             if (v === "none") {
                 m.fallback = { enabled: false };
             }
-            else if (v === "ollama" || v === "transformers") {
-                m.fallback = { enabled: true, provider: v };
+            else if (v === "openai-compatible" || v === "ollama") {
+                // Accept "ollama" as a friendlier alias for "openai-compatible" —
+                // they're functionally identical (any local /v1/embeddings endpoint).
+                m.fallback = { enabled: true, provider: "openai-compatible" };
             }
             else {
-                ctx.ui.notify("/vm remote config fallback <ollama|transformers|none>", "error");
+                ctx.ui.notify("/vm remote config fallback <openai-compatible|ollama|none>", "error");
                 return;
             }
             writeProjectConfig(cfgPath, obj);
@@ -882,17 +889,17 @@ const handleModalConfig = async (args, ctx) => {
             ctx.ui.notify(MODAL_CONFIG_USAGE, "info");
     }
 };
-const handleModal = async (args, ctx, pi) => {
+const handleModal = async (args, ctx, _pi) => {
     const cfg = loadConfig(ctx.cwd);
     const parts = args.trim().split(/\s+/).filter(Boolean);
     const sub = parts[0]?.toLowerCase() || "status";
     const rest = parts.slice(1).join(" ");
     switch (sub) {
         case "status": {
-            const modal = cfg.vaultMind.embedding.modal;
+            const emb = cfg.vaultMind.embedding;
             const tokenSrc = resolveModalToken(cfg.vaultMind)
-                ? "env or ~/.pi/agent/vault-mind.env ✅"
-                : modal?.apiToken
+                ? "env or .vault-mind/vault-mind.env ✅"
+                : emb.remoteApiKey
                     ? "config"
                     : "❌ none";
             const derivedUrl = resolveBaseUrl(cfg.vaultMind);
@@ -901,9 +908,9 @@ const handleModal = async (args, ctx, pi) => {
                 "",
                 `Configured: ${isModalConfigured(cfg.vaultMind) ? "✅" : "❌"}`,
                 `  workspace: ${resolveWorkspace(cfg.vaultMind) || "(not set)"}`,
-                `  baseUrl: ${modal?.baseUrl || (derivedUrl ? `${derivedUrl} (derived)` : "(not set)")}`,
-                `  model: ${modal?.model || "(default embeddinggemma)"}`,
-                `  dim: ${modal?.dim ?? "(native)"}`,
+                `  baseUrl: ${emb.remoteUrl || (derivedUrl ? `${derivedUrl} (derived)` : "(not set)")}`,
+                `  model: ${emb.model || "(default embeddinggemma)"}`,
+                `  dim: ${emb.dim ?? "(native)"}`,
                 `  token: ${tokenSrc}`,
             ];
             const client = createModalClient(cfg.vaultMind);
@@ -943,8 +950,8 @@ const handleModal = async (args, ctx, pi) => {
             ctx.ui.notify(`Syncing ${oneCollection ? `"${oneCollection}"` : "all collections"}${full ? " (full)" : ""}...`, "info");
             try {
                 const results = oneCollection
-                    ? [await syncCollection(cfg, oneCollection, { full })]
-                    : await syncAll(cfg, undefined, { full });
+                    ? [await syncCollection(cfg, oneCollection, ctx.cwd, { full })]
+                    : await syncAll(cfg, ctx.cwd, undefined, { full });
                 const lines = ["**Sync Report:**", ""];
                 for (const r of results)
                     lines.push(`  ${r.rows > 0 ? "✅" : "•"} ${r.collection} / ${r.model} / ${r.dim}: ${r.rows} rows, watermark=${r.watermark}${r.full ? " (full)" : ""}`);
@@ -986,16 +993,16 @@ const handleModal = async (args, ctx, pi) => {
         case "auto": {
             const cfgPath = findConfig(ctx.cwd).project;
             if (!cfgPath) {
-                ctx.ui.notify("No project config found. Run /vm init first.", "error");
+                ctx.ui.notify("No project config found. Run /vm setup first.", "error");
                 return;
             }
             const workspace = resolveWorkspace(cfg.vaultMind);
-            if (!workspace && !cfg.vaultMind.embedding.modal?.baseUrl) {
+            if (!workspace && !cfg.vaultMind.embedding[EMBEDDING_FLAT_KEYS[0]]) {
                 ctx.ui.notify("Modal workspace or baseUrl not configured. Run:\n  /vm remote config workspace <name>", "error");
             }
             const token = resolveModalToken(cfg.vaultMind);
             if (!token) {
-                ctx.ui.notify("Modal token not found. Set PVM_API_TOKEN env or write it to ~/.pi/agent/vault-mind.env", "error");
+                ctx.ui.notify("Modal token not found. Set PVM_REMOTE_EMBEDDING_API_KEY env or write it to .vault-mind/vault-mind.env", "error");
                 return;
             }
             ctx.ui.notify("🔄 Auto-configuring Modal...", "info");
@@ -1082,7 +1089,7 @@ const handleModal = async (args, ctx, pi) => {
             ctx.ui.notify(`Canonical model → ${newModel}${newDim ? `@${newDim}` : ""} (was ${oldModel}${oldDim ? `@${oldDim}` : ""}). Old namespace kept. Starting remote re-embed...`, "info");
             const fresh = loadConfig(ctx.cwd);
             try {
-                const results = await reindexRemote(fresh, Object.keys(fresh.collections));
+                const results = await reindexRemote(fresh, Object.keys(fresh.collections), ctx.cwd);
                 const lines = [`**Migration → ${newModel}:**`, ""];
                 for (const r of results)
                     if (r.error)
@@ -1105,10 +1112,10 @@ const handleModal = async (args, ctx, pi) => {
 const handleContext = async (args, ctx, pi) => {
     const parts = args.trim().split(/\s+/g);
     const subcommand = parts[0]?.toLowerCase() || "status";
-    const value = parts[1]?.toLowerCase();
+    const _value = parts[1]?.toLowerCase();
     const { project: cfgPath } = findConfig(ctx.cwd);
     if (!cfgPath) {
-        ctx.ui.notify("No config found. Run /vm init first.", "error");
+        ctx.ui.notify("No config found. Run /vm setup first.", "error");
         return;
     }
     switch (subcommand) {
@@ -1226,7 +1233,65 @@ export const watcherState = createWatcherState();
 /** Module-level server state, referenced by the /vm server command.
  *  Port is set when the server starts in index.ts. */
 export const serverState = createServerState();
-const handleServer = (ctx) => {
+const handleServer = (args, ctx, pi) => {
+    const subcommand = args.trim().split(/\s+/g)[0]?.toLowerCase() || "status";
+    if (subcommand === "start") {
+        const cfg = loadConfig(ctx.cwd);
+        serverState.port = cfg.vaultMind.httpPort || 11435;
+        startServer(pi, serverState, watcherState, async () => {
+            const registry = ctx.modelRegistry;
+            await registry.refresh();
+            const error = registry.getError();
+            if (error)
+                return { status: "model-registry-error" };
+            const all = registry.getAll();
+            if (all.length === 0)
+                return { status: "model-registry-empty" };
+            const available = registry.getAvailable();
+            if (available.length === 0) {
+                const providers = [...new Set(all.map((m) => m.provider))];
+                const statuses = providers.map((p) => {
+                    const status = registry.getProviderAuthStatus(p);
+                    return {
+                        providerId: p,
+                        configured: status?.configured,
+                        source: status?.source,
+                    };
+                });
+                const configured = statuses.filter((s) => s.configured);
+                if (configured.length === 0) {
+                    const firstSource = statuses[0]?.source;
+                    return {
+                        status: "provider-authentication-required",
+                        authSource: firstSource,
+                    };
+                }
+                const firstConfigured = configured[0];
+                return {
+                    status: "configured-provider-unavailable",
+                    providerId: firstConfigured.providerId,
+                };
+            }
+            const currentModel = ctx.model;
+            if (!currentModel) {
+                if (available.length > 0)
+                    return { status: "model-selection-required" };
+            }
+            else if (!available.some((m) => m.id === currentModel.id && m.provider === currentModel.provider)) {
+                return { status: "current-model-unavailable", modelId: currentModel.id };
+            }
+            return {
+                status: "ready",
+                model: {
+                    id: currentModel.id,
+                    name: currentModel.name,
+                    provider: currentModel.provider,
+                },
+            };
+        });
+        ctx.ui.notify(`Started HTTP server on http://127.0.0.1:${serverState.port}/vault-mind/status`, "info");
+        return;
+    }
     const lines = [
         `HTTP server: ${serverState.server ? "RUNNING" : "STOPPED"}`,
         `Port: ${serverState.port}`,
@@ -1255,7 +1320,7 @@ const handleWatcher = async (args, ctx, pi) => {
         case "start": {
             const cfg = loadConfig(ctx.cwd);
             if (!cfg.vaultMind.vaults || Object.keys(cfg.vaultMind.vaults).length === 0) {
-                ctx.ui.notify("No vaults configured. Add vaults to vaultMind.vaults in pi-vault-mind.config.json first.", "error");
+                ctx.ui.notify("No vaults configured. Add vaults to vaultMind.vaults in .vault-mind/vault-mind.config.json first.", "error");
                 return;
             }
             if (watcherState.running) {
@@ -1369,7 +1434,7 @@ const handleWatcher = async (args, ctx, pi) => {
 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+--/);
+    const parts = args.trim().replace(/^--/, "").split(/\s+--/);
     for (const part of parts) {
         const trimmed = part.trim();
         if (trimmed.startsWith("vault "))
@@ -1385,11 +1450,28 @@ const handleSetup = async (args, ctx, pi) => {
             cliArgs.model = trimmed.slice(6).trim();
         else if (trimmed.startsWith("workspace "))
             cliArgs.workspace = trimmed.slice(10).trim();
-    }
-    const hasCliArgs = cliArgs.vault || cliArgs.remoteUrl || cliArgs.localUrl || cliArgs.model || cliArgs.workspace;
+        else if (trimmed.startsWith("remoteApiKey "))
+            cliArgs.remoteApiKey = trimmed.slice(13).trim();
+        else if (trimmed.startsWith("collection "))
+            cliArgs.collection = trimmed.slice(11).trim();
+    }
+    const hasCliArgs = cliArgs.vault ||
+        cliArgs.remoteUrl ||
+        cliArgs.localUrl ||
+        cliArgs.model ||
+        cliArgs.workspace ||
+        cliArgs.collection ||
+        cliArgs.remoteApiKey;
+    // Merge-safe scaffold FIRST: on a truly fresh vault this populates the
+    // default collections/injectors (with vault-derived naming) before
+    // setupWizard ever writes the file — setupWizard writing first would
+    // permanently skip this branch (it always sees an existing file).
+    await handleInit(cliArgs.collection ? `--collection ${cliArgs.collection}` : "", ctx, pi);
     await setupWizard(ctx, hasCliArgs ? cliArgs : undefined);
-    // Scaffold collections, .gitignore, and project config if not already present
-    await handleInit("", ctx, pi);
+    // Scaffold model-router.json with tuned defaults if this vault doesn't
+    // have one yet — mirrors what the Obsidian plugin does today, so a
+    // CLI-only setup gets the same primary/fallback model choices.
+    scaffoldModelRouterConfig(ctx.cwd);
     if (ctx.hasUI) {
         ctx.ui.notify("Running personalization (system.md + AGENTS.md)...", "info");
         await runPersonalize(ctx, pi);
@@ -1399,7 +1481,7 @@ const handleSetup = async (args, ctx, pi) => {
     }
 };
 // ── /vm intake ─────────────────────────────────────────────────────────────
-const handleIntake = async (args, ctx) => {
+const _handleIntake = async (args, ctx) => {
     const filePath = args.trim();
     if (!filePath) {
         ctx.ui.notify("Usage: /vm intake <path-to-json-spec>", "error");
@@ -1430,15 +1512,8 @@ const handleIntake = async (args, ctx) => {
     }
 };
 // ── /vm remote token ────────────────────────────────────────────────────────
-/** Dotenv path where the Modal token is persisted. */
-const MODAL_TOKEN_ENV_PATH = path.join(process.env.HOME || process.env.USERPROFILE || "", ".pi", "agent", "vault-mind.env");
-const writeTokenEnv = (token) => {
-    const dir = path.dirname(MODAL_TOKEN_ENV_PATH);
-    if (!fs.existsSync(dir))
-        fs.mkdirSync(dir, { recursive: true });
-    // fs mode bits are unsupported on Windows; skip them to avoid EINVAL.
-    const options = process.platform === "win32" ? {} : { mode: 0o600 };
-    fs.writeFileSync(MODAL_TOKEN_ENV_PATH, `PVM_API_TOKEN="${token}"\n`, options);
+export const writeTokenEnv = (token, cwd, varName = "PVM_API_TOKEN") => {
+    writeEnvEntry(varName, token, { cwd });
 };
 const fetchTokenFrom1Password = () => {
     try {
@@ -1453,32 +1528,32 @@ const fetchTokenFrom1Password = () => {
 };
 const handleModalToken = async (ctx, cliToken) => {
     if (cliToken) {
-        writeTokenEnv(cliToken);
-        ctx.ui.notify(`✅ Wrote token to ${MODAL_TOKEN_ENV_PATH}`, "info");
+        writeTokenEnv(cliToken, ctx.cwd, MODAL_TOKEN_ENV);
+        ctx.ui.notify(`✅ Wrote token to ${modalTokenEnvPath(ctx.cwd)}`, "info");
         return;
     }
     const envToken = process.env[MODAL_TOKEN_ENV];
     if (envToken) {
-        ctx.ui.notify("PVM_API_TOKEN is already exported in env. Skipping write so we don't clobber it.", "warning");
+        ctx.ui.notify("PVM_REMOTE_EMBEDDING_API_KEY is already exported in env. Skipping write so we don't clobber it.", "warning");
         return;
     }
     const tokenFrom1Pass = fetchTokenFrom1Password();
     if (tokenFrom1Pass) {
-        writeTokenEnv(tokenFrom1Pass);
-        ctx.ui.notify(`✅ Fetched token from 1Password item "pi-vault-mind-auth" and wrote it to ${MODAL_TOKEN_ENV_PATH}`, "info");
+        writeTokenEnv(tokenFrom1Pass, ctx.cwd, MODAL_TOKEN_ENV);
+        ctx.ui.notify(`✅ Fetched token from 1Password item "pi-vault-mind-auth" and wrote it to ${modalTokenEnvPath(ctx.cwd)}`, "info");
         return;
     }
     if (!ctx.hasUI) {
         ctx.ui.notify("No 1Password token found and no TUI available. Use:\n  /vm remote token <token>", "error");
         return;
     }
-    const token = await ctx.ui.input("Modal API token:", "paste bearer token here (will be written to ~/.pi/agent/vault-mind.env)");
+    const token = await ctx.ui.input("Modal API token:", "paste bearer token here (will be written to .vault-mind/vault-mind.env as PVM_REMOTE_EMBEDDING_API_KEY)");
     if (!token) {
         ctx.ui.notify("Token setup cancelled.", "warning");
         return;
     }
-    writeTokenEnv(token);
-    ctx.ui.notify(`✅ Wrote token to ${MODAL_TOKEN_ENV_PATH}`, "info");
+    writeTokenEnv(token, ctx.cwd, MODAL_TOKEN_ENV);
+    ctx.ui.notify(`✅ Wrote token to ${modalTokenEnvPath(ctx.cwd)}`, "info");
 };
 // ── /vm token ──────────────────────────────────────────────────────────────
 const maskToken = (token) => {
@@ -1500,15 +1575,15 @@ const handleToken = (args, ctx) => {
             else {
                 source = "none";
                 try {
-                    const text = fs.readFileSync(MODAL_TOKEN_ENV_PATH, "utf-8");
+                    const text = fs.readFileSync(modalTokenEnvPath(ctx.cwd), "utf-8");
                     for (const line of text.split(/\r?\n/)) {
                         const m = line.match(/^\s*([A-Z_][A-Z0-9_]*)\s*=\s*("([^"]*)"|'([^']*)'|[^\s#]+)/);
-                        if (!m || m[1] !== "PVM_API_TOKEN")
+                        if (m?.[1] !== "PVM_API_TOKEN")
                             continue;
                         const val = m[3] ?? m[4] ?? m[2];
                         if (val) {
                             token = val;
-                            source = "~/.pi/agent/vault-mind.env";
+                            source = ".vault-mind/vault-mind.env";
                             break;
                         }
                     }
@@ -1516,14 +1591,6 @@ const handleToken = (args, ctx) => {
                 catch {
                     // file missing or unreadable
                 }
-                if (!token) {
-                    const cfg = loadConfig(ctx.cwd);
-                    const cfgToken = cfg?.vaultMind?.embedding?.modal?.apiToken;
-                    if (cfgToken) {
-                        token = cfgToken;
-                        source = "config (vaultMind.embedding.modal.apiToken)";
-                    }
-                }
             }
             const masked = token ? maskToken(token) : "(not set)";
             ctx.ui.notify(["**API Token**", `Source: ${source}`, `Value:  ${masked}`].join("\n"), token ? "info" : "warning");
@@ -1537,7 +1604,7 @@ const handleToken = (args, ctx) => {
                 : "";
             ctx.ui.notify([
                 `\u2705 New token: ${masked}`,
-                "Written to ~/.pi/agent/vault-mind.env.",
+                "Written to .vault-mind/vault-mind.env.",
                 `\u26a0\ufe0f  All clients (Obsidian plugin, scripts) must update to the new token — the old token is now invalid.${envNote}`,
             ].join("\n"), "warning");
             return;
@@ -1568,15 +1635,15 @@ export const registerCommands = (pi) => {
         getArgumentCompletions: (_prefix) => {
             const words = _prefix.trim().split(/\s+/);
             const top = [
-                "init",
                 "validate",
                 "approve",
-                "query",
+                "search",
                 "tombstone",
                 "settings",
                 "help",
                 "collection",
                 "discover-schema",
+                "doctor",
                 "injector",
                 "context",
                 "embedding",
@@ -1597,11 +1664,6 @@ export const registerCommands = (pi) => {
             const subcommand = words[0];
             if (words.length >= 2) {
                 const prefix = words[1] || "";
-                if (subcommand === "init") {
-                    return ["--collection"]
-                        .filter((c) => c.startsWith(prefix))
-                        .map((c) => ({ label: c, value: c, description: `init ${c}` }));
-                }
                 if (subcommand === "embedding") {
                     return ["status", "use", "model", "models", "pull", "cloud"]
                         .filter((c) => c.startsWith(prefix))
@@ -1617,11 +1679,11 @@ export const registerCommands = (pi) => {
                         .filter((c) => c.startsWith(prefix))
                         .map((c) => ({ label: c, value: c, description: `discover-schema ${c}` }));
                 }
-                if (subcommand === "query") {
+                if (subcommand === "search") {
                     const names = collectionNames(loadConfig(process.cwd()));
                     return names
                         .filter((c) => c.startsWith(prefix))
-                        .map((c) => ({ label: c, value: c, description: `query ${c}` }));
+                        .map((c) => ({ label: c, value: c, description: `search ${c}` }));
                 }
                 if (subcommand === "collection") {
                     return ["select", "list", "create", "reindex"]
@@ -1639,7 +1701,15 @@ export const registerCommands = (pi) => {
                         .map((c) => ({ label: c, value: c, description: `watcher ${c}` }));
                 }
                 if (subcommand === "setup") {
-                    return ["--vault", "--remoteUrl", "--localUrl", "--model", "--workspace"]
+                    return [
+                        "--vault",
+                        "--remoteUrl",
+                        "--localUrl",
+                        "--model",
+                        "--workspace",
+                        "--collection",
+                        "--remoteApiKey",
+                    ]
                         .filter((c) => c.startsWith(prefix))
                         .map((c) => ({ label: c, value: c, description: `setup ${c}` }));
                 }
@@ -1661,14 +1731,14 @@ export const registerCommands = (pi) => {
             const subcommand = parts[0]?.toLowerCase() || "help";
             const rest = parts.slice(1).join(" ");
             switch (subcommand) {
-                case "init":
-                    return handleInit(rest, ctx, pi);
+                case "doctor":
+                    return handleDoctor(ctx);
                 case "validate":
                     return handleValidate(rest, ctx, pi);
                 case "approve":
                     return handleApprove(rest, ctx);
-                case "query":
-                    return handleQuery(rest, ctx);
+                case "search":
+                    return handleSearch(rest, ctx);
                 case "tombstone":
                     return handleTombstone(rest, ctx);
                 case "settings":
@@ -1684,7 +1754,7 @@ export const registerCommands = (pi) => {
                 case "embedding":
                     return handleEmbedding(rest, ctx, pi);
                 case "server":
-                    return handleServer(ctx);
+                    return handleServer(rest, ctx, pi);
                 case "watcher":
                     return handleWatcher(rest, ctx, pi);
                 case "remote":