pi-vault-mind 0.7.0

package/dist/src/commands.js

@@ -0,0 +1,813 @@
+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, } from "./utils.js";
+import { updateActiveCollectionWidget } from "./widget.js";
+import { connect, pullOllamaModel, testOllamaConnection } from "./lance.js";
+import { createServerState } from "./server.js";
+import { createCollectionWizard, createInjectorWizard, openSettingsDashboard, setupWizard, } from "./settings-ui.js";
+import { createWatcherState, getWatcherStatus, startWatcher, stopWatcher } from "./watcher.js";
+// ── Shared helpers ───────────────────────────────────────────────────────────
+const WIKI_USAGE = [
+    "**pi-vault-mind Commands**",
+    "",
+    "  /wiki init                  Scaffold config + collections",
+    "  /wiki validate              Check LanceDB, config, and collection health",
+    "  /wiki approve [collection]  Batch-review pending entries",
+    "  /wiki settings              Open interactive settings dashboard",
+    "  /wiki audit                 Audit config for missing defaults",
+    "  /wiki reindex               Rebuild FTS + vector indexes (replaces old /qmd-index)",
+    "  /wiki collection select     Select active collection",
+    "  /wiki collection create     Create a new collection (wizard)",
+    "  /wiki injector create       Create a new injector (wizard)",
+    "  /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 model       Set Ollama embedding model",
+    "  /wiki embedding models      List available Ollama models",
+    "  /wiki embedding pull        Pull a model from Ollama",
+    "  /wiki watcher start          Start passive file watcher",
+    "  /wiki watcher stop           Stop passive file watcher",
+    "  /wiki watcher status         Show watcher status",
+    "  /wiki server status          Show HTTP server status + port",
+    "  /wiki setup                  Interactive global config wizard",
+    "  /wiki setup --vault <path>   CLI: set vault path",
+    "  /wiki setup --provider <p>   CLI: set embedding provider",
+    "  /wiki 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 /wiki init first.", "info");
+        return;
+    }
+    const projectCfg = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+    const missingCollections = [];
+    const missingInjectors = [];
+    for (const name of Object.keys(DEFAULT_CONFIG.collections)) {
+        if (!projectCfg.collections?.[name])
+            missingCollections.push(name);
+    }
+    for (const ij of DEFAULT_CONFIG.injectors) {
+        if (!projectCfg.injectors?.some((pij) => pij.name === ij.name)) {
+            missingInjectors.push(ij.name);
+        }
+    }
+    if (missingCollections.length === 0 && missingInjectors.length === 0) {
+        ctx.ui.notify("✅ Project config is up-to-date with all default collections and injectors.", "info");
+        return;
+    }
+    const report = [
+        "**Config Audit Report**",
+        "",
+        `Project Config: ${path.relative(ctx.cwd, cfgPath)}`,
+        "",
+        `Missing Collections (${missingCollections.length}):`,
+        ...missingCollections.map((l) => `  • ${l}`),
+        "",
+        `Missing Injectors (${missingInjectors.length}):`,
+        ...missingInjectors.map((i) => `  • ${i}`),
+        "",
+        "Would you like to repair the config by adding the missing defaults?",
+    ].join("\n");
+    const repair = await ctx.ui.confirm("Repair Config", report);
+    if (repair) {
+        const updatedCfg = { ...projectCfg };
+        updatedCfg.collections = { ...(projectCfg.collections || {}), ...DEFAULT_CONFIG.collections };
+        const injectors = [...(projectCfg.injectors || [])];
+        for (const ij of DEFAULT_CONFIG.injectors) {
+            if (!injectors.some((pij) => pij.name === ij.name)) {
+                injectors.push(ij);
+            }
+        }
+        updatedCfg.injectors = injectors;
+        fs.writeFileSync(cfgPath, `${JSON.stringify(updatedCfg, null, 2)}\n`, "utf-8");
+        ctx.ui.notify("✅ Project config repaired with missing defaults.", "info");
+    }
+    else {
+        ctx.ui.notify("Audit complete. No changes made.", "info");
+    }
+};
+export const selectActiveCollection = async (ctx) => {
+    const cfg = loadConfig(ctx.cwd);
+    const names = collectionNames(cfg);
+    if (!ctx.hasUI) {
+        const next = names.find((n) => n !== getActiveCollection(ctx.cwd)) || names[0];
+        if (next) {
+            setActiveCollection(next);
+            updateActiveCollectionWidget(ctx);
+            ctx.ui.notify(`Active collection set to: ${next}`, "info");
+        }
+        return;
+    }
+    if (names.length === 0) {
+        ctx.ui.notify("No collections configured.", "warning");
+        return;
+    }
+    const items = names.map((name) => ({ label: name, value: name }));
+    const result = await ctx.ui.custom((tui, theme, _keybindings, done) => {
+        const container = new Container();
+        container.addChild(new Text(theme.fg("accent", "Select Active Collection"), 1, 1));
+        const selectList = new SelectList(items, Math.min(items.length, 10), {
+            selectedPrefix: (t) => theme.fg("accent", t),
+            selectedText: (t) => theme.fg("accent", t),
+            description: (t) => theme.fg("muted", t),
+            scrollInfo: (t) => theme.fg("dim", t),
+            noMatch: (t) => theme.fg("warning", t),
+        });
+        selectList.onSelect = (item) => done(item.value);
+        selectList.onCancel = () => done(null);
+        container.addChild(selectList);
+        container.addChild(new Text(theme.fg("dim", "↑↓ navigate • enter select • esc cancel"), 1, 0));
+        return {
+            render: (w) => container.render(w),
+            handleInput: (data) => {
+                selectList.handleInput?.(data);
+                tui.requestRender();
+            },
+            invalidate: () => container.invalidate(),
+        };
+    }, { overlay: true });
+    if (result) {
+        setActiveCollection(result);
+        updateActiveCollectionWidget(ctx);
+        ctx.ui.notify(`Active collection set to: ${result}`, "info");
+    }
+};
+// ── /wiki init ──────────────────────────────────────────────────────────────
+const handleInit = async (_args, ctx, pi) => {
+    const cfg = loadConfig(ctx.cwd);
+    const created = [];
+    const skipped = [];
+    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/main.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",
+                },
+            ],
+            wiki: {
+                dataDir: ".lancedb",
+                embedding: {
+                    provider: "transformers",
+                    ollamaModel: "embeddinggemma",
+                    ollamaHost: "http://127.0.0.1:11434",
+                },
+                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);
+    }
+    for (const [name, def] of Object.entries(cfg.collections)) {
+        ensureFile(def.path, name === "pending" ? "PENDING_LEDGER.jsonl" : "UCL_LEDGER.jsonl");
+    }
+    for (const ij of cfg.injectors) {
+        if (ij.artifactPath)
+            ensureFile(ij.artifactPath, "ARTIFACT.md");
+    }
+    const msg = [
+        "Wiki scaffolding complete.",
+        "",
+        "Created:",
+        ...created.map((c) => `  • ${path.relative(ctx.cwd, c)}`),
+    ];
+    if (skipped.length) {
+        msg.push("", "Skipped (already exist):", ...skipped.map((s) => `  • ${path.relative(ctx.cwd, s)}`));
+    }
+    msg.push("", '💡 Tip: Tell the agent "Remember: [fact]" to auto-append to the main collection!');
+    if (ctx.hasUI) {
+        ctx.ui.notify(msg.join("\n"), "info");
+        if (hasPiContextTools(pi)) {
+            const enable = await ctx.ui.confirm("Enable pi-context integration?", "pi-context tools were detected. Would you like to enable the integration now to capture session context?");
+            if (enable) {
+                const existing = JSON.parse(fs.readFileSync(cfgDest, "utf-8"));
+                existing.extensionCompatibility = existing.extensionCompatibility || {};
+                existing.extensionCompatibility["pi-context"] = {
+                    tagPatterns: [],
+                    enhanceInjectors: false,
+                    autoEnableAcm: true,
+                    indexContextEvents: true,
+                    ...existing.extensionCompatibility["pi-context"],
+                    enabled: true,
+                };
+                fs.writeFileSync(cfgDest, `${JSON.stringify(existing, null, 2)}\n`, "utf-8");
+                ctx.ui.notify("✅ pi-context integration ENABLED in config", "info");
+            }
+        }
+    }
+};
+// ── /wiki validate ───────────────────────────────────────────────────────────
+const handleValidate = async (_args, ctx, pi) => {
+    const cfg = loadConfig(ctx.cwd);
+    const lines = [];
+    try {
+        await connect(cfg.wiki.dataDir);
+        lines.push(`✅ LanceDB: Connected to ${cfg.wiki.dataDir}`);
+    }
+    catch (err) {
+        lines.push(`❌ LanceDB: Connection failed. ${err.message}`);
+    }
+    // Check LanceDB tables
+    try {
+        const db = await connect(cfg.wiki.dataDir);
+        const tableNames = await db.tableNames();
+        lines.push(`📊 LanceDB tables: ${tableNames.length > 0 ? tableNames.join(", ") : "(none — created on first append)"}`);
+    }
+    catch { }
+    const { project: cfgPath } = findConfig(ctx.cwd);
+    lines.push(cfgPath ? `✅ Config: ${cfgPath}` : `⚠️  No config file (checked ${CONFIG_FILES.join(", ")}).`);
+    for (const [name, def] of Object.entries(cfg.collections)) {
+        const exists = fs.existsSync(def.path);
+        lines.push(`${exists ? "✅" : "⚠️"} Collection "${name}": ${def.path} ${exists ? "" : "(missing)"}`);
+        if (exists && def.dedupField)
+            lines.push(`   └─ dedupField: ${def.dedupField}`);
+    }
+    lines.push(`📡 Injectors (${cfg.injectors.length}):`);
+    for (const ij of cfg.injectors) {
+        lines.push(`   • "${ij.name}" → collection:"${ij.collection}" regex:${ij.regex}`);
+    }
+    const hasContext = hasPiContextTools(pi);
+    const contextCfg = getPiContextConfig(cfg);
+    const willCapture = hasContext && contextCfg.enabled;
+    lines.push("", "🧩 Extension Integrations:", "   • pi-context:");
+    lines.push(`       - Tools installed: ${hasContext ? "✅ Yes (context_tag, context_log, context_checkout)" : "❌ No"}`);
+    lines.push(`       - Config enabled: ${contextCfg.enabled ? "✅ Yes" : "❌ No"}`);
+    lines.push(`       - Will capture events: ${willCapture ? "✅ Yes — on next turn" : "❌ No"}`);
+    if (hasContext && !contextCfg.enabled)
+        lines.push("       → Run /wiki context enable to activate");
+    if (!hasContext && contextCfg.enabled)
+        lines.push("       ⚠️  Config says enabled but tools missing. Install with: pi install npm:pi-context");
+    if (ctx.hasUI)
+        ctx.ui.notify(lines.join("\n"), "info");
+};
+// ── /wiki approve ────────────────────────────────────────────────────────────
+const handleApprove = async (args, ctx) => {
+    const cfg = loadConfig(ctx.cwd);
+    const pending = cfg.collections.pending;
+    if (!pending || !fs.existsSync(pending.path)) {
+        ctx.ui.notify("No pending collection configured or empty.", "info");
+        return;
+    }
+    const targetName = args.trim() || "main";
+    const target = cfg.collections[targetName];
+    if (!target) {
+        ctx.ui.notify(`Unknown target collection "${targetName}".`, "error");
+        return;
+    }
+    const lines = fs.readFileSync(pending.path, "utf-8").split("\n").filter(Boolean);
+    if (lines.length === 0) {
+        ctx.ui.notify("No pending entries.", "info");
+        return;
+    }
+    let approved = 0;
+    const rejected = [];
+    for (const line of lines) {
+        const ok = await ctx.ui.confirm("Pending Entry", `${line}\n\nApprove migration to "${targetName}"?`);
+        if (ok) {
+            let actualTargetName = targetName;
+            try {
+                const entry = JSON.parse(line);
+                if (entry._promotion_target)
+                    actualTargetName = entry._promotion_target;
+            }
+            catch { }
+            const actualTarget = cfg.collections[actualTargetName];
+            if (!actualTarget) {
+                ctx.ui.notify(`Promotion target "${actualTargetName}" is no longer valid.`, "error");
+                continue;
+            }
+            ensureDir(actualTarget.path);
+            fs.appendFileSync(actualTarget.path, `${line}\n`);
+            approved++;
+        }
+        else {
+            rejected.push(line);
+        }
+    }
+    fs.writeFileSync(pending.path, rejected.join("\n") + (rejected.length > 0 ? "\n" : ""));
+    ctx.ui.notify(`Approved ${approved} → "${targetName}". Rejected ${rejected.length}.`, "info");
+};
+// ── /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;
+    ctx.ui.notify(rebuildEmbeddings
+        ? "Reindexing: regenerating embeddings + rebuilding indexes..."
+        : "Reindexing: rebuilding FTS + vector indexes...", "info");
+    const lines = [];
+    const names = collectionFilter ? [collectionFilter] : Object.keys(cfg.collections);
+    for (const name of names) {
+        if (!cfg.collections[name])
+            continue;
+        const tableName = `collection_${name}`;
+        try {
+            const db = await connect(cfg.wiki.dataDir);
+            const existing = await db.tableNames();
+            if (!existing.includes(tableName)) {
+                lines.push(`  ⚠️  ${tableName}: table not found (created on first append)`);
+                continue;
+            }
+            const table = await db.openTable(tableName);
+            // If --reembed, drop and recreate with fresh embeddings
+            if (rebuildEmbeddings) {
+                // Read all existing rows
+                const rows = await table.query().toArray();
+                lines.push(`  📦 ${tableName}: ${rows.length} rows — re-embedding...`);
+                // Drop and recreate (LanceDB auto-embeds on add)
+                await db.dropTable(tableName);
+                // The table will be recreated on next append/upsert with current embedding config
+                lines.push(`  ✅ ${tableName}: dropped — will re-embed on next append`);
+            }
+            else {
+                // Rebuild FTS index
+                try {
+                    if (cfg.wiki.ftsEnabled !== false) {
+                        await table.createIndex("fact", { config: lancedb.Index.fts(), replace: true });
+                        lines.push(`  ✅ ${tableName}: FTS index rebuilt`);
+                    }
+                }
+                catch (err) {
+                    lines.push(`  ⚠️  ${tableName}: FTS reindex failed — ${err.message}`);
+                }
+                // Rebuild vector ANN index for larger tables
+                try {
+                    const count = await table.countRows();
+                    if (count > 1000) {
+                        await table.createIndex("vector");
+                        lines.push(`  ✅ ${tableName}: vector ANN index created (${count} rows)`);
+                    }
+                }
+                catch (err) {
+                    lines.push(`  ⚠️  ${tableName}: vector index skipped — ${err.message}`);
+                }
+            }
+        }
+        catch (err) {
+            lines.push(`  ❌ ${tableName}: ${err.message}`);
+        }
+    }
+    // Also reindex graph tables if --all
+    if (reindexAll) {
+        for (const graphTable of ["entities", "relations"]) {
+            try {
+                const db = await connect(cfg.wiki.dataDir);
+                const existing = await db.tableNames();
+                if (existing.includes(graphTable)) {
+                    const table = await db.openTable(graphTable);
+                    if (rebuildEmbeddings) {
+                        const rows = await table.query().toArray();
+                        lines.push(`  📦 ${graphTable}: ${rows.length} rows — re-embedding...`);
+                        await db.dropTable(graphTable);
+                    }
+                }
+            }
+            catch (err) {
+                lines.push(`  ⚠️  ${graphTable}: ${err.message}`);
+            }
+        }
+    }
+    lines.unshift("**Reindex Report:**", "");
+    lines.push("", rebuildEmbeddings
+        ? "Entries will be re-embedded with current embedding model on next append."
+        : "Use /wiki reindex --reembed to regenerate embeddings after model switch.");
+    ctx.ui.notify(lines.join("\n"), "info");
+};
+// ── /wiki embedding ──────────────────────────────────────────────────────────
+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 { project: cfgPath } = findConfig(ctx.cwd);
+    if (!cfgPath) {
+        ctx.ui.notify("No config found. Run /wiki init first.", "error");
+        return;
+    }
+    switch (subcommand) {
+        case "status": {
+            const lines = [
+                "**Embedding Configuration**",
+                "",
+                `Provider: ${cfg.wiki.embedding.provider}`,
+                cfg.wiki.embedding.provider === "ollama"
+                    ? `Model: ${cfg.wiki.embedding.ollamaModel || "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) {
+                const conn = await testOllamaConnection(pi);
+                lines.push("", "**Ollama Status:**", `  Reachable: ${conn.reachable ? "✅ Yes" : "❌ No"}`);
+                if (conn.error)
+                    lines.push(`  Error: ${conn.error}`);
+                if (conn.models.length > 0) {
+                    lines.push(`  Available models (${conn.models.length}):`);
+                    for (const m of conn.models.slice(0, 10)) {
+                        const isCurrent = m.name === cfg.wiki.embedding.ollamaModel;
+                        lines.push(`    ${isCurrent ? "★" : " "} ${m.name} (${m.size})`);
+                    }
+                    if (conn.models.length > 10)
+                        lines.push(`    ... and ${conn.models.length - 10} more`);
+                }
+                else {
+                    lines.push("  No models found. Pull one with: /wiki embedding pull embeddinggemma");
+                }
+            }
+            else {
+                lines.push("", "**Transformers:** Using Xenova/all-MiniLM-L6-v2 (384 dims)", "  Downloads on first use and caches locally.");
+            }
+            ctx.ui.notify(lines.join("\n"), "info");
+            return;
+        }
+        case "use": {
+            if (!value || !["ollama", "transformers"].includes(value)) {
+                ctx.ui.notify("/wiki embedding use <ollama|transformers>", "error");
+                return;
+            }
+            if (value === "ollama") {
+                const conn = await testOllamaConnection(pi);
+                if (!conn.reachable) {
+                    const confirm = await ctx.ui.confirm("Ollama Not Reachable", "Cannot connect to Ollama. Switch anyway?\n\nVerify with:\n  ollama list\n  ollama pull embeddinggemma");
+                    if (!confirm)
+                        return;
+                }
+            }
+            const existing = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+            existing.wiki = existing.wiki || {};
+            existing.wiki.embedding = existing.wiki.embedding || {};
+            existing.wiki.embedding.provider = value;
+            fs.writeFileSync(cfgPath, `${JSON.stringify(existing, null, 2)}\n`, "utf-8");
+            ctx.ui.notify(`✅ Embedding provider set to: ${value}. Restart session for changes to take effect.`, "info");
+            return;
+        }
+        case "model": {
+            if (!value) {
+                ctx.ui.notify(`Current: ${cfg.wiki.embedding.ollamaModel || "embeddinggemma"}. Usage: /wiki embedding model <name>`, "info");
+                return;
+            }
+            const existing = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+            existing.wiki = existing.wiki || {};
+            existing.wiki.embedding = existing.wiki.embedding || {};
+            existing.wiki.embedding.ollamaModel = value;
+            fs.writeFileSync(cfgPath, `${JSON.stringify(existing, null, 2)}\n`, "utf-8");
+            ctx.ui.notify(`✅ Ollama embedding model set to: ${value}`, "info");
+            return;
+        }
+        case "models": {
+            const conn = await testOllamaConnection(pi);
+            if (!conn.reachable) {
+                ctx.ui.notify("❌ Ollama not reachable.", "error");
+                return;
+            }
+            if (conn.models.length === 0) {
+                ctx.ui.notify("No models found. Pull one with: /wiki embedding pull embeddinggemma", "info");
+                return;
+            }
+            const lines = ["**Available Ollama Models:**", ""];
+            for (const m of conn.models) {
+                lines.push(`  ${m.name === cfg.wiki.embedding.ollamaModel ? "★" : " "} ${m.name} (${m.size})`);
+            }
+            ctx.ui.notify(lines.join("\n"), "info");
+            return;
+        }
+        case "pull": {
+            if (!value) {
+                ctx.ui.notify("/wiki embedding pull <model>. Try: embeddinggemma", "error");
+                return;
+            }
+            ctx.ui.notify(`Pulling "${value}" from Ollama... (this may take a while)`, "info");
+            const result = await pullOllamaModel(value, pi);
+            ctx.ui.notify(result.message, result.success ? "info" : "error");
+            return;
+        }
+        default: {
+            ctx.ui.notify(`Unknown: ${subcommand}. Try: status, use, model, models, pull`, "error");
+            return;
+        }
+    }
+};
+// ── /wiki context ────────────────────────────────────────────────────────────
+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 { project: cfgPath } = findConfig(ctx.cwd);
+    if (!cfgPath) {
+        ctx.ui.notify("No config found. Run /wiki init first.", "error");
+        return;
+    }
+    switch (subcommand) {
+        case "status":
+        case "show": {
+            const cfg = loadConfig(ctx.cwd);
+            const piContextCfg = getPiContextConfig(cfg);
+            const hasTools = hasPiContextTools(pi);
+            const willCapture = hasTools && piContextCfg.enabled;
+            const lines = [
+                "**pi-context Integration**",
+                "",
+                `Status: ${willCapture ? "✅ ACTIVE" : "❌ INACTIVE"}`,
+                `  - Tools installed: ${hasTools ? "✅" : "❌"}`,
+                `  - Config enabled: ${piContextCfg.enabled ? "✅" : "❌"}`,
+                `  - Will capture on next turn: ${willCapture ? "✅ Yes" : "❌ No"}`,
+                "",
+                `Tag Patterns: ${piContextCfg.tagPatterns?.length || 0}`,
+                ...(piContextCfg.tagPatterns?.length
+                    ? piContextCfg.tagPatterns.map((p) => `  • "${p}"`)
+                    : ["  (none — no tag-based lookups)"]),
+                "",
+                `Enhance Injectors: ${piContextCfg.enhanceInjectors ? "Yes" : "No"}`,
+                `autoEnableAcm: ${piContextCfg.autoEnableAcm ? "Yes" : "No"}`,
+                `indexContextEvents: ${piContextCfg.indexContextEvents ? "Yes" : "No"}`,
+            ];
+            ctx.ui.notify(lines.join("\n"), willCapture ? "info" : "warning");
+            return;
+        }
+        case "enable": {
+            _toggleContext(cfgPath, true);
+            ctx.ui.notify("✅ pi-context integration ENABLED", "info");
+            return;
+        }
+        case "disable": {
+            _toggleContext(cfgPath, false);
+            ctx.ui.notify("pi-context integration DISABLED", "info");
+            return;
+        }
+        default: {
+            if (["enable", "on", "true", "yes", "1"].includes(subcommand)) {
+                _toggleContext(cfgPath, true);
+                ctx.ui.notify("✅ pi-context integration ENABLED", "info");
+                return;
+            }
+            if (["disable", "off", "false", "no", "0"].includes(subcommand)) {
+                _toggleContext(cfgPath, false);
+                ctx.ui.notify("pi-context integration DISABLED", "info");
+                return;
+            }
+            ctx.ui.notify(`Unknown: ${subcommand}. Try: status, enable, disable`, "error");
+        }
+    }
+};
+const _toggleContext = (cfgPath, enabled) => {
+    const existing = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+    existing.extensionCompatibility = existing.extensionCompatibility || {};
+    existing.extensionCompatibility["pi-context"] = {
+        tagPatterns: [],
+        enhanceInjectors: false,
+        autoEnableAcm: true,
+        indexContextEvents: true,
+        ...existing.extensionCompatibility["pi-context"],
+        enabled,
+    };
+    fs.writeFileSync(cfgPath, `${JSON.stringify(existing, null, 2)}\n`, "utf-8");
+};
+// ── /wiki collection ─────────────────────────────────────────────────────────────
+const handleCollection = async (args, ctx) => {
+    const parts = args.trim().split(/\s+/g);
+    const subcommand = parts[0]?.toLowerCase() || "select";
+    switch (subcommand) {
+        case "select":
+            await selectActiveCollection(ctx);
+            return;
+        case "create":
+            await createCollectionWizard(ctx);
+            return;
+        default:
+            ctx.ui.notify(`Unknown: ${subcommand}. Try: select, create`, "error");
+    }
+};
+// ── /wiki injector ───────────────────────────────────────────────────────────
+const handleInjector = async (args, ctx) => {
+    const parts = args.trim().split(/\s+/g);
+    const subcommand = parts[0]?.toLowerCase() || "create";
+    switch (subcommand) {
+        case "create":
+            await createInjectorWizard(ctx);
+            return;
+        default:
+            ctx.ui.notify(`Unknown: ${subcommand}. Try: create`, "error");
+    }
+};
+// ── Watcher ──────────────────────────────────────────────────────────────────
+export const watcherState = createWatcherState();
+/** Module-level server state, referenced by the /wiki server command.
+ *  Port is set when the server starts in index.ts. */
+export const serverState = createServerState();
+const handleServer = (ctx) => {
+    const lines = [
+        `HTTP server: ${serverState.server ? "RUNNING" : "STOPPED"}`,
+        `Port: ${serverState.port}`,
+        "Bind: 127.0.0.1",
+    ];
+    if (serverState.startTime > 0) {
+        const uptime = Math.floor((Date.now() - serverState.startTime) / 1000);
+        lines.push(`Uptime: ${uptime}s`);
+        lines.push("");
+        lines.push("Endpoints:");
+        lines.push(`  GET  http://127.0.0.1:${serverState.port}/vault-mind/status`);
+        lines.push(`  POST http://127.0.0.1:${serverState.port}/vault-mind/scan`);
+        lines.push(`  POST http://127.0.0.1:${serverState.port}/vault-mind/dispatch`);
+    }
+    ctx.ui.notify(lines.join("\n"), "info");
+};
+const handleWatcher = async (args, ctx, pi) => {
+    const parts = args.trim().split(/\s+/g);
+    const subcommand = parts[0]?.toLowerCase() || "status";
+    switch (subcommand) {
+        case "start": {
+            const cfg = loadConfig(ctx.cwd);
+            if (!cfg.wiki.vaults || Object.keys(cfg.wiki.vaults).length === 0) {
+                ctx.ui.notify("No vaults configured. Add vaults to wiki.vaults in pi-vault-mind.config.json first.", "error");
+                return;
+            }
+            if (watcherState.running) {
+                ctx.ui.notify("Watcher is already running.", "info");
+                return;
+            }
+            startWatcher(pi, cfg.wiki.vaults, watcherState);
+            ctx.ui.notify(getWatcherStatus(watcherState), "info");
+            return;
+        }
+        case "stop": {
+            if (!watcherState.running) {
+                ctx.ui.notify("Watcher is not running.", "info");
+                return;
+            }
+            stopWatcher(watcherState);
+            ctx.ui.notify("Watcher stopped.", "info");
+            return;
+        }
+        default: {
+            ctx.ui.notify(getWatcherStatus(watcherState), "info");
+            return;
+        }
+    }
+};
+// ── Setup ────────────────────────────────────────────────────────────────────
+const handleSetup = async (args, ctx) => {
+    // Parse optional CLI-style args: --vault <path> --provider <name> --model <name>
+    const cliArgs = {};
+    const parts = args.trim().split(/\s+--/);
+    for (const part of parts) {
+        const trimmed = part.trim();
+        if (trimmed.startsWith("vault "))
+            cliArgs.vault = trimmed.slice(6).trim();
+        else if (trimmed === "vault") {
+            /* flag without value, handled by interactive */
+        }
+        else if (trimmed.startsWith("provider "))
+            cliArgs.provider = trimmed.slice(9).trim();
+        else if (trimmed.startsWith("model "))
+            cliArgs.model = trimmed.slice(6).trim();
+    }
+    const hasCliArgs = cliArgs.vault || cliArgs.provider || cliArgs.model;
+    await setupWizard(ctx, hasCliArgs ? cliArgs : undefined);
+};
+// ── Main /wiki command ───────────────────────────────────────────────────────
+export const registerCommands = (pi) => {
+    pi.registerCommand("wiki", {
+        description: "pi-vault-mind: manage collections, embedding, reindexing, and config.",
+        getArgumentCompletions: (_prefix) => {
+            const words = _prefix.trim().split(/\s+/);
+            const top = [
+                "init",
+                "validate",
+                "approve",
+                "settings",
+                "audit",
+                "help",
+                "reindex",
+                "collection",
+                "injector",
+                "context",
+                "embedding",
+                "watcher",
+                "setup",
+            ];
+            if (words.length === 1 || (words.length === 2 && words[1] === "")) {
+                return top
+                    .filter((c) => c.startsWith(words[0] || ""))
+                    .map((c) => ({ label: c, value: c, description: `wiki ${c}` }));
+            }
+            // Subcommand completions
+            const subcommand = words[0];
+            if (words.length >= 2) {
+                const prefix = words[1] || "";
+                if (subcommand === "embedding") {
+                    return ["status", "use", "model", "models", "pull"]
+                        .filter((c) => c.startsWith(prefix))
+                        .map((c) => ({ label: c, value: c, description: `embedding ${c}` }));
+                }
+                if (subcommand === "context") {
+                    return ["status", "enable", "disable"]
+                        .filter((c) => c.startsWith(prefix))
+                        .map((c) => ({ label: c, value: c, description: `context ${c}` }));
+                }
+                if (subcommand === "collection") {
+                    return ["select", "create"]
+                        .filter((c) => c.startsWith(prefix))
+                        .map((c) => ({ label: c, value: c, description: `collection ${c}` }));
+                }
+                if (subcommand === "injector") {
+                    return ["create"]
+                        .filter((c) => c.startsWith(prefix))
+                        .map((c) => ({ label: c, value: c, description: `injector ${c}` }));
+                }
+                if (subcommand === "reindex") {
+                    return ["--all", "--reembed"]
+                        .filter((c) => c.startsWith(prefix))
+                        .map((c) => ({ label: c, value: c, description: `reindex ${c}` }));
+                }
+                if (subcommand === "watcher") {
+                    return ["start", "stop", "status"]
+                        .filter((c) => c.startsWith(prefix))
+                        .map((c) => ({ label: c, value: c, description: `watcher ${c}` }));
+                }
+                if (subcommand === "setup") {
+                    return ["--vault", "--provider", "--model"]
+                        .filter((c) => c.startsWith(prefix))
+                        .map((c) => ({ label: c, value: c, description: `setup ${c}` }));
+                }
+            }
+            return [];
+        },
+        handler: async (args, ctx) => {
+            const parts = args.trim().split(/\s+/g);
+            const subcommand = parts[0]?.toLowerCase() || "help";
+            const rest = parts.slice(1).join(" ");
+            switch (subcommand) {
+                case "init":
+                    return handleInit(rest, ctx, pi);
+                case "validate":
+                    return handleValidate(rest, ctx, pi);
+                case "approve":
+                    return handleApprove(rest, ctx);
+                case "settings":
+                    return openSettingsDashboard(ctx);
+                case "audit":
+                    return auditConfig(ctx);
+                case "reindex":
+                    return handleReindex(rest, ctx, pi);
+                case "collection":
+                    return handleCollection(rest, ctx);
+                case "injector":
+                    return handleInjector(rest, ctx);
+                case "context":
+                    return handleContext(rest, ctx, pi);
+                case "embedding":
+                    return handleEmbedding(rest, ctx, pi);
+                case "server":
+                    return handleServer(ctx);
+                case "watcher":
+                    return handleWatcher(rest, ctx, pi);
+                case "setup":
+                    return handleSetup(rest, ctx);
+                default:
+                    ctx.ui.notify(WIKI_USAGE, "info");
+            }
+        },
+    });
+    // Legacy aliases — /wiki-* commands delegate to /wiki subcommand handlers
+};