pi-vault-mind 0.16.6 → 0.16.8

package/CHANGELOG.md

@@ -1,5 +1,48 @@
 # Changelog
 
+## 0.16.8 / 0.6.11 — 2026-07-19
+
+### Added
+
+- **Persistent agent-model sequence editing.** The extension owns authenticated `GET/PUT /vm/model-router` routes, the typed client and configuration adapter expose the contract, and Settings now edits one primary model plus ordered fallbacks through the shared `ModelSequenceEditor` without writing Pi's model catalog.
+- **Explicit personalization cancellation.** The first-run Personalize card now exposes a separate Cancel action while work is active. Cancellation invalidates the controller attempt, uses Pi's existing abort transport, restores the idle model/action controls immediately, and prevents a stale completion from revealing chat or writing the personalization marker.
+- **Durable chat diff lifecycle.** Persisted vault-edit events hydrate actionable `DiffMessage` cards after reconnect, apply/reject actions retain their direction across retry, and the client authenticates its WebSocket connection. The remaining dedicated full-review/MergeView experience is tracked separately in the roadmap.
+
+### Fixed
+
+- **Embedding-only discovery catalogs.** Ollama and OpenAI-compatible probe results now retain explicit or known embedding-capable models, exclude known chat/generative families, preserve exact IDs/dimensions/order, and keep a configured current selection available without polluting newly discovered choices.
+- **Personalization parser and write boundary.** Aborted assistant results are classified as cancellation rather than malformed JSON; normally completed malformed output still reports an error. Proposal parsing validates the complete two-file schema, preserves fenced Markdown and escaped content, rejects duplicate or alternate paths and empty create/update content, and permits writes only to the resolved agent-dir `system.md` and vault-root `AGENTS.md`.
+- **Configuration persistence integrity.** Model-router configuration is written atomically; collection/injector configuration mutations preserve sibling vault configuration and explicit injector opt-outs rather than reintroducing scaffold defaults.
+- **Portable chat state restoration.** Diff-card and composer lifecycle updates now propagate reactive completion/retry state through both the sandbox source and the Obsidian port without stale one-shot snapshots.
+
+### Verified
+
+- Completed the ReturnVape seven-step setup walkthrough, Local embedding discovery, populated folder defaults, the enabled context-automation choice, setup save, configured-panel handoff, first-run model selection, Cancel recovery, proposal review, and durable personalization completion in Obsidian 1.12.7 on macOS. The known Auto-start persistence defect remains tracked separately.
+- Added focused regressions for model-router round trips, mixed-provider embedding filtering, configuration merge/injector invariants, persisted diff hydration and retry direction, composer completion, cancellation races, malformed-versus-aborted personalization output, strict proposal schema/path validation, and fenced Markdown preservation.
+
+## 0.16.7 / 0.6.10 — 2026-07-18
+
+### Fixed
+
+- **Obsidian Markdown lifecycle.** Assistant Markdown renders through Obsidian's native renderer, renderer components unload on panel close or remount, stale asynchronous opens cannot remount a closed panel, and deferred message fills cannot hijack a replacement message placeholder.
+- **Generated sandbox constants.** Root builds now format the sandbox extension-package catalog they regenerate, so the release build cannot invalidate the sandbox verification suite.
+- **Repository-only documentation.** Removed the obsolete MkDocs configuration, GitHub Pages deployment workflow, publication badges, and generated-site instructions while retaining maintained Markdown documentation in the repository.
+
+### Tests
+
+- Added focused regressions for Markdown cleanup ownership, direct remount disposal, close-during-refresh cancellation, and deferred placeholder isolation.
+
+## 0.6.9 — 2026-07-18
+
+### Fixed
+
+- **First-run personalization recovery.** The configured-vault onboarding card now retains its active personalization state until durable runtime status confirms completion, including when the prompt acknowledgement fails or a permission request is pending. The chat feed and composer remain correctly gated until then.
+- **Portable model selection.** The shared panel contract now passes opaque model IDs end-to-end; the Obsidian adapter resolves each ID to Pi's provider/model RPC payload internally, preserving IDs that contain `/` or `:`.
+
+### Tests
+
+- Added focused regressions for acknowledgement failure, pending permission delivery, re-entry protection, and exact model-ID selection ordering.
+
 ## 0.16.6 / 0.6.8 — 2026-07-18
 
 ### Fixed

package/README.md

@@ -3,8 +3,6 @@
 [![npm version](https://img.shields.io/npm/v/pi-vault-mind)](https://www.npmjs.com/package/pi-vault-mind)
 [![license](https://img.shields.io/npm/l/pi-vault-mind)](LICENSE)
 [![pi-extension](https://img.shields.io/badge/pi-extension-blue)](https://github.com/mariozechner/pi)
-[![docs](https://img.shields.io/badge/docs-pi--vault--mind-blue)](https://kylebrodeur.github.io/pi-vault-mind/)
-[![docs build](https://github.com/kylebrodeur/pi-vault-mind/actions/workflows/docs.yml/badge.svg)](https://github.com/kylebrodeur/pi-vault-mind/actions/workflows/docs.yml)
 
 Passive Obsidian vault extension for the [pi](https://github.com/mariozechner/pi) agent ecosystem. Watches `@agent` markers in your vault, dispatches forked subagents, and stores results in LanceDB with vector + FTS + graph. Multi-agent "Drop & Forget" workflow.
 
@@ -19,8 +17,8 @@ Passive Obsidian vault extension for the [pi](https://github.com/mariozechner/pi
 - **LanceDB Vector + FTS + Graph** — hybrid semantic + keyword search with automatic entity extraction and BFS graph traversal. All local, no external binaries.
 - **JSONL Source-of-Truth + LanceDB Index** — every fact lives in a durable, human-readable, version-control-friendly `collections/*.jsonl` file. The LanceDB index is derived and rebuildable via `/vm reindex --all --reembed`.
 - **Bidirectional Obsidian Sync** — substantial entries (`>200 chars` or tagged `decision`/`insight`/`requirement`) auto-write to `Vault/Agent/Inbox/`. Graph entities render as Obsidian Canvas files.
-- **Two-Layer Config** — global (`~/.pi/agent/vault-mind.config.json`) for shared settings, project (`./pi-vault-mind.config.json`) for project-specific knowledge. Works across all projects from any directory.
-- **Interactive Setup Wizard** — `/vm setup` walks through vault path, embedding provider, and model selection. CLI mode: `--vault`, `--provider`, `--model` flags for scripting.
+- **Vault-Scoped Configuration Surface** — Vault Mind setup/config now lives under `<vault>/.vault-mind/`, with the Obsidian setup wizard and `/vm setup` both writing the vault-local surface instead of a shared global config.
+- **Interactive Setup Wizard** — the Obsidian setup wizard handles first-run runtime/install/provider/folder/preferences/review flow, and `/vm setup` remains available for CLI/repair use.
 
 ## Architecture
 
@@ -212,19 +210,20 @@ pi install git:git@github.com:kylebrodeur/pi-vault-mind
 /vm setup
 ```
 
-This walks you through: vault path → embedding provider → Ollama model (if applicable).
+This configures the current vault's setup surface: vault path, embedding
+provider details, folder layout, and scaffolding.
 
-Or via CLI for scripting:
+Or via CLI for scripting/repair:
 
 ```bash
-/vm setup --vault /home/you/Obsidian/MyVault --provider transformers
-/vm setup --vault /home/you/Obsidian/MyVault --provider ollama --model embeddinggemma
+/vm setup --vault /home/you/Obsidian/MyVault --remoteUrl https://your-embedding-service-url.example.com --model embeddinggemma
 ```
 
-Config is written to `~/.pi/agent/vault-mind.config.json` — it applies globally
-no matter which project directory you open pi from.
+Config is written to the vault-local Vault Mind surface under
+`<vault>/.vault-mind/` rather than a shared global config file.
 
-You can re-run `/vm setup` anytime to view or change settings.
+You can re-run `/vm setup` anytime to view or change settings, and the
+Obsidian plugin's setup wizard uses the same extension-owned routes.
 
 ### 3. Start using
 
@@ -237,7 +236,7 @@ Entries are automatically embedded and stored in LanceDB. If graph is enabled, e
 
 ### 4. Adapt the config
 
-Edit `pi-vault-mind.config.json` to match your domain:
+Edit `<vault>/.vault-mind/vault-mind.config.json` to match your domain:
 
 ```json
 {
@@ -346,7 +345,7 @@ Edit `pi-vault-mind.config.json` to match your domain:
 | Command                        | Purpose                                                  |
 | ------------------------------ | -------------------------------------------------------- |
 | `/vm help`                   | Show usage help                                          |
-| `/vm setup`                  | **Interactive global config wizard** (vault, embedding) |
+| `/vm setup`                  | Interactive vault-local setup/config wizard (runtime, embedding, scaffold) |
 | `/vm validate`               | Health check LanceDB, config, and all collection paths   |
 | `/vm approve [collection]`   | Batch-review pending entries                              |
 | `/vm settings`               | Open interactive settings dashboard                       |
@@ -363,19 +362,16 @@ Edit `pi-vault-mind.config.json` to match your domain:
 
 ## Documentation
 
-> **Full docs site:** [kylebrodeur.github.io/pi-vault-mind](https://kylebrodeur.github.io/pi-vault-mind/) (GH Pages, built from [`docs/`](docs/)).
-> The links below point to the source files in this repository.
+Documentation is maintained directly in this repository.
 
 ### Getting started
 
 | Doc | Description |
 |---|---|
-| [docs/getting-started/QUICKSTART.md](docs/getting-started/QUICKSTART.md) | **Fastest path** — 60-second install, setup, first append |
-| [docs/getting-started/NEW_VAULT_WALKTHROUGH.md](docs/getting-started/NEW_VAULT_WALKTHROUGH.md) | **Fresh Mac → new vault → Modal → sync → verified**, one linear path (incl. multi-vault storage isolation) |
-| [docs/getting-started/INSTALL.md](docs/getting-started/INSTALL.md) | **Canonical install playbook** — all 5 layers (pi ext, skills, Obsidian, config, external CLIs) |
-| [docs/getting-started/GETTING_STARTED.md](docs/getting-started/GETTING_STARTED.md) | End-to-end workflow + daily "drop & forget" usage |
-| [docs/getting-started/CLI_ONLY_WALKTHROUGH.md](docs/getting-started/CLI_ONLY_WALKTHROUGH.md) | Same setup + daily commands, entirely CLI — no Obsidian plugin required |
-| [docs/getting-started/WALKTHROUGH_PROMPT.md](docs/getting-started/WALKTHROUGH_PROMPT.md) | Paste-into-pi guided setup with checkpoints between phases |
+| [Install playbook](docs/_reference/reference_archive/getting-started/INSTALL.md) | Canonical install procedure for the extension, skills, Obsidian plugin, configuration, and external CLIs |
+| [Getting started](docs/_reference/reference_archive/getting-started/GETTING_STARTED.md) | End-to-end setup and daily “drop and forget” workflow |
+| [CLI-only walkthrough](docs/_reference/reference_archive/getting-started/CLI_ONLY_WALKTHROUGH.md) | Setup and daily commands without the Obsidian plugin |
+| [ReturnVape walkthrough](docs/getting-started/WALKTHROUGH.md) | Current guided Obsidian test-vault procedure |
 
 ### Architecture & design
 
@@ -384,8 +380,6 @@ Edit `pi-vault-mind.config.json` to match your domain:
 | [docs/architecture/AGENTS.md](docs/architecture/AGENTS.md) | Agent Roster and Multi-Agent Architecture ("Fork & Review" model) |
 | [docs/architecture/EXTENSION_WIRING.md](docs/architecture/EXTENSION_WIRING.md) | Extension dependencies, runtime wiring, auto-install patterns |
 | [docs/architecture/DISPATCHER_SPEC.md](docs/architecture/DISPATCHER_SPEC.md) | Technical spec for the passive file-watcher and subagent routing — incl. the "Fork & Dispatch" rationale and thread resume |
-| [docs/architecture/AGENTS.md](docs/architecture/AGENTS.md) | Agent roster + the Miner's "Drop & Forget" ingestion pipeline |
-| [docs/integrations/OBSIDIAN_SETUP.md](docs/integrations/OBSIDIAN_SETUP.md) | Recommended Obsidian vault structure, plugins, and CLI |
 
 ### Modal embedding service (local integration done)
 
@@ -401,8 +395,6 @@ full design.
 | Doc | Description |
 |---|---|
 | [docs/integrations/MODAL_EMBEDDING.md](docs/integrations/MODAL_EMBEDDING.md) | Design of record: ADRs, HTTP contract, sync protocol, roadmap for the cloud embedding service |
-| [docs/plans/modal-embedding-plan.md](docs/plans/modal-embedding-plan.md) | **Consolidated plan & next steps** — phases, owners, status, decision gate (in repo, not on the docs site) |
-| [docs/plans/embedding-open-questions.md](docs/plans/embedding-open-questions.md) | Embedding-strategy decision log (decided + open questions) |
 | [modal/](modal/) | The deployable Modal app: embedding service + bulk worker + sync + dataset generator |
 | [eval/](eval/) | Retrieval eval harness + labeled benchmark datasets for picking the canonical model |
 
@@ -412,17 +404,10 @@ full design.
 |---|---|
 | [skills/vault-mind/SKILL.md](skills/vault-mind/SKILL.md) | The Manager skill — what pi auto-loads about this extension |
 | [docs/CHANGELOG.md](docs/CHANGELOG.md) | Version history (rename from `pi-knowledge-store` to `pi-vault-mind` was v0.7.0) |
-| [docs/reference/tools.md](docs/reference/tools.md) | The 11 `vm_*` and `vm_query`/`vm_append`/etc. tools — parameters, return shapes |
-| [docs/reference/commands.md](docs/reference/commands.md) | Full `/vm` slash command tree |
-| [docs/reference/configuration.md](docs/reference/configuration.md) | The complete `pi-vault-mind.config.json` schema |
-| [docs/reference/skill.md](docs/reference/skill.md) | Manifest of all bundled skills and their trigger phrases |
-
-### Testing
-
-| Doc | Description |
-|---|---|
-| [docs/testing/TESTING.md](docs/testing/TESTING.md) | Test plan for agent / human / HITL personas, regression suite |
-| [docs/testing/E2E_MANUAL_TEST.md](docs/testing/E2E_MANUAL_TEST.md) | Manual end-to-end verification procedure (watcher → dispatch → vault) |
+| [Tools reference](docs/_reference/reference_archive/tools.md) | Registered Vault Mind tools, parameters, and return shapes |
+| [Commands reference](docs/_reference/reference_archive/commands.md) | Full `/vm` slash command tree |
+| [Setup and configuration](docs/reference/setup-and-configuration.md) | Current integrated setup/configuration surface, ownership, routes, and live gaps |
+| [Skill manifest](docs/_reference/reference_archive/skill.md) | Bundled skills and their trigger phrases |
 
 ### Development
 
@@ -430,22 +415,13 @@ full design.
 |---|---|
 | [docs/development/CONTRIBUTING.md](docs/development/CONTRIBUTING.md) | Dev setup, testing, and commit conventions |
 | [docs/development/PUBLISHING.md](docs/development/PUBLISHING.md) | How to publish this extension to npm |
-| [docs/development/FUTURE_WORK.md](docs/development/FUTURE_WORK.md) | Roadmap — codegraph integration, pagination, TUI rendering, etc. |
-
-### Research
-
-| Doc | Description |
-|---|---|
-| [docs/research/COMPETITOR_COMPARISON.md](docs/research/COMPETITOR_COMPARISON.md) | Tier 1/2/3 comparison vs. other Obsidian-LLM tools (22 competitors) |
-| [docs/research/naming-decisions.md](docs/research/naming-decisions.md) | Historical record of the 2026-06-06 decision to name the project `pi-vault-mind` |
-| [docs/research/obsidian-links-reviewed.csv](docs/research/obsidian-links-reviewed.csv) | Curated subset of starred Obsidian repos with adoption verdicts |
 
 ### Archive
 
 | Doc | Description |
 |---|---|
 | [docs/_archive/](docs/_archive/) | Historical docs kept for context (e.g. the `pi-knowledge-store` → `pi-vault-mind` rename audit) |
-| [docs/_archive/legacy-audit.md](docs/_archive/legacy-audit.md) | The 2026-06-08 legacy-terminology audit (139 findings, 13 blockers) and its resolution log. Resolved 2026-06-09; archived 2026-06-16 (in the repo, not on the docs site) |
+| [docs/_archive/legacy-audit.md](docs/_archive/legacy-audit.md) | The 2026-06-08 legacy-terminology audit (139 findings, 13 blockers) and its resolution log. Resolved 2026-06-09 and archived 2026-06-16. |
 
 ## Contributing
 

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

@@ -1,3 +1,11 @@
+const encodeWebSocketAuthProtocol = (token) => {
+    const bytes = new TextEncoder().encode(token);
+    let binary = "";
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    const encoded = btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+    return `pvm-auth.${encoded}`;
+};
 /**
  * HTTP + WebSocket client for the pi-vault-mind extension.
  *
@@ -58,7 +66,7 @@ export class VaultMindClient {
         if (this.ws)
             return;
         try {
-            this.ws = new WebSocket(this.wsUrl, [`Authorization: Bearer ${this.config.token}`]);
+            this.ws = new WebSocket(this.wsUrl, encodeWebSocketAuthProtocol(this.config.token));
         }
         catch (err) {
             this.setState({ connected: false, error: String(err), reconnecting: true });
@@ -144,6 +152,9 @@ export class VaultMindClient {
     async setup(body) {
         return (await this.httpJson("POST", "/vm/setup", body));
     }
+    async cancelPersonalization() {
+        return (await this.httpJson("POST", "/vm/personalize/cancel"));
+    }
     async probeEmbedding(body) {
         return (await this.httpJson("POST", "/vm/embedding/probe", body));
     }
@@ -286,6 +297,14 @@ export class VaultMindClient {
     async getModels() {
         return (await this.httpJson("GET", "/vault-mind/models"));
     }
+    /** GET /vm/model-router — ordered provider/model primary and fallback identities. */
+    async getModelRouter() {
+        return (await this.httpJson("GET", "/vm/model-router"));
+    }
+    /** PUT /vm/model-router — replace the ordered primary/fallback sequence. */
+    async putModelRouter(config) {
+        return (await this.httpJson("PUT", "/vm/model-router", config));
+    }
     /** POST /vm/token — write PVM_API_TOKEN to vault-mind.env */
     async writeToken(token) {
         return (await this.httpJson("POST", "/vm/token", { token }));

package/dist/src/auth.d.ts

@@ -35,6 +35,7 @@ export declare const resolveTokenIdentity: (token: string) => TokenIdentity | un
 export interface IncomingLike {
     headers: {
         authorization?: string | string[] | undefined;
+        "sec-websocket-protocol"?: string | string[] | undefined;
     };
 }
 export interface AuthResult {
@@ -46,7 +47,11 @@ export interface AuthResult {
 /**
  * Authorize a request against configured tokens.
  *
- * Resolution order:
+ * Credential resolution order:
+ * 1. A normal `Authorization: Bearer <token>` header.
+ * 2. An exact `pvm-auth.<base64url(UTF-8 token)>` WebSocket protocol.
+ *
+ * Token matching order:
  * 1. Per-role `PVM_TOKEN_<ROLE>` env vars — returns the matched identity.
  * 2. Legacy `PVM_API_TOKEN` — returns `ok: true` with no identity (full access).
  * 3. No token configured → `ok: true` (auth is off).

package/dist/src/auth.js

@@ -89,10 +89,31 @@ const safeEqual = (a, b) => {
     }
     return mismatch === 0;
 };
+const WEBSOCKET_AUTH_PROTOCOL_PREFIX = "pvm-auth.";
+const decodeWebSocketAuthProtocol = (protocol) => {
+    if (!protocol.startsWith(WEBSOCKET_AUTH_PROTOCOL_PREFIX))
+        return null;
+    const encoded = protocol.slice(WEBSOCKET_AUTH_PROTOCOL_PREFIX.length);
+    if (!encoded || !/^[A-Za-z0-9_-]+$/.test(encoded) || encoded.length % 4 === 1)
+        return null;
+    try {
+        const bytes = Buffer.from(encoded, "base64url");
+        if (bytes.toString("base64url") !== encoded)
+            return null;
+        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+    }
+    catch {
+        return null;
+    }
+};
 /**
  * Authorize a request against configured tokens.
  *
- * Resolution order:
+ * Credential resolution order:
+ * 1. A normal `Authorization: Bearer <token>` header.
+ * 2. An exact `pvm-auth.<base64url(UTF-8 token)>` WebSocket protocol.
+ *
+ * Token matching order:
  * 1. Per-role `PVM_TOKEN_<ROLE>` env vars — returns the matched identity.
  * 2. Legacy `PVM_API_TOKEN` — returns `ok: true` with no identity (full access).
  * 3. No token configured → `ok: true` (auth is off).
@@ -106,12 +127,30 @@ export const authoriseRequest = (req) => {
         // No tokens configured — auth is off, allow all requests regardless of header
         return { ok: true };
     }
-    if (!header)
-        return { ok: false, reason: "missing" };
-    const m = header.match(/^Bearer\s+(.+)$/i);
-    if (!m)
-        return { ok: false, reason: "malformed" };
-    const token = m[1];
+    let token;
+    if (raw !== undefined) {
+        if (!header)
+            return { ok: false, reason: "missing" };
+        const match = header.match(/^Bearer\s+(.+)$/i);
+        if (!match)
+            return { ok: false, reason: "malformed" };
+        token = match[1];
+    }
+    else {
+        const rawProtocol = req.headers["sec-websocket-protocol"];
+        if (rawProtocol === undefined)
+            return { ok: false, reason: "missing" };
+        if (Array.isArray(rawProtocol) && rawProtocol.length !== 1) {
+            return { ok: false, reason: "malformed" };
+        }
+        const protocol = Array.isArray(rawProtocol) ? rawProtocol[0] : rawProtocol;
+        if (protocol === undefined)
+            return { ok: false, reason: "malformed" };
+        const decoded = decodeWebSocketAuthProtocol(protocol);
+        if (decoded === null)
+            return { ok: false, reason: "malformed" };
+        token = decoded;
+    }
     // 1. Per-role token match
     const identity = resolveTokenIdentity(token);
     if (identity)

package/dist/src/embedding-probe.js

@@ -1,4 +1,5 @@
 import { resolveEmbeddingSecret } from "./embedding-secrets.js";
+import { getModelCapabilities } from "./model-utils.js";
 const normalizeEndpointUrl = (url) => {
     const suffixes = ["/v1/embeddings", "/v1", "/"];
     let base = url;
@@ -43,15 +44,40 @@ const isOpenAiCatalog = (body) => {
         return false;
     return body.data.every((d) => isObject(d) && hasStringField(d, "id"));
 };
+const catalogModelCapabilities = (model) => isObject(model.capabilities)
+    ? getModelCapabilities({ id: model.id, capabilities: model.capabilities })
+    : getModelCapabilities({ id: model.id });
+const hasExplicitCapabilities = (capabilities) => isObject(capabilities) &&
+    (typeof capabilities.chat === "boolean" || typeof capabilities.embedding === "boolean");
+const KNOWN_OPENAI_EMBEDDING_FAMILY = /(^|[/_:.-])(?:e5|gte|instructor)(?=$|[/_:.-])/;
+const isOpenAiEmbeddingChoice = (model) => {
+    const capabilities = catalogModelCapabilities(model);
+    const id = model.id.toLowerCase();
+    if (capabilities.embedding)
+        return true;
+    if (hasExplicitCapabilities(model.capabilities))
+        return false;
+    if (KNOWN_OPENAI_EMBEDDING_FAMILY.test(id))
+        return true;
+    return false;
+};
 const normalizeModels = (body) => {
     if (isOllamaCatalog(body)) {
-        return body.models.map((m) => ({ id: m.name, name: m.name, dim: null }));
+        return body.models
+            .filter((model) => catalogModelCapabilities({ id: model.name, capabilities: model.capabilities }).embedding)
+            .map((model) => ({ id: model.name, name: model.name, dim: null }));
     }
     if (isModalCatalog(body)) {
-        return body.models.map((m) => ({ id: m.key, name: m.key, dim: m.native_dim }));
+        return body.models.map((model) => ({
+            id: model.key,
+            name: model.key,
+            dim: model.native_dim,
+        }));
     }
     if (isOpenAiCatalog(body)) {
-        return body.data.map((d) => ({ id: d.id, name: d.id, dim: null }));
+        return body.data
+            .filter(isOpenAiEmbeddingChoice)
+            .map((model) => ({ id: model.id, name: model.id, dim: null }));
     }
     return null;
 };

package/dist/src/model-router.d.ts

@@ -10,6 +10,13 @@
  * equivalent extension-exposed path) in a future refactor rather than
  * maintaining its own copy.
  */
+export interface ModelRouterModelReference {
+    providerId: string;
+    modelId: string;
+}
+export interface ModelRouterConfig {
+    sequence: ModelRouterModelReference[];
+}
 /** Tuned default primary model + fallback sequence for the `auto` router profile. */
 export declare const defaultModelRouterChoices: () => {
     primary: string;
@@ -25,3 +32,7 @@ export declare const scaffoldModelRouterConfig: (cwd: string) => {
     created: boolean;
     path: string;
 };
+/** Read the active ordered primary/fallback sequence without creating or modifying its file. */
+export declare const readModelRouterConfig: (cwd: string) => ModelRouterConfig;
+/** Replace only the active ordered primary/fallback sequence, preserving every other router option. */
+export declare const writeModelRouterConfig: (cwd: string, value: unknown) => ModelRouterConfig;

package/dist/src/model-router.js

@@ -10,8 +10,72 @@
  * equivalent extension-exposed path) in a future refactor rather than
  * maintaining its own copy.
  */
+import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import { ensureDir, resolveVaultMindPaths } from "./utils.js";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const writeModelRouterFile = (filePath, value) => {
+    ensureDir(filePath);
+    const temporaryPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        fs.writeFileSync(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
+        fs.renameSync(temporaryPath, filePath);
+    }
+    catch (error) {
+        try {
+            fs.unlinkSync(temporaryPath);
+        }
+        catch { }
+        throw error;
+    }
+};
+const parseModelReference = (value) => {
+    const separator = value.indexOf("/");
+    if (separator <= 0 || separator === value.length - 1) {
+        throw new Error(`Invalid model-router model reference: ${value}`);
+    }
+    return {
+        providerId: value.slice(0, separator),
+        modelId: value.slice(separator + 1),
+    };
+};
+const serializeModelReference = (reference) => `${reference.providerId}/${reference.modelId}`;
+const readPrimaryModel = (config) => {
+    const profileName = typeof config.defaultProfile === "string" && config.defaultProfile.length > 0
+        ? config.defaultProfile
+        : "auto";
+    const profiles = isRecord(config.profiles) ? config.profiles : {};
+    const profile = isRecord(profiles[profileName]) ? profiles[profileName] : {};
+    for (const tier of ["high", "medium", "low"]) {
+        const tierConfig = profile[tier];
+        if (isRecord(tierConfig) && typeof tierConfig.model === "string") {
+            return tierConfig.model;
+        }
+    }
+    return null;
+};
+const validateModelRouterConfig = (value) => {
+    if (!isRecord(value) || !Array.isArray(value.sequence) || value.sequence.length === 0) {
+        throw new Error("Model-router sequence must contain at least one model.");
+    }
+    const sequence = value.sequence.map((entry, index) => {
+        if (!isRecord(entry)) {
+            throw new Error(`Model-router sequence entry ${index} must be an object.`);
+        }
+        const { providerId, modelId } = entry;
+        if (typeof providerId !== "string" ||
+            providerId.length === 0 ||
+            providerId.trim() !== providerId ||
+            providerId.includes("/")) {
+            throw new Error(`Model-router sequence entry ${index} has an invalid providerId.`);
+        }
+        if (typeof modelId !== "string" || modelId.length === 0 || modelId.trim() !== modelId) {
+            throw new Error(`Model-router sequence entry ${index} has an invalid modelId.`);
+        }
+        return { providerId, modelId };
+    });
+    return { sequence };
+};
 /** Tuned default primary model + fallback sequence for the `auto` router profile. */
 export const defaultModelRouterChoices = () => {
     return {
@@ -63,7 +127,61 @@ export const scaffoldModelRouterConfig = (cwd) => {
             },
         },
     };
-    ensureDir(configPath);
-    fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf-8");
+    writeModelRouterFile(configPath, config);
     return { created: true, path: configPath };
 };
+/** Read the active ordered primary/fallback sequence without creating or modifying its file. */
+export const readModelRouterConfig = (cwd) => {
+    const { modelRouter: configPath } = resolveVaultMindPaths(cwd);
+    if (!fs.existsSync(configPath)) {
+        const { fallbackSequence } = defaultModelRouterChoices();
+        return { sequence: fallbackSequence.map(parseModelReference) };
+    }
+    const parsed = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    if (!isRecord(parsed))
+        throw new Error("Invalid model-router configuration.");
+    const fallback = isRecord(parsed.rateLimitFallback)
+        ? parsed.rateLimitFallback.fallbackSequence
+        : undefined;
+    let serializedSequence = [];
+    if (Array.isArray(fallback)) {
+        if (!fallback.every((value) => typeof value === "string")) {
+            throw new Error("Model-router fallback sequence contains a non-string entry.");
+        }
+        serializedSequence = [...fallback];
+    }
+    const primary = readPrimaryModel(parsed);
+    if (primary && serializedSequence[0] !== primary)
+        serializedSequence.unshift(primary);
+    if (serializedSequence.length === 0) {
+        throw new Error("Model-router configuration has no active model sequence.");
+    }
+    return { sequence: serializedSequence.map(parseModelReference) };
+};
+/** Replace only the active ordered primary/fallback sequence, preserving every other router option. */
+export const writeModelRouterConfig = (cwd, value) => {
+    const request = validateModelRouterConfig(value);
+    const { modelRouter: configPath } = resolveVaultMindPaths(cwd);
+    scaffoldModelRouterConfig(cwd);
+    const parsed = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    if (!isRecord(parsed))
+        throw new Error("Invalid model-router configuration.");
+    const profileName = typeof parsed.defaultProfile === "string" && parsed.defaultProfile.length > 0
+        ? parsed.defaultProfile
+        : "auto";
+    const primary = serializeModelReference(request.sequence[0]);
+    const profiles = isRecord(parsed.profiles) ? parsed.profiles : {};
+    const profile = isRecord(profiles[profileName]) ? profiles[profileName] : {};
+    for (const tier of ["high", "medium", "low"]) {
+        const tierConfig = isRecord(profile[tier]) ? profile[tier] : {};
+        profile[tier] = { ...tierConfig, model: primary };
+    }
+    parsed.profiles = { ...profiles, [profileName]: profile };
+    const rateLimitFallback = isRecord(parsed.rateLimitFallback) ? parsed.rateLimitFallback : {};
+    parsed.rateLimitFallback = {
+        ...rateLimitFallback,
+        fallbackSequence: request.sequence.map(serializeModelReference),
+    };
+    writeModelRouterFile(configPath, parsed);
+    return readModelRouterConfig(cwd);
+};

package/dist/src/model-utils.d.ts

@@ -0,0 +1,10 @@
+export interface ModelCapabilitySource {
+    id: string;
+    capabilities?: Record<string, unknown>;
+}
+export interface ModelCapabilities {
+    chat: boolean;
+    embedding: boolean;
+}
+/** Resolve explicit capability metadata first, then known embedding-only model families. */
+export declare function getModelCapabilities(model: ModelCapabilitySource): ModelCapabilities;

package/dist/src/model-utils.js

@@ -0,0 +1,24 @@
+const KNOWN_EMBEDDING_MODELS = [
+    "embeddinggemma",
+    "nomic-embed-text",
+    "mxbai-embed-large",
+    "all-minilm",
+    "paraphrase-multilingual",
+];
+/** Resolve explicit capability metadata first, then known embedding-only model families. */
+export function getModelCapabilities(model) {
+    const explicitChat = model.capabilities?.chat;
+    const explicitEmbedding = model.capabilities?.embedding;
+    if (typeof explicitChat === "boolean" || typeof explicitEmbedding === "boolean") {
+        const embedding = typeof explicitEmbedding === "boolean" ? explicitEmbedding : false;
+        return {
+            chat: typeof explicitChat === "boolean" ? explicitChat : !embedding,
+            embedding,
+        };
+    }
+    const id = model.id.toLowerCase();
+    const knownModel = KNOWN_EMBEDDING_MODELS.some((name) => id.includes(name));
+    const embeddingFamily = /(^|[/_:.-])(?:bge-|embed(?:ding)?(?:$|[/_:.-]))/.test(id);
+    const embedding = knownModel || embeddingFamily;
+    return { chat: !embedding, embedding };
+}

package/dist/src/personalize.d.ts

@@ -27,19 +27,24 @@ export interface SuggestionResult {
     commentary?: string;
     files: FileSuggestion[];
 }
+export interface PersonalizationCancelResult {
+    cancelled: boolean;
+}
+/** Abort the currently active personalization for a resolved vault, if one exists. */
+export declare const cancelPersonalization: (vaultPath: string) => PersonalizationCancelResult;
 /** Resolve the vault path: configured default vault wins, otherwise ctx.cwd. */
 export declare const resolveVaultPath: (ctx: ExtensionContext) => string;
 /** Load current agent configuration files if they exist. */
 export declare const loadCurrentConfig: (vaultPath: string) => ConfigFiles;
 /** Analyze the vault structure, tags, and LanceDB state. */
-export declare const analyzeVaultProfile: (ctx: ExtensionContext) => Promise<VaultProfile>;
+export declare const analyzeVaultProfile: (ctx: ExtensionContext, signal?: AbortSignal) => Promise<VaultProfile>;
 export declare const parseSuggestionJson: (text: string) => SuggestionResult;
 /** Ask the current session model to suggest personalized config updates. */
-export declare const generateSuggestions: (pi: ExtensionAPI, profile: VaultProfile, currentConfig: ConfigFiles) => Promise<SuggestionResult>;
+export declare const generateSuggestions: (pi: ExtensionAPI, profile: VaultProfile, currentConfig: ConfigFiles, signal?: AbortSignal) => Promise<SuggestionResult>;
 /** Format old vs new as a markdown diff block. */
 export declare const formatDiff: (current: string | null, proposed: string) => string;
 /** Present each suggestion diff to the user and write approved files. */
-export declare const presentAndApplyDiff: (suggestions: SuggestionResult, ctx: ExtensionContext, currentConfig: ConfigFiles) => Promise<{
+export declare const presentAndApplyDiff: (suggestions: SuggestionResult, ctx: ExtensionContext, currentConfig: ConfigFiles, signal?: AbortSignal) => Promise<{
     approved: string[];
     rejected: string[];
 }>;