pi-vault-mind 0.8.0 → 0.8.3

package/dist/src/index.js

@@ -1,72 +1,111 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { MessageBus } from "./agent-bus/MessageBus.js";
+import { TaskQueue } from "./agent-bus/TaskQueue.js";
 import { startAutoSync } from "./autosync.js";
+import { createBridge } from "./bridge.js";
 import { registerCommands, selectActiveCollection, serverState, watcherState } from "./commands.js";
+import { enableACM } from "./context-capture.js";
+import { startEngine, stopEngine } from "./engine.js";
 import { handleBeforeAgentStart, handleTurnEnd } from "./events.js";
+import { registerIdentityInjector } from "./identity-injector.js";
 import { registerIntakeTool } from "./intake.js";
 import { startServer, stopServer } from "./server.js";
+import { clearEngineStatus, clearWatcherStatus, registerStatusCapture, setEngineStatus, } from "./status.js";
 import { registerTools } from "./tools.js";
 import { EXT_ROOT } from "./utils.js";
 import { loadConfig } from "./utils.js";
-import { startWatcher, stopWatcher } from "./watcher.js";
+import { registerVaultTools } from "./vault-tools.js";
+import { registerAllExtensionTools } from "./vm-handlers.js";
+import { startWatcher, stopWatcher, subscribeJobCompleted } from "./watcher.js";
 import { updateActiveCollectionWidget } from "./widget.js";
 let stopAutoSync = null;
+let engineState = null;
 export default function (pi) {
-    /* expose skills directory */
+    /* expose skills directory — event listener only, safe during load */
     pi.on("resources_discover", async (_event) => {
         const skillsDir = path.join(EXT_ROOT, "skills");
         return fs.existsSync(skillsDir) ? { skillPaths: [skillsDir] } : {};
     });
+    /* Defer all action-method calls to session_start.
+     * pi 0.79.9+ rejects pi.registerCommand/registerTool/registerShortcut
+     * during extension loading — the runtime must be initialized first. */
     pi.on("session_start", async (_event, ctx) => {
         updateActiveCollectionWidget(ctx);
-    });
-    /* register shortcut */
-    pi.registerShortcut("ctrl+alt+l", {
-        description: "Select Active Collection",
-        handler: async (ctx) => {
-            await selectActiveCollection(ctx);
-        },
-    });
-    /* register commands */
-    registerCommands(pi);
-    /* register tools */
-    registerTools(pi);
-    registerIntakeTool(pi);
-    /* before_agent_start: dynamic injectors */
-    pi.on("before_agent_start", async (event, ctx) => {
-        return handleBeforeAgentStart(pi, event, ctx);
-    });
-    /* turn_end: capture pi-context events */
-    pi.on("turn_end", async (event, ctx) => {
-        return handleTurnEnd(pi, event, ctx);
-    });
-    /* watcher: auto-start if vaults configured */
-    try {
-        const cfg = loadConfig(process.cwd());
-        serverState.port = cfg.wiki.httpPort || 11435;
-        startServer(pi, serverState, watcherState);
-        if (cfg.wiki.vaults && Object.keys(cfg.wiki.vaults).length > 0) {
-            setTimeout(() => {
-                console.log("[pi-vault-mind] Auto-starting watcher for", Object.keys(cfg.wiki.vaults).length, "vault(s)");
-                const vaults = cfg.wiki.vaults;
-                if (vaults)
-                    startWatcher(pi, vaults, watcherState);
-            }, 2000);
+        enableACM(pi);
+        /* register shortcut */
+        pi.registerShortcut("ctrl+alt+l", {
+            description: "Select Active Collection",
+            handler: async (ctx) => {
+                await selectActiveCollection(ctx);
+            },
+        });
+        /* capture ctx.ui.setStatus for TUI footer indicators */
+        registerStatusCapture(pi);
+        /* register commands */
+        registerCommands(pi);
+        /* register tools */
+        registerTools(pi);
+        registerVaultTools(pi);
+        registerIntakeTool(pi);
+        /* agent bus — bus, bridge, vm_* handlers, engine, JOB_COMPLETED watcher */
+        const bus = new MessageBus();
+        const taskQueue = new TaskQueue();
+        createBridge(pi, bus);
+        registerAllExtensionTools(bus);
+        subscribeJobCompleted(bus, watcherState);
+        watcherState.bus = bus;
+        void startEngine({ bus, taskQueue })
+            .then((state) => {
+            engineState = state;
+            setEngineStatus(state.agents.length);
+            console.log(`[pi-vault-mind] Agent engine started (${state.agents.length} agent(s) loaded)`);
+        })
+            .catch((err) => {
+            console.error("[pi-vault-mind] Agent engine failed to start:", err);
+        });
+        /* identity boundary injector */
+        registerIdentityInjector(pi);
+        /* before_agent_start: dynamic injectors */
+        pi.on("before_agent_start", async (event, ctx) => {
+            return handleBeforeAgentStart(pi, event, ctx);
+        });
+        /* turn_end: capture pi-context events */
+        pi.on("turn_end", async (event, ctx) => {
+            return handleTurnEnd(pi, event, ctx);
+        });
+        /* watcher: auto-start if vaults configured */
+        try {
+            const cfg = loadConfig(process.cwd());
+            serverState.port = cfg.vaultMind.httpPort || 11435;
+            startServer(pi, serverState, watcherState);
+            if (cfg.vaultMind.vaults && Object.keys(cfg.vaultMind.vaults).length > 0) {
+                setTimeout(() => {
+                    console.log("[pi-vault-mind] Auto-starting watcher for", Object.keys(cfg.vaultMind.vaults).length, "vault(s)");
+                    const vaults = cfg.vaultMind.vaults;
+                    if (vaults)
+                        startWatcher(pi, vaults, watcherState);
+                }, 2000);
+            }
+            /* auto-sync: off by default; only starts when modal.sync.autoSync is true */
+            if (cfg.vaultMind.embedding.remoteUrl && cfg.vaultMind.embedding.modal?.sync?.autoSync) {
+                stopAutoSync = startAutoSync(cfg.vaultMind.embedding.modal?.sync?.autoSyncIntervalMs ?? 300000);
+                console.log(`[pi-vault-mind] Modal auto-sync enabled (every ${cfg.vaultMind.embedding.modal?.sync?.autoSyncIntervalMs ?? 300000}ms)`);
+            }
         }
-        /* auto-sync: off by default; only starts when modal.sync.autoSync is true */
-        if (cfg.wiki.embedding.provider === "modal" && cfg.wiki.embedding.modal?.sync?.autoSync) {
-            stopAutoSync = startAutoSync(cfg.wiki.embedding.modal?.sync?.autoSyncIntervalMs ?? 300000);
-            console.log(`[pi-vault-mind] Modal auto-sync enabled (every ${cfg.wiki.embedding.modal?.sync?.autoSyncIntervalMs ?? 300000}ms)`);
+        catch {
+            /* config may not exist yet; user can start watcher manually via /vm watcher start */
         }
-    }
-    catch {
-        /* config may not exist yet; user can start watcher manually via /wiki watcher start */
-    }
-    /* session_shutdown: stop the watcher and server */
-    pi.on("session_shutdown", async () => {
-        stopWatcher(watcherState);
-        stopServer(serverState);
-        if (stopAutoSync)
-            stopAutoSync();
+        /* session_shutdown: stop the watcher, server, and engine */
+        pi.on("session_shutdown", async () => {
+            stopWatcher(watcherState);
+            stopServer(serverState);
+            if (stopAutoSync)
+                stopAutoSync();
+            if (engineState)
+                stopEngine(engineState);
+            clearEngineStatus();
+            clearWatcherStatus();
+        });
     });
 }

package/dist/src/intake.js

@@ -11,8 +11,8 @@ import { ensureDir, expandHome, loadConfig } from "./utils.js";
  *    (returns undefined), so we build multi-select by looping ctx.ui.select()
  *    with a control item ("✓ Done") and a "Cancel" item. This works in both
  *    TUI and RPC and gives us an explicit cancel signal.
- * 2. Vault path resolution: loadConfig() already expands wiki.vaults.default.path
- *    (see src/utils.ts expandVaultPaths). We use cfg.wiki.vaults.default.path.
+ * 2. Vault path resolution: loadConfig() already expands vaultMind.vaults.default.path
+ *    (see src/utils.ts expandVaultPaths). We use cfg.vaultMind.vaults.default.path.
  * 3. Atomic vault write: VaultWriter already ensures Agent/Inbox/ exists, so we
  *    reuse it when available; fall back to mkdirSync + writeFileSync.
  * 4. Progress indicator: ctx.ui.setStatus("ask_intake", "Question 2 of 7...")
@@ -131,7 +131,7 @@ export const registerIntakeTool = (pi) => {
     pi.registerTool({
         name: "ask_intake",
         label: "Ask Intake",
-        description: "Ask the user a structured questionnaire (single or multi-select, free text) and optionally persist answers to the wiki ledger, the Obsidian vault, or both.",
+        description: "Ask the user a structured questionnaire (single or multi-select, free text) and optionally persist answers to the durable store, the Obsidian vault, or both.",
         promptSnippet: 'ask_intake(questions=[{question:"...", header:"...", options:[{label:"...", description:"..."}], multi_select:false}], persist="none")',
         promptGuidelines: [
             "Use ask_intake when you need structured answers from the user and want them persisted.",
@@ -199,7 +199,7 @@ const persistToLedger = (ctx, answers, collection) => {
 };
 const persistToVault = (ctx, answers, questions) => {
     const cfg = loadConfig(ctx.cwd);
-    const vaultCfg = cfg.wiki.vaults?.default;
+    const vaultCfg = cfg.vaultMind.vaults?.default;
     if (!vaultCfg?.path) {
         ctx.ui.notify("ask_intake: no default vault configured — skipping vault persist.", "warning");
         return null;

package/dist/src/lance.d.ts

@@ -1,47 +1,21 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import * as lancedb from "@lancedb/lancedb";
-import type { WikiConfig } from "./types.js";
+import type { AgentIdentity } from "./bridge.js";
+import type { VaultMindConfig } from "./types.js";
 export declare const connect: (dataDir: string) => Promise<lancedb.Connection>;
 export declare const resetConnection: () => void;
-export interface OllamaModelInfo {
-    name: string;
-    size: string;
-    modified: string;
-    details?: {
-        family?: string;
-        parameter_size?: string;
-    };
-}
-/**
- * Discover Ollama models using multiple paths (matching pi-model-router pattern):
- * 1. Try `pi.exec('ollama', ['list'])` — Pi's managed shell execution
- * 2. Fall back to HTTP /api/tags
- * 3. Fall back to Pi's cached models.json
- */
-export declare const discoverOllamaModels: (piOrHost?: ExtensionAPI | string) => Promise<OllamaModelInfo[]>;
-/**
- * Test Ollama connectivity. Uses pi.exec first, then HTTP.
- */
-export declare const testOllamaConnection: (hostOrPi?: string | ExtensionAPI) => Promise<{
-    reachable: boolean;
-    models: OllamaModelInfo[];
-    error?: string;
-}>;
-/**
- * Pull a model from Ollama. Uses pi.exec for managed timeout, falls back to HTTP.
- */
-export declare const pullOllamaModel: (model: string, piOrHost?: ExtensionAPI | string) => Promise<{
-    success: boolean;
-    message: string;
-}>;
-export declare const upsertEntry: (dataDir: string, collectionName: string, entry: Record<string, string>, cfg: WikiConfig) => Promise<void>;
+export declare const upsertEntry: (dataDir: string, collectionName: string, entry: Record<string, string>, cfg: VaultMindConfig, identity?: AgentIdentity) => Promise<void>;
 /**
  * Precomputed-vector insert path — used by sync. Upserts rows that are already
  * embedded (vectors come from the server) into the namespaced table, keyed by
  * `id` (merge-insert). Bypasses the auto-embed source field entirely. Carries
  * text + metadata. Idempotent (re-fetching a boundary row is a no-op).
  */
-export declare const upsertPrecomputed: (dataDir: string, collectionName: string, model: string, dim: number, rows: Array<Record<string, unknown>>, cfg: WikiConfig) => Promise<void>;
-export declare const searchHybrid: (dataDir: string, collectionName: string, query: string, limit: number, cfg: WikiConfig) => Promise<unknown[]>;
-export declare const searchFts: (dataDir: string, collectionName: string, query: string, limit: number, cfg: WikiConfig) => Promise<unknown[]>;
+export declare const upsertPrecomputed: (dataDir: string, collectionName: string, model: string, dim: number, rows: Array<Record<string, unknown>>, cfg: VaultMindConfig, identity?: AgentIdentity) => Promise<void>;
+/**
+ * Deterministic JSONL query for a collection. Applies optional substring search,
+ * exact field filters, identity visibility filter, and pagination.
+ */
+export declare const queryCollection: (collectionPath: string, schema: string[], query: string | null | undefined, filters: Record<string, string> | undefined, limit: number, offset: number, identity?: AgentIdentity) => Promise<unknown[]>;
+export declare const searchHybrid: (dataDir: string, collectionName: string, query: string, limit: number, cfg: VaultMindConfig, identity?: AgentIdentity) => Promise<unknown[]>;
+export declare const searchFts: (dataDir: string, collectionName: string, query: string, limit: number, cfg: VaultMindConfig, identity?: AgentIdentity) => Promise<unknown[]>;
 export declare const getStatus: (dataDir: string) => Promise<Record<string, unknown>>;