pi-vault-mind 0.16.7 → 0.16.8

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # 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

package/README.md

@@ -17,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
 
@@ -210,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
 
@@ -235,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
 {
@@ -344,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                       |
@@ -405,7 +406,7 @@ full design.
 | [docs/CHANGELOG.md](docs/CHANGELOG.md) | Version history (rename from `pi-knowledge-store` to `pi-vault-mind` was v0.7.0) |
 | [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 |
-| [Configuration reference](docs/_reference/reference_archive/configuration.md) | Complete `pi-vault-mind.config.json` schema |
+| [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

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[];
 }>;