pi-vault-mind 0.15.0 → 0.16.3

package/CHANGELOG.md

@@ -1,5 +1,228 @@
 # Changelog
 
+## 0.16.3 / 0.6.5 — 2026-07-16
+
+### Added
+
+- **`GET /vault-mind/models` endpoint.** Auth-gated route returns pi's
+  provider/model catalog (`{ providers: ProviderInfo[] }`, plus an
+  `error` field when a `models.json` exists but fails to parse), merged
+  from the agent-dir and project-level `models.json` (project overrides
+  agent-dir for same-named providers). `src/models.ts`
+  `readModelProviders()` mirrors the plugin's `pi-config-reader.ts`
+  flattened shape (`$`-stripped `envVarName`, model `name` falls back to
+  `id`, providers sorted by name). New `VaultMindClient.getModels()`
+  (typed `VmModelsResponse`) is the client bridge so the plugin can
+  replace synchronous `models.json` disk reads with a live call. Covered
+  by `test/rest-models.test.ts` (auth, empty, parse, override, malformed).
+
+- **Extension-owned setup and configuration surfaces.** Added masked
+  provider-credential status and atomic extension-owned secret storage,
+  Local/Remote live embedding probes, complete typed setup/configuration
+  client methods, default-vault sibling preservation, and a deterministic
+  configuration E2E smoke. Added the portable seven-step Arrow setup
+  wizard and twelve-category section-save Settings UI, then ported it into
+  the Obsidian plugin behind a thin `RestConfigurationAdapter`. The plugin
+  now uses typed runtime model discovery instead of synchronous
+  `models.json` reads or writes, routes model selection through Pi RPC,
+  mounts Settings through one adapter boundary, renders retryable offline
+  recovery rather than a blank pane, and keeps plugin/extension bridge
+  credentials separate from embedding-provider credentials. Added
+  port-parity canonicalization for type re-exports, CSS/import guards,
+  intrinsic SVG icon bounds, and focused regression coverage across the
+  extension, sandbox, and plugin.
+
+### Fixed
+
+- **Un-imported `modalUrl` in `src/server.ts`** — the
+  `handleVaultMindConfig` function destructured `modalUrl` from
+  `../modal-config.js` without ever importing it. Would have crashed
+  with `TypeError: Cannot read properties of undefined (reading 'space')`
+  if the modal config branch was hit. Caught by
+  `/tmp/pvm-e2e-http-setup-test.mjs`. Import is now in place.
+
+### Documentation
+
+- **`vault-mind-config-index.md` §12 — Modal extraction question.** New
+  section documenting the open architectural question: should
+  `pi-vault-mind`'s Modal-specific code (HTTP client, sync engine,
+  `ModalProvider`, `/vm remote *` slash commands, `embedding.sync`
+  config block, Python `modal/` app) move into a separate package
+  (`pi-vault-mind-remote-modal/`) so the extension is truly
+  provider-agnostic? Three options documented (A: namespace in-tree /
+  B: extract to a package / C: server+client out, CLI stays). Smaller
+  win called out regardless of option: drop `/vm remote *` in favor of
+  `--remoteUrl` / `--remoteApiKey` flags on `/vm setup`. Awaiting
+  user decision; no work committed.
+- **§7.1 scope column.** Every `/vm *` slash command is now tagged
+  `🟢 agnostic` / `🟡 Modal-specific` / `🔵 token` so the reader can
+  see exactly which commands depend on Modal.
+
+## 0.16.2 — 2026-07-07
+
+### Changed
+
+- **`ModalEmbeddingConfig` flattened into `EmbeddingConfig`.** Modal
+  is just an OpenAI-compatible endpoint, so the `embedding.modal: {
+  baseUrl, workspace, apiToken, readToken, writeToken, model, dim,
+  fallback, sync }` wrapper is gone. All fields are now top-level on
+  `EmbeddingConfig` itself: `workspace`, `remoteApiKey`,
+  `remoteReadApiKey`, `remoteWriteApiKey`, `model`, `dim`, `fallback`
+  (now a simplified `{ enabled?: boolean }` — the `provider`
+  discriminator was already removed in 0.16.1+), and `sync`. **`apiKey`
+  is now explicitly the local-Ollama bearer** (defaults to `"ollama"`
+  in `OpenAICompatibleProvider`); the remote-endpoint token is
+  `remoteApiKey` so a single config can carry distinct local-vs-remote
+  credentials. The Modal-only blocks that remain as their own
+  inline objects are `sync` (pull-down watermark behavior) and
+  `fallback` (offline degrade policy). The `MODAL_APP_NAME` URL
+  helper stays in `src/modal-config.ts` (`modalUrl(workspace)`); the
+  Obsidian plugin keeps a small local mirror because it can't import
+  from the extension at runtime. `isModal()` is now simply
+  `!!cfg.embedding.remoteUrl`. The Obsidian plugin's
+  `provider: "ollama" | "modal" | "skip"` UI discriminator was renamed
+  to `"local" | "remote" | "skip"` (display labels stay user-friendly).
+  On save, the Modal wizard removes the old `embedding.modal` block
+  so existing configs upgrade cleanly on next `/vm setup`. The index
+  doc `vault-mind-config-index.md` §2.4 is updated; the per-setting
+  plan `vault-mind-config-plugin-surface.md` is reconciled.
+
+### Removed
+
+- **`ModalEmbeddingConfig` and `ModalFallbackConfig` types removed
+  from `src/types.ts`.** Fields are inlined on `EmbeddingConfig` (see
+  above). `FallbackConfig` (`{ enabled?: boolean }`) is the new
+  simplified fallback shape; `ModalSyncConfig` is unchanged.
+
+### Tests
+
+- 268 tests pass (no change in count — the migration was mechanical).
+  Three test files migrated from `modal: { ... }` fixtures to the
+  flat shape: `test/auth.test.ts`, `test/lance-modal.test.ts`,
+  `test/modal-config.test.ts`. The `ModalFallbackConfig["provider"]`
+  type-level regression test was removed (the type no longer exists).
+  One collateral fixture in `test/sync.test.ts`. One collateral
+  fixture in `test/vault-tools.test.ts` (the `writeConfig` helper
+  needed `model: "testmodel"` added so `resolveModel` returns the
+  right value for the test's `searchFts` assertion). The provider-cache
+  leak in `src/lance.ts`'s `resetConnection()` was fixed (the cache
+  was module-level and survived across tests).
+
+
+## 0.16.1 — 2026-07-07
+
+### Added
+
+- **`src/embedding-providers.ts`** — new store-agnostic `EmbeddingProvider`
+  interface (`embed` / `dim` / `init`) and the three concrete providers
+  (`OpenAICompatibleProvider`, `TransformersProvider`, `ModalProvider`)
+  plus a `createProvider(cfg)` factory. The vector-store layer
+  (`src/lance.ts`) now consumes providers through a 35-line
+  `LanceEmbeddingAdapter` that wraps them into LanceDB's
+  `TextEmbeddingFunction`. **Adding a new vector store (Qdrant, Pinecone,
+  pgvector, …) means writing a new adapter; adding a new embedding
+  provider means implementing the interface.** No downstream code (lance,
+  coalescer, plugin) needs to change for either.
+- **`/vm remote config fallback`** accepts `"ollama"` as a friendlier
+  alias for `"openai-compatible"` (rewritten to the enum value before
+  write). Help text and error messages updated.
+
+### Removed
+
+- **`ModalFallbackConfig.provider` enum reduced to `"openai-compatible"`.**
+  The legacy `"transformers"` value was dead code (no runtime path
+  selected it). The offline transformers path lives separately under
+  `EmbeddingConfig.useTransformers`. `/vm remote config fallback` parser
+  no longer accepts `"transformers"`. Type-level regression test
+  prevents the dead value from being added back.
+
+### Fixed
+
+- **`LanceEmbeddingFunction` now defaults `apiKey` to `"ollama"`** for
+  local endpoints, matching `AgentModelProvider`'s behavior and the
+  JSDoc contract. The previous `string | undefined` field would have
+  sent `Authorization: Bearer undefined` for any vault without an
+  explicit `apiKey`; Ollama happened to ignore the malformed header,
+  but stricter `/v1/embeddings`-compatible servers would have rejected
+  it. Pass `apiKey: null` to opt out (some local servers reject
+  `Bearer ollama` as invalid auth).
+- **`IdentityConfig.role` made optional.** It was required at the type
+  level but `mergeIdentityProfiles` always pulls `role` (and `id`) from
+  the base — config cannot rename an agent. Required type was dead.
+- **Index doc §2.6 `vaultMind.identities` reframed as "wired but
+  unenforced"** — the block is read at engine start
+  (`engine.ts:124-137` calls `mergeIdentityProfiles` and
+  `bridge.ts:100` registers the merged identity), but the registered
+  identity is never read back (`getAgentIdentity` in `bridge.ts:117`
+  has no callers). The block stays typed; future runtime enforcement
+  reuses it. New regression test in `test/bridge-identity.test.ts`
+  pins the merge contract (layer values override, empty array is
+  explicit deny, role/id always from base, undefined layer is a no-op).
+- **Config example drift closed.** `pi-vault-mind.config.example.json`
+  now shows the scaffolded `draft-context` injector instead of an
+  empty array — matches the live `src/scaffold.ts` output so a user
+  hand-rolling a config from the example doesn't silently miss a
+  built-in.
+
+## 0.16.0 — 2026-07-06
+
+### Added
+
+- **New `src/scaffold.ts`** — the single, UI-agnostic implementation of vault
+  config scaffolding (default collections/injectors, `.gitignore`), shared
+  by the CLI `/vm setup` command, the HTTP `POST /vm/setup` route, and any
+  future consumer. Robust to caller order: seeds default collections/
+  injectors whenever they're empty, not only when the config file is brand
+  new, so no future caller can silently end up with `"collections": {}`
+  again by writing embedding/vault fields before calling it.
+
+### Removed
+
+- **Legacy config/token migration dropped entirely.** `migrateLegacyState()`
+  and the `CONFIG_FILES` legacy-filename list are gone; pi-vault-mind no
+  longer rescues config/token from a vault-root `pi-vault-mind.config.json`,
+  `.pi/vault-mind.config.json`, or the global `~/.pi/agent/`. `.vault-mind/`
+  is now the only place pi-vault-mind ever reads its own config/token from —
+  no backward-compat fallback path.
+- **`/vm init` removed as a standalone command.** It only ever duplicated
+  part of `/vm setup`'s work with a deprecation notice; fully consolidated
+  onto `/vm setup`, which now also accepts `--collection <name>` (previously
+  only available via `/vm init --collection`). Every "Run /vm init first"
+  message across `commands.ts`, `settings-ui.ts`, `tools.ts`,
+  `vm-handlers.ts`, and `tools/marksman.ts` now says `/vm setup`.
+- **`POST /vm/init` removed from the HTTP API.** It duplicated a third copy
+  of the collections/injectors scaffold template (alongside the CLI's and
+  the Obsidian plugin's own copies). `POST /vm/setup` now calls the same
+  shared `scaffoldVaultConfig()` after writing embedding/vault fields, so it
+  does everything `/vm/init` did plus its own job, and its response now
+  includes `created`/`updated`/`skipped`/`collectionName`. The Obsidian
+  plugin's `VaultMindClient.init()` (only caller: the chat composer's
+  `/reindex` command) is removed too — it now calls `client.setup({})`
+  directly, since the reindex flow never used `init()`'s return value.
+
+### Fixed
+
+- **`/vm setup` never actually scaffolded default collections.** `handleInit`
+  (the scaffold logic) only populates the default `main`/`pending`/
+  `context_events` collections and the `draft-context` injector when the
+  config file doesn't exist yet — but `setupWizard` always wrote the config
+  file *first*, so `handleInit` permanently saw an existing file and took its
+  merge-safe (no-op-for-collections) branch instead. Every `/vm setup` run,
+  CLI or interactive, ended with `"collections": {}`. Reordered so
+  `handleInit` runs before `setupWizard`; verified end-to-end (fresh vault →
+  `/vm setup` → all three default collections + injector scaffolded with the
+  vault-derived file name, confirmed via direct JSONL read-back).
+- **`loadConfig` returned duplicate injector entries, causing them to fire
+  twice.** `mergeConfigLayer` concatenated `DEFAULT_CONFIG.injectors` with
+  the vault's own config-file injectors with zero deduplication. Since every
+  vault's config now always has its own `draft-context` injector (scaffolded
+  by `/vm setup`), `loadConfig()` returned it twice — and `events.ts`
+  processes every injector's regex match independently, so a matching note
+  would trigger the injector's capture/artifact-sync logic twice per prompt.
+  Fixed by deduplicating by `name` in the merge (layer's entry wins on a
+  collision), mirroring the existing dedupe pattern in `auditConfig`.
+  Verified via `loadConfig` on a freshly-scaffolded vault: exactly one
+  `draft-context` injector, not two.
 
 ## 0.15.0 / 0.6.4 — 2026-07-06
 

package/README.md

@@ -260,9 +260,9 @@ Edit `pi-vault-mind.config.json` to match your domain:
   "vaultMind": {
     "dataDir": ".lancedb",
     "embedding": {
-      "provider": "transformers",
-      "ollamaModel": "embeddinggemma",
-      "ollamaHost": "http://127.0.0.1:11434"
+      "remoteUrl": "http://127.0.0.1:11434",
+      "model": "embeddinggemma",
+      "dim": 768
     },
     "ftsEnabled": true,
     "graph": { "enabled": true, "canvasSync": false }
@@ -347,7 +347,6 @@ Edit `pi-vault-mind.config.json` to match your domain:
 | ------------------------------ | -------------------------------------------------------- |
 | `/vm help`                   | Show usage help                                          |
 | `/vm setup`                  | **Interactive global config wizard** (vault, embedding) |
-| `/vm init`                   | Scaffold project config + collections                    |
 | `/vm validate`               | Health check LanceDB, config, and all collection paths   |
 | `/vm approve [collection]`   | Batch-review pending entries                              |
 | `/vm settings`               | Open interactive settings dashboard                       |
@@ -358,7 +357,7 @@ Edit `pi-vault-mind.config.json` to match your domain:
 | `/vm injector create`        | Interactive wizard to create a new injector                |
 | `/vm context enable \| disable \| status` | Manage pi-context integration              |
 | `/vm embedding status \| use \| model \| models \| pull` | Manage embedding provider |
-| `/vm modal status \| config \| sync \| jobs \| migrate` | Manage Modal embedding + vector sync |
+| `/vm remote status \| config \| sync \| jobs \| migrate` | Manage remote embedding + vector sync |
 | `/vm watcher start \| stop \| status` | Manage the passive file watcher                  |
 | `/vm server status` | Show HTTP server status, port, and uptime |
 

package/agents/broadcaster.agent.md

@@ -2,7 +2,7 @@
 type: BroadcasterAgent
 role: broadcaster
 capabilities: [read, write, edit]
-allowed_tools: [read, write, edit, vm_search, vm_fts_search]
+allowed_tools: [read, write, edit, vm_search]
 write_collections: []
 can_publish: false
 llm_provider: ollama
@@ -16,7 +16,7 @@ and external-facing content from vault knowledge.
 ## Capability Boundary
 
 - **MAY**: read files, write files, edit files
-- **MAY**: search collections via vm_search, vm_fts_search
+- **MAY**: search collections via vm_search
 - **MUST NOT**: run bash commands, grep, or find
 - **MUST NOT**: write to the durable knowledge store
 - **MUST NOT**: publish or spawn sub-agents

package/agents/heavy-lifter.agent.md

@@ -2,7 +2,7 @@
 type: HeavyLifterAgent
 role: heavy-lifter
 capabilities: [read, write, edit, grep, find, ls, bash]
-allowed_tools: [read, write, edit, grep, find, ls, bash, vm_search, vm_fts_search]
+allowed_tools: [read, write, edit, grep, find, ls, bash, vm_search]
 write_collections: []
 can_publish: false
 llm_provider: ollama

package/agents/main.agent.md

@@ -0,0 +1,29 @@
+---
+type: ManagerAgent
+role: main
+capabilities: [read, write, edit, bash, grep, find, ls]
+allowed_tools: [read, write, edit, bash, grep, find, ls, vm_search, vm_query, vm_append, vm_stats, vm_status, vm_describe, vm_configure]
+write_collections: []
+can_publish: false
+llm_provider: ollama
+---
+
+# Main Agent
+
+Primary interactive agent for pi-vault-mind. The default role used by the
+Obsidian plugin's chat interface and the CLI `/vm chat` command.
+
+## Capability Boundary
+
+- **MAY**: all 7 built-in tools (read, write, edit, bash, grep, find, ls)
+- **MAY**: vm_search, vm_query (read paths)
+- **MAY**: vm_append, vm_stats, vm_status, vm_describe, vm_configure (write/config paths)
+- **MAY**: read from the "main" collection
+- **MUST NOT**: write to collections, publish, or access arbitrary vault paths
+
+## Tool Calling Convention
+
+When calling pi-vault-mind tools, always include your role:
+```
+vm_search({ query: "...", role: "main" })
+```

package/agents/manager.agent.md

@@ -2,7 +2,7 @@
 type: ManagerAgent
 role: manager
 capabilities: [read, write, edit, grep, find, ls]
-allowed_tools: [read, write, edit, grep, find, ls, vm_search, vm_fts_search, vm_append, vm_sync, vm_promote, vm_query, vm_configure, vm_describe, vm_stats, vm_export, vm_ingest, vm_status, vm_graph_query]
+allowed_tools: [read, write, edit, grep, find, ls, vm_search, vm_append, vm_sync, vm_promote, vm_query, vm_configure, vm_describe, vm_stats, vm_export, vm_ingest, vm_status]
 write_collections: [main, research, presentations]
 can_publish: true
 llm_provider: ollama

package/agents/miner.agent.md

@@ -2,7 +2,7 @@
 type: MinerAgent
 role: miner
 capabilities: [read, write, edit, grep, find, ls]
-allowed_tools: [read, write, edit, grep, find, ls, vm_search, vm_fts_search, vm_append]
+allowed_tools: [read, write, edit, grep, find, ls, vm_search, vm_append]
 write_collections: [main, research]
 can_publish: false
 llm_provider: ollama

package/dist/packages/obsidian/src/client.js

@@ -0,0 +1,331 @@
+/**
+ * HTTP + WebSocket client for the pi-vault-mind extension.
+ *
+ * REST calls use `fetch`. WebSocket events use the native `WebSocket` global
+ * with exponential backoff on disconnect (1, 2, 4, 8, 16, 30 s).
+ */
+export class VaultMindClient {
+    config;
+    ws = null;
+    reconnectTimer = null;
+    reconnectDelay = 1000;
+    intentionalClose = false;
+    eventHandlers = new Set();
+    stateHandlers = new Set();
+    _state = { connected: false };
+    constructor(config) {
+        this.config = config;
+    }
+    get baseUrl() {
+        return `http://${this.config.host}:${this.config.port}`;
+    }
+    get wsUrl() {
+        return `ws://${this.config.host}:${this.config.port}/agent/stream`;
+    }
+    get authHeaders() {
+        return {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.config.token}`,
+        };
+    }
+    setState(state) {
+        this._state = state;
+        for (const h of this.stateHandlers)
+            h(state);
+    }
+    get state() {
+        return this._state;
+    }
+    subscribeEvents(handler) {
+        this.eventHandlers.add(handler);
+        return () => this.eventHandlers.delete(handler);
+    }
+    subscribeState(handler) {
+        this.stateHandlers.add(handler);
+        return () => this.stateHandlers.delete(handler);
+    }
+    emit(event) {
+        for (const h of this.eventHandlers) {
+            try {
+                h(event);
+            }
+            catch {
+                // never let a bad listener break others
+            }
+        }
+    }
+    connect() {
+        if (this.ws)
+            return;
+        try {
+            this.ws = new WebSocket(this.wsUrl, [`Authorization: Bearer ${this.config.token}`]);
+        }
+        catch (err) {
+            this.setState({ connected: false, error: String(err), reconnecting: true });
+            this.scheduleReconnect();
+            return;
+        }
+        this.ws.onopen = () => {
+            this.reconnectDelay = 1000;
+            this.setState({ connected: true, reconnecting: false });
+        };
+        this.ws.onmessage = (event) => {
+            try {
+                const parsed = JSON.parse(event.data);
+                this.emit(parsed);
+            }
+            catch {
+                // ignore malformed events
+            }
+        };
+        this.ws.onclose = (event) => {
+            this.ws = null;
+            if (this.intentionalClose) {
+                this.setState({ connected: false, error: undefined, reconnecting: false });
+                return;
+            }
+            const wasConnected = this._state.connected;
+            this.setState({ connected: false, error: `closed ${event.code}`, reconnecting: true });
+            if (wasConnected || event.code !== 4401) {
+                this.scheduleReconnect();
+            }
+        };
+        this.ws.onerror = () => {
+            this.setState({ connected: this.ws?.readyState === WebSocket.OPEN, error: "socket error" });
+        };
+    }
+    disconnect() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        this.intentionalClose = true;
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.setState({ connected: false, error: undefined, reconnecting: false });
+        this.intentionalClose = false;
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimer)
+            return;
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.connect();
+        }, this.reconnectDelay);
+        this.reconnectDelay = Math.min(this.reconnectDelay * 2, 30000);
+    }
+    async httpJson(method, path, body) {
+        const res = await fetch(`${this.baseUrl}${path}`, {
+            method,
+            headers: this.authHeaders,
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        const text = await res.text();
+        if (!res.ok) {
+            let serverMessage = text;
+            try {
+                const parsed = JSON.parse(text);
+                if (typeof parsed.message === "string")
+                    serverMessage = parsed.message;
+            }
+            catch {
+                // keep raw text as the server message
+            }
+            // Never echo the request body or secret material in the thrown error.
+            throw new Error(`${res.status} ${serverMessage}`);
+        }
+        return text ? JSON.parse(text) : undefined;
+    }
+    async status() {
+        return (await this.httpJson("GET", "/vm/status"));
+    }
+    async setup(body) {
+        return (await this.httpJson("POST", "/vm/setup", body));
+    }
+    async probeEmbedding(body) {
+        return (await this.httpJson("POST", "/vm/embedding/probe", body));
+    }
+    async putEmbeddingSecrets(body) {
+        return (await this.httpJson("PUT", "/vm/embedding/secrets", body));
+    }
+    async startServer() {
+        return (await this.httpJson("POST", "/server/start"));
+    }
+    async toggleWatcher() {
+        return (await this.httpJson("POST", "/vm/watcher/toggle"));
+    }
+    async listQueue(status) {
+        const query = status ? `?status=${status}` : "";
+        return (await this.httpJson("GET", `/agent/queue${query}`));
+    }
+    async retryJob(id) {
+        return (await this.httpJson("POST", `/agent/jobs/${encodeURIComponent(id)}/retry`));
+    }
+    async cancelJob(id) {
+        return (await this.httpJson("POST", `/agent/jobs/${encodeURIComponent(id)}/cancel`));
+    }
+    /**
+     * Unified search with mode dispatch. Calls POST /vm/search with mode param.
+     * mode='hybrid' (default) = vector+FTS rank-merge, 'semantic' = vector-only,
+     * 'fts' = keyword, 'graph' = entity traversal, 'full' = all merged.
+     */
+    async searchWithMode(params) {
+        return (await this.httpJson("POST", "/vm/search", {
+            collection: params.collection ?? "main",
+            query: params.query,
+            mode: params.mode ?? "hybrid",
+            limit: params.limit ?? 5,
+            ...(params.entity ? { entity: params.entity } : {}),
+            ...(params.depth ? { depth: params.depth } : {}),
+            ...(params.sources ? { sources: params.sources } : {}),
+        }));
+    }
+    async gitStatus() {
+        return (await this.httpJson("GET", "/git/status"));
+    }
+    async gitBranches() {
+        return (await this.httpJson("GET", "/git/branches"));
+    }
+    async gitCheckout(branch) {
+        return (await this.httpJson("POST", "/git/checkout", { branch }));
+    }
+    async listSessions() {
+        return (await this.httpJson("GET", "/sessions"));
+    }
+    async getSession(id) {
+        return (await this.httpJson("GET", `/sessions/${encodeURIComponent(id)}`));
+    }
+    async renameSession(id, name) {
+        return (await this.httpJson("PATCH", `/sessions/${encodeURIComponent(id)}`, { name }));
+    }
+    async deleteSession(id) {
+        return (await this.httpJson("DELETE", `/sessions/${encodeURIComponent(id)}`));
+    }
+    async exportSession(id) {
+        return (await this.httpJson("POST", `/sessions/${encodeURIComponent(id)}/export`));
+    }
+    async archiveSession(id) {
+        return (await this.httpJson("POST", `/sessions/${encodeURIComponent(id)}/archive`));
+    }
+    /**
+     * List pending edits, optionally filtered by vault-relative file path.
+     */
+    async listEdits(filePath) {
+        const query = filePath ? `?path=${encodeURIComponent(filePath)}` : "";
+        const res = await this.httpJson("GET", `/vm/edits${query}`);
+        return res.edits;
+    }
+    /**
+     * Get a specific pending edit by ID.
+     */
+    async getEdit(id) {
+        const res = await this.httpJson("GET", `/vm/edits/${encodeURIComponent(id)}`);
+        return res.edit;
+    }
+    /**
+     * Apply a pending edit to the target file.
+     */
+    async applyEdit(id) {
+        return (await this.httpJson("POST", `/vm/edits/${encodeURIComponent(id)}/apply`));
+    }
+    /**
+     * Reject a pending edit.
+     */
+    async rejectEdit(id) {
+        return (await this.httpJson("POST", `/vm/edits/${encodeURIComponent(id)}/reject`));
+    }
+    async listPending() {
+        const res = await this.httpJson("GET", "/vm/pending");
+        return res.pending;
+    }
+    async approveEntry(id, collection, action) {
+        await this.httpJson("POST", "/vm/approve", { id, collection, action });
+    }
+    async pushContext(filePath, selection, cursor) {
+        return (await this.httpJson("POST", "/vault-mind/context", {
+            filePath,
+            selection,
+            cursor,
+        }));
+    }
+    async scan(file, vault) {
+        try {
+            return (await this.httpJson("POST", "/vault-mind/scan", { file, vault }));
+        }
+        catch (err) {
+            return { error: String(err) };
+        }
+    }
+    async dispatch(role, instruction, file, vault) {
+        try {
+            return (await this.httpJson("POST", "/vault-mind/dispatch", {
+                role,
+                instruction,
+                file,
+                vault,
+            }));
+        }
+        catch (err) {
+            return { error: String(err) };
+        }
+    }
+    async vmStats() {
+        return (await this.httpJson("GET", "/vm/stats"));
+    }
+    /** GET /vault-mind/config — full config + hasToken + remote block */
+    async getConfig() {
+        return (await this.httpJson("GET", "/vault-mind/config"));
+    }
+    /** GET /vault-mind/paths — vault/agent/env paths */
+    async paths() {
+        return (await this.httpJson("GET", "/vault-mind/paths"));
+    }
+    /** GET /vault-mind/models — provider/model catalog parsed from pi's models.json */
+    async getModels() {
+        return (await this.httpJson("GET", "/vault-mind/models"));
+    }
+    /** POST /vm/token — write PVM_API_TOKEN to vault-mind.env */
+    async writeToken(token) {
+        return (await this.httpJson("POST", "/vm/token", { token }));
+    }
+    /** PATCH /vm/config — partial config update (deep-merged on vaultMind) */
+    async updateConfig(partial) {
+        return (await this.httpJson("PATCH", "/vm/config", partial));
+    }
+    /** GET /vault-mind/tools — full tool catalog + per-role allowlists */
+    async listTools() {
+        return (await this.httpJson("GET", "/vault-mind/tools"));
+    }
+    /** GET /vault-mind/identities — identity registry */
+    async listIdentities() {
+        return (await this.httpJson("GET", "/vault-mind/identities"));
+    }
+    /** PUT /vault-mind/identities/:role/allowedTools — update per-role allowlist */
+    async setAllowedTools(role, allowedTools) {
+        return (await this.httpJson("PUT", `/vault-mind/identities/${encodeURIComponent(role)}/allowedTools`, { allowedTools }));
+    }
+    /** POST /vault-mind/reload-identities — reload bridge registry */
+    async reloadIdentities() {
+        return (await this.httpJson("POST", "/vault-mind/reload-identities"));
+    }
+    /** POST /vm/reindex — trigger a remote reindex of all collections */
+    async reindex() {
+        return (await this.httpJson("POST", "/vm/reindex"));
+    }
+    /** GET /agent/activity — list activity events, optionally filtered by jobId and limited. */
+    async listActivity(opts = {}) {
+        const params = new URLSearchParams();
+        if (opts.jobId !== undefined)
+            params.set("jobId", opts.jobId);
+        if (opts.limit !== undefined)
+            params.set("limit", String(opts.limit));
+        const qs = params.toString();
+        return (await this.httpJson("GET", `/agent/activity${qs ? `?${qs}` : ""}`));
+    }
+    /** GET /vault-mind/model-readiness — returns model registry status and current selected model */
+    async getModelReadiness() {
+        return (await this.httpJson("GET", "/vault-mind/model-readiness"));
+    }
+}

package/dist/packages/obsidian/src/types.js

@@ -0,0 +1 @@
+export {};