pi-vault-mind 0.7.0 → 0.7.2

package/dist/src/commands.js

@@ -7,8 +7,10 @@ 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 { createServerState } from "./server.js";
 import { createCollectionWizard, createInjectorWizard, openSettingsDashboard, setupWizard, } from "./settings-ui.js";
+import { reindexRemote, syncAll, syncCollection } from "./sync.js";
 import { createWatcherState, getWatcherStatus, startWatcher, stopWatcher } from "./watcher.js";
 // ── Shared helpers ───────────────────────────────────────────────────────────
 const WIKI_USAGE = [
@@ -26,10 +28,15 @@ const WIKI_USAGE = [
     "  /wiki context enable|disable  Enable/disable pi-context integration",
     "  /wiki context status        Show pi-context integration status",
     "  /wiki embedding status      Show embedding config + Ollama models",
-    "  /wiki embedding use         Switch provider (ollama | transformers)",
+    "  /wiki embedding use         Switch provider (ollama | transformers | modal)",
     "  /wiki embedding model       Set Ollama embedding model",
     "  /wiki embedding models      List available Ollama models",
     "  /wiki embedding pull        Pull a model from Ollama",
+    "  /wiki modal status          Show Modal config + health + remote collections",
+    "  /wiki modal config          Set Modal baseUrl/model/dim/sync/fallback",
+    "  /wiki modal sync            Pull server vectors into local LanceDB [--full]",
+    "  /wiki modal jobs <id>       Poll a Modal bulk job",
+    "  /wiki modal migrate <model> Change canonical model + re-embed (remote)",
     "  /wiki watcher start          Start passive file watcher",
     "  /wiki watcher stop           Stop passive file watcher",
     "  /wiki watcher status         Show watcher status",
@@ -139,9 +146,42 @@ export const selectActiveCollection = async (ctx) => {
     }
 };
 // ── /wiki 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`,
+        };
+    }
+    // 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 handleInit = async (_args, ctx, pi) => {
     const cfg = loadConfig(ctx.cwd);
     const created = [];
+    const updated = [];
     const skipped = [];
     const ensureFile = (dest, tmpl) => {
         if (fs.existsSync(dest)) {
@@ -203,12 +243,30 @@ const handleInit = async (_args, ctx, pi) => {
         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 msg = [
         "Wiki scaffolding complete.",
         "",
         "Created:",
         ...created.map((c) => `  • ${path.relative(ctx.cwd, c)}`),
     ];
+    if (updated.length) {
+        msg.push("", "Updated:", ...updated.map((u) => `  • ${path.relative(ctx.cwd, u)}`));
+    }
     if (skipped.length) {
         msg.push("", "Skipped (already exist):", ...skipped.map((s) => `  • ${path.relative(ctx.cwd, s)}`));
     }
@@ -328,10 +386,47 @@ const handleApprove = async (args, ctx) => {
 // ── /wiki reindex ────────────────────────────────────────────────────────────
 const handleReindex = async (args, ctx, pi) => {
     const cfg = loadConfig(ctx.cwd);
-    const subcommand = args.trim().split(/\s+/)[0]?.toLowerCase() || "";
-    const rebuildEmbeddings = subcommand === "--reembed" || subcommand === "--full";
-    const reindexAll = subcommand === "--all";
-    const collectionFilter = reindexAll || rebuildEmbeddings ? null : subcommand || null;
+    const tokens = args.trim().split(/\s+/).filter(Boolean);
+    const flags = new Set(tokens.map((t) => t.toLowerCase()));
+    const rebuildEmbeddings = flags.has("--reembed") || flags.has("--full");
+    const reindexAll = flags.has("--all");
+    const remote = flags.has("--remote");
+    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.wiki.embedding.provider !== "modal") {
+            ctx.ui.notify("--remote requires the modal provider. Run /wiki embedding use modal.", "error");
+            return;
+        }
+        if (!isModalConfigured(cfg.wiki)) {
+            ctx.ui.notify(`Modal not configured. Set baseUrl (/wiki modal config baseUrl) and ${MODAL_TOKEN_ENV}.`, "error");
+            return;
+        }
+        const names = reindexAll
+            ? Object.keys(cfg.collections)
+            : collectionFilter
+                ? [collectionFilter]
+                : 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, {
+                onStatus: (s) => ctx.ui.notify(`  ${s.collection || ""}: ${s.status} ${s.processed}/${s.total}`, "info"),
+            });
+            const lines = ["**Remote Re-index Report:**", ""];
+            for (const r of results) {
+                if (r.error)
+                    lines.push(`  ❌ ${r.collection}: ${r.error}`);
+                else
+                    lines.push(`  ✅ ${r.collection}: job ${r.job?.status}, synced ${r.sync?.rows ?? 0} rows (wm ${r.sync?.watermark ?? 0})`);
+            }
+            lines.push("", "Old namespaces are left intact until the new one is verified.");
+            ctx.ui.notify(lines.join("\n"), "info");
+        }
+        catch (err) {
+            ctx.ui.notify(`Remote re-index failed: ${err.message}`, "error");
+        }
+        return;
+    }
     ctx.ui.notify(rebuildEmbeddings
         ? "Reindexing: regenerating embeddings + rebuilding indexes..."
         : "Reindexing: rebuilding FTS + vector indexes...", "info");
@@ -432,12 +527,27 @@ const handleEmbedding = async (args, ctx, pi) => {
                 `Provider: ${cfg.wiki.embedding.provider}`,
                 cfg.wiki.embedding.provider === "ollama"
                     ? `Model: ${cfg.wiki.embedding.ollamaModel || "embeddinggemma"}`
-                    : "Model: all-MiniLM-L6-v2 (384 dims)",
+                    : cfg.wiki.embedding.provider === "modal"
+                        ? `Model: ${cfg.wiki.embedding.modal?.model || "(default embeddinggemma)"}`
+                        : "Model: all-MiniLM-L6-v2 (384 dims)",
                 `FTS: ${cfg.wiki.ftsEnabled !== false ? "enabled" : "disabled"}`,
                 `Graph: ${cfg.wiki.graph?.enabled !== false ? "enabled" : "disabled"}`,
                 `Data Dir: ${cfg.wiki.dataDir}`,
             ];
-            if (cfg.wiki.embedding.provider === "ollama" || !cfg.wiki.embedding.provider) {
+            if (cfg.wiki.embedding.provider === "modal") {
+                const modal = cfg.wiki.embedding.modal;
+                const tokenSrc = process.env[MODAL_TOKEN_ENV]
+                    ? `env ${MODAL_TOKEN_ENV} ✅`
+                    : modal?.apiToken
+                        ? "config (set env PVM_API_TOKEN to override)"
+                        : "❌ none (set PVM_API_TOKEN env)";
+                lines.push("", "**Modal:**", `  Base URL: ${modal?.baseUrl || "❌ not set"}`, `  Model: ${modal?.model || "(default embeddinggemma)"}`, `  Dim: ${modal?.dim ?? "(native)"}`, `  Token: ${tokenSrc}`, `  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`);
+                const co = cfg.wiki.embedding.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}`);
+                }
+            }
+            else if (cfg.wiki.embedding.provider === "ollama" || !cfg.wiki.embedding.provider) {
                 const conn = await testOllamaConnection(pi);
                 lines.push("", "**Ollama Status:**", `  Reachable: ${conn.reachable ? "✅ Yes" : "❌ No"}`);
                 if (conn.error)
@@ -462,8 +572,8 @@ const handleEmbedding = async (args, ctx, pi) => {
             return;
         }
         case "use": {
-            if (!value || !["ollama", "transformers"].includes(value)) {
-                ctx.ui.notify("/wiki embedding use <ollama|transformers>", "error");
+            if (!value || !["ollama", "transformers", "modal"].includes(value)) {
+                ctx.ui.notify("/wiki embedding use <ollama|transformers|modal>", "error");
                 return;
             }
             if (value === "ollama") {
@@ -474,6 +584,12 @@ const handleEmbedding = async (args, ctx, pi) => {
                         return;
                 }
             }
+            if (value === "modal") {
+                const modal = cfg.wiki.embedding.modal;
+                if (!modal?.baseUrl) {
+                    ctx.ui.notify("Modal needs a base URL. Set it with: /wiki modal config baseUrl <url>\n(Token via PVM_API_TOKEN env, preferred.)", "warning");
+                }
+            }
             const existing = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
             existing.wiki = existing.wiki || {};
             existing.wiki.embedding = existing.wiki.embedding || {};
@@ -528,6 +644,336 @@ const handleEmbedding = async (args, ctx, pi) => {
         }
     }
 };
+// ── /wiki modal ──────────────────────────────────────────────────────────────
+const MODAL_CONFIG_USAGE = [
+    "**/wiki modal config**",
+    "",
+    "  /wiki modal config baseUrl <url>        Set the Modal ASGI base URL",
+    "  /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",
+    "  /wiki modal config sync auto on|off     Toggle auto-sync",
+    "  /wiki modal config sync interval <ms>   Auto-sync interval",
+    "  /wiki modal config pageSize <n>         Sync page size",
+    "  /wiki modal config coalesce debounce <ms>  Coalescer debounce window",
+    "  /wiki modal config coalesce batch <n>   Coalescer max batch size",
+    "  /wiki modal config token                Show token guidance (use PVM_API_TOKEN env)",
+    "",
+    "  (no args) Show current Modal config",
+].join("\n");
+/** Read the raw project config object (mutable). */
+const readProjectConfig = (cfgPath) => {
+    try {
+        return JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+};
+const writeProjectConfig = (cfgPath, obj) => {
+    fs.writeFileSync(cfgPath, `${JSON.stringify(obj, null, 2)}\n`, "utf-8");
+};
+const modalSection = (obj) => {
+    obj.wiki = obj.wiki || {};
+    const wiki = obj.wiki;
+    wiki.embedding = wiki.embedding || {};
+    const emb = wiki.embedding;
+    emb.modal = emb.modal || {};
+    return emb.modal;
+};
+const handleModalConfig = async (args, ctx) => {
+    const { project: cfgPath } = findConfig(ctx.cwd);
+    if (!cfgPath) {
+        ctx.ui.notify("No config found. Run /wiki init first.", "error");
+        return;
+    }
+    const cfg = loadConfig(ctx.cwd);
+    const parts = args.trim().split(/\s+/).filter(Boolean);
+    const key = parts[0]?.toLowerCase();
+    const modal = cfg.wiki.embedding.modal ?? {};
+    if (!key) {
+        const tokenSrc = process.env[MODAL_TOKEN_ENV]
+            ? `env ${MODAL_TOKEN_ENV} ✅`
+            : modal.apiToken
+                ? "config (set PVM_API_TOKEN env to override)"
+                : "❌ none (set PVM_API_TOKEN env)";
+        const lines = [
+            "**Modal Config:**",
+            "",
+            `  baseUrl: ${modal.baseUrl || "❌ not set"}`,
+            `  model: ${modal.model || "(default embeddinggemma)"}`,
+            `  dim: ${modal.dim ?? "(native)"}`,
+            `  token: ${tokenSrc}`,
+            `  fallback: ${modal.fallback?.enabled === false ? "disabled" : modal.fallback?.provider || "(none)"}`,
+            `  sync: ${JSON.stringify(modal.sync ?? {})}`,
+            `  coalesce: ${JSON.stringify(cfg.wiki.embedding.coalesce ?? {})}`,
+        ];
+        ctx.ui.notify(lines.join("\n"), "info");
+        return;
+    }
+    const obj = readProjectConfig(cfgPath);
+    const m = modalSection(obj);
+    const setNum = (target, k, v) => {
+        const n = Number.parseInt(v, 10);
+        if (!Number.isFinite(n)) {
+            ctx.ui.notify(`Invalid number for ${k}: ${v}`, "error");
+            return false;
+        }
+        target[k] = n;
+        return true;
+    };
+    switch (key) {
+        case "baseurl":
+        case "url": {
+            const url = parts[1];
+            if (!url) {
+                ctx.ui.notify("/wiki modal config baseUrl <url>", "error");
+                return;
+            }
+            m.baseUrl = url.replace(/\/$/, "");
+            writeProjectConfig(cfgPath, obj);
+            ctx.ui.notify(`✅ Modal baseUrl set to ${m.baseUrl}`, "info");
+            return;
+        }
+        case "model": {
+            if (!parts[1]) {
+                ctx.ui.notify("/wiki modal config model <name>", "error");
+                return;
+            }
+            m.model = parts[1];
+            writeProjectConfig(cfgPath, obj);
+            ctx.ui.notify(`✅ Modal model set to ${parts[1]}`, "info");
+            return;
+        }
+        case "dim": {
+            if (!setNum(m, "dim", parts[1] ?? ""))
+                return;
+            writeProjectConfig(cfgPath, obj);
+            ctx.ui.notify(`✅ Modal dim set to ${m.dim}`, "info");
+            return;
+        }
+        case "fallback": {
+            const v = parts[1]?.toLowerCase();
+            if (v === "none") {
+                m.fallback = { enabled: false };
+            }
+            else if (v === "ollama" || v === "transformers") {
+                m.fallback = { enabled: true, provider: v };
+            }
+            else {
+                ctx.ui.notify("/wiki modal config fallback <ollama|transformers|none>", "error");
+                return;
+            }
+            writeProjectConfig(cfgPath, obj);
+            ctx.ui.notify(`✅ Modal fallback set to ${v}`, "info");
+            return;
+        }
+        case "sync": {
+            const sub = parts[1]?.toLowerCase();
+            const val = parts[2]?.toLowerCase();
+            const sync = m.sync || {};
+            if (sub === "auto") {
+                sync.autoSync = val === "on" || val === "true";
+            }
+            else if (sub === "interval") {
+                if (!setNum(sync, "autoSyncIntervalMs", parts[2] ?? ""))
+                    return;
+            }
+            else if (sub === "pagesize") {
+                if (!setNum(sync, "pageSize", parts[2] ?? ""))
+                    return;
+            }
+            else if (sub === "collections") {
+                sync.collections = parts.slice(2);
+            }
+            else {
+                ctx.ui.notify("/wiki modal config sync <auto on|off|interval <ms>|pageSize <n>|collections ...>", "error");
+                return;
+            }
+            m.sync = sync;
+            writeProjectConfig(cfgPath, obj);
+            ctx.ui.notify(`✅ Modal sync.${sub} updated`, "info");
+            return;
+        }
+        case "coalesce": {
+            const sub = parts[1]?.toLowerCase();
+            const wiki = obj.wiki || {};
+            const emb = wiki.embedding || {};
+            const co = emb.coalesce || {};
+            if (sub === "debounce") {
+                if (!setNum(co, "debounceMs", parts[2] ?? ""))
+                    return;
+            }
+            else if (sub === "batch") {
+                if (!setNum(co, "maxBatchSize", parts[2] ?? ""))
+                    return;
+            }
+            else if (sub === "concurrency") {
+                if (!setNum(co, "maxConcurrentFlushes", parts[2] ?? ""))
+                    return;
+            }
+            else {
+                ctx.ui.notify("/wiki modal config coalesce <debounce|batch|concurrency> <n>", "error");
+                return;
+            }
+            emb.coalesce = co;
+            writeProjectConfig(cfgPath, obj);
+            ctx.ui.notify(`✅ Modal coalesce.${sub} updated`, "info");
+            return;
+        }
+        case "token": {
+            ctx.ui.notify(`Token resolution: env ${MODAL_TOKEN_ENV} is preferred (never committed).\nSet it in your shell: export ${MODAL_TOKEN_ENV}=...\nConfig wiki.embedding.modal.apiToken is a fallback only.`, "info");
+            return;
+        }
+        default:
+            ctx.ui.notify(MODAL_CONFIG_USAGE, "info");
+    }
+};
+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.wiki.embedding.modal;
+            const tokenSrc = process.env[MODAL_TOKEN_ENV]
+                ? `env ${MODAL_TOKEN_ENV} ✅`
+                : modal?.apiToken
+                    ? "config"
+                    : "❌ none";
+            const lines = [
+                "**Modal Status**",
+                "",
+                `Configured: ${isModalConfigured(cfg.wiki) ? "✅" : "❌"}`,
+                `  baseUrl: ${modal?.baseUrl || "(not set)"}`,
+                `  model: ${modal?.model || "(default embeddinggemma)"}`,
+                `  dim: ${modal?.dim ?? "(native)"}`,
+                `  token: ${tokenSrc}`,
+            ];
+            const client = createModalClient(cfg.wiki);
+            if (client) {
+                try {
+                    const health = await client.health();
+                    lines.push("", `Health: ✅ ok, default_model=${health.default_model}`);
+                }
+                catch (err) {
+                    lines.push("", `Health: ❌ ${err.message}`);
+                }
+                try {
+                    const cols = await client.syncCollections();
+                    lines.push("", `Remote collections (${cols.length}):`);
+                    for (const c of cols)
+                        lines.push(`  • ${c.collection} / ${c.model} / ${c.dim} — ${c.rows} rows (${c.table})`);
+                }
+                catch (err) {
+                    lines.push("", `Remote collections: ❌ ${err.message}`);
+                }
+            }
+            ctx.ui.notify(lines.join("\n"), "info");
+            return;
+        }
+        case "config":
+            await handleModalConfig(rest, ctx);
+            return;
+        case "sync": {
+            if (!isModalConfigured(cfg.wiki)) {
+                ctx.ui.notify(`Modal not configured. Set baseUrl + ${MODAL_TOKEN_ENV} first.`, "error");
+                return;
+            }
+            const syncTokens = rest.split(/\s+/).filter(Boolean);
+            const full = syncTokens.includes("--full");
+            const colFlagIdx = syncTokens.indexOf("--collection");
+            const oneCollection = colFlagIdx >= 0 ? syncTokens[colFlagIdx + 1] : undefined;
+            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 });
+                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)" : ""}`);
+                lines.push("", "Re-running with no new rows is a no-op.");
+                ctx.ui.notify(lines.join("\n"), "info");
+            }
+            catch (err) {
+                ctx.ui.notify(`Sync failed: ${err.message}`, "error");
+            }
+            return;
+        }
+        case "jobs": {
+            const jobId = parts[1];
+            if (!jobId) {
+                ctx.ui.notify("/wiki modal jobs <job_id>  — poll a Modal bulk job.\n(Server-side job listing is pending upstream.)", "info");
+                return;
+            }
+            const client = createModalClient(cfg.wiki);
+            if (!client) {
+                ctx.ui.notify("Modal not configured.", "error");
+                return;
+            }
+            try {
+                const status = await client.jobStatus(jobId);
+                ctx.ui.notify([
+                    `Job ${jobId}:`,
+                    `  status: ${status.status}`,
+                    `  collection: ${status.collection}`,
+                    `  model: ${status.model} / dim ${status.dim}`,
+                    `  processed: ${status.processed}/${status.total}`,
+                    ...(status.error ? [`  error: ${status.error}`] : []),
+                ].join("\n"), "info");
+            }
+            catch (err) {
+                ctx.ui.notify(`Job poll failed: ${err.message}`, "error");
+            }
+            return;
+        }
+        case "migrate": {
+            const newModel = parts[1];
+            if (!newModel) {
+                ctx.ui.notify("/wiki modal migrate <newModel> [dim]  — change the canonical model + re-embed (remote).\nOld namespace is left intact until verified.", "info");
+                return;
+            }
+            const newDim = parts[2] ? Number.parseInt(parts[2], 10) : undefined;
+            if (parts[2] && !Number.isFinite(newDim)) {
+                ctx.ui.notify(`Invalid dim: ${parts[2]}`, "error");
+                return;
+            }
+            const { project: cfgPath } = findConfig(ctx.cwd);
+            if (!cfgPath) {
+                ctx.ui.notify("No config found.", "error");
+                return;
+            }
+            const obj = readProjectConfig(cfgPath);
+            const m = modalSection(obj);
+            const oldModel = m.model || "embeddinggemma";
+            const oldDim = m.dim;
+            m.model = newModel;
+            if (newDim != null)
+                m.dim = newDim;
+            writeProjectConfig(cfgPath, obj);
+            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 lines = [`**Migration → ${newModel}:**`, ""];
+                for (const r of results)
+                    if (r.error)
+                        lines.push(`  ❌ ${r.collection}: ${r.error}`);
+                    else
+                        lines.push(`  ✅ ${r.collection}: synced ${r.sync?.rows ?? 0} rows`);
+                lines.push("", `Old col_*__${oldModel}__* tables are untouched. Verify the new space, then drop the old table(s) when ready.`);
+                ctx.ui.notify(lines.join("\n"), "info");
+            }
+            catch (err) {
+                ctx.ui.notify(`Migration re-embed failed: ${err.message}`, "error");
+            }
+            return;
+        }
+        default:
+            ctx.ui.notify("Unknown /wiki modal subcommand. Try: status, config, sync, jobs, migrate", "error");
+    }
+};
 // ── /wiki context ────────────────────────────────────────────────────────────
 const handleContext = async (args, ctx, pi) => {
     const parts = args.trim().split(/\s+/g);
@@ -723,6 +1169,7 @@ export const registerCommands = (pi) => {
                 "injector",
                 "context",
                 "embedding",
+                "modal",
                 "watcher",
                 "setup",
             ];
@@ -756,10 +1203,15 @@ export const registerCommands = (pi) => {
                         .map((c) => ({ label: c, value: c, description: `injector ${c}` }));
                 }
                 if (subcommand === "reindex") {
-                    return ["--all", "--reembed"]
+                    return ["--all", "--reembed", "--remote"]
                         .filter((c) => c.startsWith(prefix))
                         .map((c) => ({ label: c, value: c, description: `reindex ${c}` }));
                 }
+                if (subcommand === "modal") {
+                    return ["status", "config", "sync", "jobs", "migrate"]
+                        .filter((c) => c.startsWith(prefix))
+                        .map((c) => ({ label: c, value: c, description: `modal ${c}` }));
+                }
                 if (subcommand === "watcher") {
                     return ["start", "stop", "status"]
                         .filter((c) => c.startsWith(prefix))
@@ -798,6 +1250,8 @@ export const registerCommands = (pi) => {
                     return handleContext(rest, ctx, pi);
                 case "embedding":
                     return handleEmbedding(rest, ctx, pi);
+                case "modal":
+                    return handleModal(rest, ctx, pi);
                 case "server":
                     return handleServer(ctx);
                 case "watcher":

package/dist/src/embed-queue.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Local embedding request coalescer — debounce + batch.
+ *
+ * Collects individual embedding requests arriving within a short window and
+ * flushes them as a single batched call to the backend (`/embed` for the modal
+ * provider, `/api/embed` for ollama, etc.), so ingest/append never fires N tiny
+ * requests. Modeled on the watcher's coalescing in `src/watcher.ts`: a debounce
+ * window (≈1000ms), a max-batch early flush, and a `maxConcurrentFlushes` cap
+ * (the analog of `pendingQueue` + `maxConcurrent`).
+ *
+ * ──────────────────────────────────────────────────────────────────────────
+ * NOTE FOR AGENT B (extension integration — see docs/plans/agent-B-*.md #11):
+ *
+ *   This is a complete, dependency-free, unit-tested building block (see
+ *   test/embed-queue.test.ts). It is intentionally NOT wired into anything yet.
+ *   Wire it in `src/lance.ts` roughly like:
+ *
+ *     const coalescer = new EmbeddingCoalescer({
+ *       embedFn: (texts, task) => modalClient.embed(texts, { task }).then(r => r.vectors),
+ *       debounceMs: cfg.embedding.coalesce?.debounceMs ?? 1000,
+ *       maxBatchSize: cfg.embedding.coalesce?.maxBatchSize ?? 64,
+ *       maxConcurrentFlushes: cfg.embedding.coalesce?.maxConcurrent ?? 2,
+ *     });
+ *
+ *   ROUTING POLICY (yours to own, not baked in here):
+ *     - append / ingest / bulk → coalescer.embed(text, "document")   [debounced]
+ *     - interactive wiki_search → coalescer.embedImmediate(query, "query")
+ *       (latency-sensitive; bypasses the debounce)
+ *
+ *   It is provider-agnostic: `embedFn` can wrap modal, ollama, or transformers —
+ *   they all take a batch and return one vector per input. Batches are
+ *   homogeneous per `task` (queries and documents flush separately) because the
+ *   embedding endpoints take a single task per call.
+ *
+ *   Make the knobs configurable (Q6 in the decision log): debounceMs,
+ *   maxBatchSize, maxConcurrentFlushes, dedupe, and whether search bypasses.
+ *   Adapt the interface freely — this is a reference, not a contract.
+ * ──────────────────────────────────────────────────────────────────────────
+ */
+export type EmbedTask = "query" | "document";
+/** Batch embed backend: same texts in, one vector per text out, in order. */
+export type EmbedFn = (texts: string[], task: EmbedTask) => Promise<number[][]>;
+export interface CoalescerOptions {
+    embedFn: EmbedFn;
+    /** Window to gather requests before flushing (ms). Default 1000 (matches watcher). */
+    debounceMs?: number;
+    /** Flush immediately once a task's buffer reaches this size. Default 64. */
+    maxBatchSize?: number;
+    /** Max batched embedFn calls in flight at once. Default 2. */
+    maxConcurrentFlushes?: number;
+    /** Coalesce identical texts within a batch to a single embed. Default true. */
+    dedupe?: boolean;
+}
+export declare class EmbeddingCoalescer {
+    private readonly embedFn;
+    private readonly debounceMs;
+    private readonly maxBatchSize;
+    private readonly maxConcurrentFlushes;
+    private readonly dedupe;
+    private readonly buffers;
+    private readonly timers;
+    private active;
+    private readonly pendingFlushes;
+    private readonly inFlight;
+    constructor(opts: CoalescerOptions);
+    /** Queue a text for embedding; resolves with its vector once a batch flushes. */
+    embed(text: string, task?: EmbedTask): Promise<number[]>;
+    /** Bypass the debounce — embed a single text right now (for latency-sensitive search). */
+    embedImmediate(text: string, task?: EmbedTask): Promise<number[]>;
+    /** Number of requests currently buffered (not yet flushed). */
+    size(): number;
+    /** Flush all buffered tasks now, then await every in-flight batch to settle. */
+    drain(): Promise<void>;
+    /** Cancel pending debounce timers. Does not reject already-buffered waiters. */
+    dispose(): void;
+    private arm;
+    private flushTask;
+    private schedule;
+    private runBatch;
+}