@vellumai/plugin-api 0.10.7 → 0.10.8-dev.202607102228.5945895

package/index.d.ts

@@ -60,6 +60,40 @@ declare interface AcpSessionUsage {
     outputTokens?: number;
 }
 
+/**
+ * Append a message to a conversation. This is the low-level insert: it
+ * persists and indexes the row only — it does not project the message into
+ * the conversation's disk view and does not notify connected clients, so
+ * background/internal writes stay silent. A user-visible append pairs this
+ * with `syncMessageToDisk` and a client notification, as the host's own
+ * out-of-pipeline writers do.
+ */
+export declare function addMessage(conversationId: string, role: MessageRole, content: string, options?: AddMessageOptions): Promise<AddMessageResult>;
+
+/**
+ * Persist a message and run post-insert side effects (memory indexing,
+ * attention projection). Delegates the core insert + retry logic to
+ * {@link insertMessageCore}.
+ */
+declare function addMessage_2(conversationId: string, role: MessageRole, content: string, options?: AddMessageOptions): Promise<InsertedMessage>;
+
+/** Options for {@link addMessage}. Only `skipIndexing` and `clientMessageId`
+ *  have defaults; `metadata` is genuinely optional. */
+declare interface AddMessageOptions {
+    metadata?: Record<string, unknown>;
+    skipIndexing?: boolean;
+    /** Client-generated nonce for idempotent inserts. When provided,
+     *  duplicate inserts for the same `(conversationId, clientMessageId)`
+     *  pair are silently skipped. */
+    clientMessageId?: string;
+    /** Pre-assigned message ID. When omitted, one is generated
+     *  internally. Pass the same value as `requestId` for user turns so
+     *  the persisted row ID matches the runtime correlation ID. */
+    id?: string;
+}
+
+declare type AddMessageResult = Awaited<ReturnType<addMessage_2>>;
+
 /**
  * Why an agent turn reached a terminal state. Supplied to the `stop` hook via
  * {@link StopContext.exitReason} and emitted on the `agent_loop_exit` event,
@@ -101,12 +135,6 @@ export declare type AgentLoopExitReason =
 /** An unhandled error ended the turn. */
 | "error";
 
-declare interface AllowlistOption {
-    label: string;
-    description: string;
-    pattern: string;
-}
-
 declare interface AppDataResponse {
     type: "app_data_response";
     surfaceId: string;
@@ -161,29 +189,6 @@ declare interface AppRestoreResponse {
     error?: string;
 }
 
-declare type ApprovalRequired = z.infer<typeof ApprovalRequiredSchema>;
-
-declare const ApprovalRequiredSchema: z.ZodObject<{
-    proposal: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        type: z.ZodLiteral<"http">;
-        credentialHandle: z.ZodString;
-        method: z.ZodString;
-        url: z.ZodString;
-        purpose: z.ZodString;
-        allowedUrlPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"command">;
-        credentialHandle: z.ZodString;
-        command: z.ZodString;
-        purpose: z.ZodString;
-        allowedCommandPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>], "type">;
-    proposalHash: z.ZodString;
-    renderedProposal: z.ZodString;
-    sessionId: z.ZodString;
-    conversationId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
 declare interface AppsListResponse {
     type: "apps_list_response";
     apps: Array<{
@@ -206,6 +211,19 @@ declare interface AppUpdatePreviewResponse {
     appId: string;
 }
 
+/**
+ * How {@link listConversations} (and friends) treats archived rows.
+ *
+ * - `"active"` — exclude rows with a non-null `archivedAt`. The default
+ *   for sidebar lists, restore, CLI pickers, and anything user-facing.
+ * - `"archived"` — return ONLY archived rows. Powers the Archive page
+ *   so it does not have to pull the entire conversation history and
+ *   filter client-side.
+ * - `"all"` — include both. Reserved for migrations and back-compat
+ *   call sites that genuinely want everything in one query.
+ */
+declare type ArchiveStatusFilter = "active" | "archived" | "all";
+
 declare type AssistantActivityStateEvent = z.infer<typeof AssistantActivityStateEventSchema>;
 
 declare const AssistantActivityStateEventSchema: z.ZodObject<{
@@ -251,6 +269,1098 @@ declare interface AssistantAttention {
     lastSeenSignalType?: string;
 }
 
+declare type AssistantConfig = z.infer<typeof AssistantConfigSchema>;
+
+declare const AssistantConfigSchema: z.ZodObject<{
+    services: z.ZodDefault<z.ZodObject<{
+        inference: z.ZodDefault<z.ZodObject<{}, z.core.$strip>>;
+        "image-generation": z.ZodDefault<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                managed: "managed";
+                "your-own": "your-own";
+            }>>;
+            provider: z.ZodDefault<z.ZodEnum<{
+                openai: "openai";
+                gemini: "gemini";
+            }>>;
+            model: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>;
+        "web-search": z.ZodDefault<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                managed: "managed";
+                "your-own": "your-own";
+            }>>;
+            provider: z.ZodDefault<z.ZodEnum<{
+                [x: string]: string;
+            }>>;
+        }, z.core.$strip>>;
+        "web-fetch": z.ZodDefault<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                managed: "managed";
+                "your-own": "your-own";
+            }>>;
+            provider: z.ZodDefault<z.ZodEnum<{
+                [x: string]: string;
+            }>>;
+        }, z.core.$strip>>;
+        stt: z.ZodDefault<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodLiteral<"your-own">>;
+            provider: z.ZodEnum<{
+                deepgram: "deepgram";
+                "google-gemini": "google-gemini";
+                "openai-whisper": "openai-whisper";
+                xai: "xai";
+            }>;
+            providers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>>>;
+        }, z.core.$strip>>;
+        tts: z.ZodDefault<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodLiteral<"your-own">>;
+            provider: z.ZodDefault<z.ZodEnum<{
+                deepgram: "deepgram";
+                xai: "xai";
+                elevenlabs: "elevenlabs";
+                "fish-audio": "fish-audio";
+            }>>;
+            providers: z.ZodDefault<z.ZodObject<{
+                elevenlabs: z.ZodDefault<z.ZodObject<{
+                    voiceId: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+                    voiceModelId: z.ZodDefault<z.ZodString>;
+                    speed: z.ZodDefault<z.ZodNumber>;
+                    stability: z.ZodDefault<z.ZodNumber>;
+                    similarityBoost: z.ZodDefault<z.ZodNumber>;
+                    conversationTimeoutSeconds: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>;
+                "fish-audio": z.ZodDefault<z.ZodObject<{
+                    referenceId: z.ZodDefault<z.ZodString>;
+                    chunkLength: z.ZodDefault<z.ZodNumber>;
+                    format: z.ZodDefault<z.ZodEnum<{
+                        mp3: "mp3";
+                        wav: "wav";
+                        opus: "opus";
+                    }>>;
+                    latency: z.ZodDefault<z.ZodEnum<{
+                        balanced: "balanced";
+                        normal: "normal";
+                    }>>;
+                    speed: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>;
+                deepgram: z.ZodDefault<z.ZodObject<{
+                    model: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+                    format: z.ZodDefault<z.ZodEnum<{
+                        mp3: "mp3";
+                        wav: "wav";
+                        opus: "opus";
+                    }>>;
+                }, z.core.$strip>>;
+                xai: z.ZodDefault<z.ZodObject<{
+                    voiceId: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+                    language: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+                    format: z.ZodDefault<z.ZodEnum<{
+                        mp3: "mp3";
+                        wav: "wav";
+                    }>>;
+                    sampleRate: z.ZodDefault<z.ZodNumber>;
+                    bitRate: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        "google-oauth": z.ZodDefault<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                managed: "managed";
+                "your-own": "your-own";
+            }>>;
+        }, z.core.$strip>>;
+        "outlook-oauth": z.ZodDefault<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                managed: "managed";
+                "your-own": "your-own";
+            }>>;
+        }, z.core.$strip>>;
+        "linear-oauth": z.ZodDefault<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                managed: "managed";
+                "your-own": "your-own";
+            }>>;
+        }, z.core.$strip>>;
+        "github-oauth": z.ZodDefault<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                managed: "managed";
+                "your-own": "your-own";
+            }>>;
+        }, z.core.$strip>>;
+        "notion-oauth": z.ZodDefault<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                managed: "managed";
+                "your-own": "your-own";
+            }>>;
+        }, z.core.$strip>>;
+        "twitter-oauth": z.ZodDefault<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                managed: "managed";
+                "your-own": "your-own";
+            }>>;
+        }, z.core.$strip>>;
+        "asana-oauth": z.ZodDefault<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                managed: "managed";
+                "your-own": "your-own";
+            }>>;
+        }, z.core.$strip>>;
+        "todoist-oauth": z.ZodDefault<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                managed: "managed";
+                "your-own": "your-own";
+            }>>;
+        }, z.core.$strip>>;
+        "discord-oauth": z.ZodDefault<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                managed: "managed";
+                "your-own": "your-own";
+            }>>;
+        }, z.core.$strip>>;
+        "hubspot-oauth": z.ZodDefault<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                managed: "managed";
+                "your-own": "your-own";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    memory: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        embeddings: z.ZodDefault<z.ZodObject<{
+            required: z.ZodDefault<z.ZodBoolean>;
+            provider: z.ZodDefault<z.ZodEnum<{
+                openai: "openai";
+                gemini: "gemini";
+                ollama: "ollama";
+                auto: "auto";
+                local: "local";
+            }>>;
+            localModel: z.ZodDefault<z.ZodString>;
+            openaiModel: z.ZodDefault<z.ZodString>;
+            geminiModel: z.ZodDefault<z.ZodString>;
+            geminiTaskType: z.ZodOptional<z.ZodEnum<{
+                SEMANTIC_SIMILARITY: "SEMANTIC_SIMILARITY";
+                CLASSIFICATION: "CLASSIFICATION";
+                CLUSTERING: "CLUSTERING";
+                RETRIEVAL_DOCUMENT: "RETRIEVAL_DOCUMENT";
+                RETRIEVAL_QUERY: "RETRIEVAL_QUERY";
+                CODE_RETRIEVAL_QUERY: "CODE_RETRIEVAL_QUERY";
+                QUESTION_ANSWERING: "QUESTION_ANSWERING";
+                FACT_VERIFICATION: "FACT_VERIFICATION";
+            }>>;
+            geminiDimensions: z.ZodOptional<z.ZodNumber>;
+            ollamaModel: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>;
+        qdrant: z.ZodDefault<z.ZodObject<{
+            url: z.ZodDefault<z.ZodString>;
+            collection: z.ZodDefault<z.ZodString>;
+            vectorSize: z.ZodDefault<z.ZodNumber>;
+            onDisk: z.ZodDefault<z.ZodBoolean>;
+            quantization: z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                scalar: "scalar";
+            }>>;
+        }, z.core.$strip>>;
+        retrieval: z.ZodDefault<z.ZodObject<{
+            maxInjectTokens: z.ZodDefault<z.ZodNumber>;
+            freshness: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                maxAgeDays: z.ZodDefault<z.ZodObject<{
+                    identity: z.ZodDefault<z.ZodNumber>;
+                    preference: z.ZodDefault<z.ZodNumber>;
+                    project: z.ZodDefault<z.ZodNumber>;
+                    decision: z.ZodDefault<z.ZodNumber>;
+                    constraint: z.ZodDefault<z.ZodNumber>;
+                    event: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>;
+                staleDecay: z.ZodDefault<z.ZodNumber>;
+                reinforcementShieldDays: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            scopePolicy: z.ZodDefault<z.ZodEnum<{
+                allow_global_fallback: "allow_global_fallback";
+                strict: "strict";
+            }>>;
+            dynamicBudget: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                minInjectTokens: z.ZodDefault<z.ZodNumber>;
+                maxInjectTokens: z.ZodDefault<z.ZodNumber>;
+                targetHeadroomTokens: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            injection: z.ZodDefault<z.ZodObject<{
+                contextLoad: z.ZodDefault<z.ZodObject<{
+                    maxNodes: z.ZodDefault<z.ZodNumber>;
+                    serendipitySlots: z.ZodDefault<z.ZodNumber>;
+                    capabilityReserve: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>;
+                perTurn: z.ZodDefault<z.ZodObject<{
+                    maxNodes: z.ZodDefault<z.ZodNumber>;
+                    serendipitySlots: z.ZodDefault<z.ZodNumber>;
+                    capabilityReserve: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            scratchpadInjection: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        segmentation: z.ZodDefault<z.ZodObject<{
+            targetTokens: z.ZodDefault<z.ZodNumber>;
+            overlapTokens: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        jobs: z.ZodDefault<z.ZodPipe<z.ZodObject<{
+            workerConcurrency: z.ZodOptional<z.ZodNumber>;
+            stalledJobTimeoutMs: z.ZodDefault<z.ZodNumber>;
+            slowLlmConcurrency: z.ZodOptional<z.ZodNumber>;
+            fastConcurrency: z.ZodOptional<z.ZodNumber>;
+            embedConcurrency: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodTransform<{
+            workerConcurrency: number;
+            stalledJobTimeoutMs: number;
+            slowLlmConcurrency: number;
+            fastConcurrency: number;
+            embedConcurrency: number;
+        }, {
+            stalledJobTimeoutMs: number;
+            workerConcurrency?: number | undefined;
+            slowLlmConcurrency?: number | undefined;
+            fastConcurrency?: number | undefined;
+            embedConcurrency?: number | undefined;
+        }>>>;
+        worker: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        retention: z.ZodDefault<z.ZodObject<{
+            keepRawForever: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        cleanup: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            supersededItemRetentionMs: z.ZodDefault<z.ZodNumber>;
+            conversationRetentionDays: z.ZodDefault<z.ZodNumber>;
+            llmRequestLogRetentionMs: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strip>>;
+        maintenance: z.ZodDefault<z.ZodObject<{
+            intervalMs: z.ZodDefault<z.ZodNumber>;
+            quietPeriodMs: z.ZodDefault<z.ZodNumber>;
+            skillPruneDays: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strip>>;
+        extraction: z.ZodDefault<z.ZodObject<{
+            useLLM: z.ZodDefault<z.ZodBoolean>;
+            extractFromAssistant: z.ZodDefault<z.ZodBoolean>;
+            batchSize: z.ZodDefault<z.ZodNumber>;
+            idleTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        summarization: z.ZodDefault<z.ZodObject<{
+            useLLM: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        v2: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            sweep_enabled: z.ZodDefault<z.ZodBoolean>;
+            d: z.ZodDefault<z.ZodNumber>;
+            c_user: z.ZodDefault<z.ZodNumber>;
+            c_assistant: z.ZodDefault<z.ZodNumber>;
+            c_now: z.ZodDefault<z.ZodNumber>;
+            k: z.ZodDefault<z.ZodNumber>;
+            hops: z.ZodDefault<z.ZodNumber>;
+            top_k: z.ZodDefault<z.ZodNumber>;
+            ann_candidate_limit: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            epsilon: z.ZodDefault<z.ZodNumber>;
+            dense_weight: z.ZodDefault<z.ZodNumber>;
+            sparse_weight: z.ZodDefault<z.ZodNumber>;
+            min_sparse_spread: z.ZodOptional<z.ZodNumber>;
+            full_sparse_spread: z.ZodOptional<z.ZodNumber>;
+            bm25_k1: z.ZodDefault<z.ZodNumber>;
+            bm25_b: z.ZodDefault<z.ZodNumber>;
+            consolidation_interval_hours: z.ZodDefault<z.ZodNumber>;
+            consolidation_max_buffer_lines: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            consolidation_max_entries_per_run: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            max_page_chars: z.ZodDefault<z.ZodNumber>;
+            consolidation_prompt_path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            rerank: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                top_k: z.ZodDefault<z.ZodNumber>;
+                alpha: z.ZodDefault<z.ZodNumber>;
+                model: z.ZodDefault<z.ZodString>;
+                dtype: z.ZodDefault<z.ZodEnum<{
+                    fp32: "fp32";
+                    fp16: "fp16";
+                    q8: "q8";
+                    int8: "int8";
+                    uint8: "uint8";
+                    q4: "q4";
+                    bnb4: "bnb4";
+                    q4f16: "q4f16";
+                }>>;
+            }, z.core.$strip>>;
+            router: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                max_page_ids: z.ZodDefault<z.ZodNumber>;
+                router_prompt_path: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                batch_size: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+                tier1_size: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+                tier2_size: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+                historical_pairs: z.ZodDefault<z.ZodNumber>;
+                historical_pairs_max_chars: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        v3: z.ZodDefault<z.ZodObject<{
+            live: z.ZodDefault<z.ZodBoolean>;
+            prune: z.ZodDefault<z.ZodObject<{
+                maxResidentBytes: z.ZodDefault<z.ZodNumber>;
+                targetResidentBytes: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            hotSet: z.ZodDefault<z.ZodObject<{
+                k: z.ZodDefault<z.ZodNumber>;
+                halfLifeDays: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            freshSet: z.ZodDefault<z.ZodObject<{
+                k: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            learnedEdges: z.ZodDefault<z.ZodObject<{
+                halfLifeDays: z.ZodDefault<z.ZodNumber>;
+                minCount: z.ZodDefault<z.ZodNumber>;
+                npmiFloor: z.ZodDefault<z.ZodNumber>;
+                maxPerPage: z.ZodDefault<z.ZodNumber>;
+                perSeed: z.ZodDefault<z.ZodNumber>;
+                cap: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            spotlight: z.ZodDefault<z.ZodObject<{
+                n: z.ZodDefault<z.ZodNumber>;
+                windowTurns: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            needleK: z.ZodDefault<z.ZodNumber>;
+            denseK: z.ZodDefault<z.ZodNumber>;
+            replyQueryK: z.ZodDefault<z.ZodNumber>;
+            selectorEnabled: z.ZodDefault<z.ZodBoolean>;
+            selectorPromptPath: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            edge: z.ZodDefault<z.ZodObject<{
+                hubDegree: z.ZodDefault<z.ZodNumber>;
+                seedCount: z.ZodDefault<z.ZodNumber>;
+                perSeed: z.ZodDefault<z.ZodNumber>;
+                cap: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            entity: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                idfFloor: z.ZodDefault<z.ZodNumber>;
+                cap: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            gate: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                denseThreshold: z.ZodDefault<z.ZodNumber>;
+                sparseThreshold: z.ZodDefault<z.ZodNumber>;
+                sparseOnlyThreshold: z.ZodDefault<z.ZodNumber>;
+                denseClusterThreshold: z.ZodDefault<z.ZodNumber>;
+                denseClusterMaxDelta: z.ZodDefault<z.ZodNumber>;
+                topK: z.ZodDefault<z.ZodNumber>;
+                bm25NormK: z.ZodDefault<z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>>;
+                bypassForCore: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        retrospective: z.ZodDefault<z.ZodObject<{
+            timeThresholdMs: z.ZodDefault<z.ZodNumber>;
+            messageThreshold: z.ZodDefault<z.ZodNumber>;
+            minCooldownMs: z.ZodDefault<z.ZodNumber>;
+            keepSupersededRuns: z.ZodDefault<z.ZodBoolean>;
+            matchConversationProfile: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    monitoring: z.ZodDefault<z.ZodObject<{
+        sampleIntervalMs: z.ZodDefault<z.ZodNumber>;
+        ringBufferSize: z.ZodDefault<z.ZodNumber>;
+        highMemThresholdRatio: z.ZodDefault<z.ZodNumber>;
+        snapshotCooldownMs: z.ZodDefault<z.ZodNumber>;
+        pluginSourceScanIntervalMs: z.ZodDefault<z.ZodNumber>;
+        baselineSnapshotIntervalMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    schedules: z.ZodDefault<z.ZodObject<{
+        worker: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    migrations: z.ZodDefault<z.ZodObject<{
+        worker: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    dataDir: z.ZodDefault<z.ZodString>;
+    timeouts: z.ZodDefault<z.ZodObject<{
+        shellMaxTimeoutSec: z.ZodDefault<z.ZodNumber>;
+        shellDefaultTimeoutSec: z.ZodDefault<z.ZodNumber>;
+        permissionTimeoutSec: z.ZodDefault<z.ZodNumber>;
+        questionResponseTimeoutSec: z.ZodDefault<z.ZodNumber>;
+        toolExecutionTimeoutSec: z.ZodDefault<z.ZodNumber>;
+        providerStreamTimeoutSec: z.ZodDefault<z.ZodNumber>;
+        backgroundTurnTimeoutSec: z.ZodDefault<z.ZodNumber>;
+        scheduleTurnTimeoutSec: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    rateLimit: z.ZodDefault<z.ZodObject<{
+        maxRequestsPerMinute: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    secretDetection: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        blockIngress: z.ZodDefault<z.ZodBoolean>;
+        allowOneTimeSend: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    auditLog: z.ZodDefault<z.ZodObject<{
+        retentionDays: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    logFile: z.ZodDefault<z.ZodObject<{
+        dir: z.ZodOptional<z.ZodString>;
+        retentionDays: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    llm: z.ZodDefault<z.ZodObject<{
+        default: z.ZodDefault<z.ZodObject<{
+            provider: z.ZodDefault<z.ZodEnum<{
+                anthropic: "anthropic";
+                openai: "openai";
+                gemini: "gemini";
+                fireworks: "fireworks";
+                openrouter: "openrouter";
+                ollama: "ollama";
+                "vercel-ai-gateway": "vercel-ai-gateway";
+                "openai-compatible": "openai-compatible";
+                minimax: "minimax";
+                atlascloud: "atlascloud";
+                together: "together";
+            }>>;
+            provider_connection: z.ZodOptional<z.ZodString>;
+            model: z.ZodDefault<z.ZodString>;
+            maxTokens: z.ZodDefault<z.ZodNumber>;
+            effort: z.ZodDefault<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                none: "none";
+                xhigh: "xhigh";
+                max: "max";
+            }>>;
+            speed: z.ZodDefault<z.ZodEnum<{
+                standard: "standard";
+                fast: "fast";
+            }>>;
+            verbosity: z.ZodDefault<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+            }>>;
+            temperature: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            topP: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            thinking: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                streamThinking: z.ZodDefault<z.ZodBoolean>;
+                level: z.ZodOptional<z.ZodEnum<{
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    minimal: "minimal";
+                }>>;
+            }, z.core.$strip>>;
+            contextWindow: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                maxInputTokens: z.ZodDefault<z.ZodNumber>;
+                targetBudgetRatio: z.ZodDefault<z.ZodNumber>;
+                compactThreshold: z.ZodDefault<z.ZodNumber>;
+                summaryBudgetRatio: z.ZodDefault<z.ZodNumber>;
+                overflowRecovery: z.ZodDefault<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    safetyMarginRatio: z.ZodDefault<z.ZodNumber>;
+                    maxAttempts: z.ZodDefault<z.ZodNumber>;
+                    interactiveLatestTurnCompression: z.ZodDefault<z.ZodEnum<{
+                        truncate: "truncate";
+                        summarize: "summarize";
+                        drop: "drop";
+                    }>>;
+                    nonInteractiveLatestTurnCompression: z.ZodDefault<z.ZodEnum<{
+                        truncate: "truncate";
+                        summarize: "summarize";
+                        drop: "drop";
+                    }>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            openrouter: z.ZodDefault<z.ZodObject<{
+                only: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            logitBias: z.ZodOptional<z.ZodEnum<{
+                "suppress-cjk": "suppress-cjk";
+            }>>;
+            disableCache: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        profiles: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            provider: z.ZodOptional<z.ZodEnum<{
+                anthropic: "anthropic";
+                openai: "openai";
+                gemini: "gemini";
+                fireworks: "fireworks";
+                openrouter: "openrouter";
+                ollama: "ollama";
+                "vercel-ai-gateway": "vercel-ai-gateway";
+                "openai-compatible": "openai-compatible";
+                minimax: "minimax";
+                atlascloud: "atlascloud";
+                together: "together";
+            }>>;
+            model: z.ZodOptional<z.ZodString>;
+            maxTokens: z.ZodOptional<z.ZodNumber>;
+            effort: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                none: "none";
+                xhigh: "xhigh";
+                max: "max";
+            }>>;
+            speed: z.ZodOptional<z.ZodEnum<{
+                standard: "standard";
+                fast: "fast";
+            }>>;
+            verbosity: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+            }>>;
+            temperature: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            topP: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            thinking: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                streamThinking: z.ZodOptional<z.ZodBoolean>;
+                level: z.ZodOptional<z.ZodEnum<{
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    minimal: "minimal";
+                }>>;
+            }, z.core.$strip>>;
+            contextWindow: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                maxInputTokens: z.ZodOptional<z.ZodNumber>;
+                targetBudgetRatio: z.ZodOptional<z.ZodNumber>;
+                compactThreshold: z.ZodOptional<z.ZodNumber>;
+                summaryBudgetRatio: z.ZodOptional<z.ZodNumber>;
+                overflowRecovery: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodOptional<z.ZodBoolean>;
+                    safetyMarginRatio: z.ZodOptional<z.ZodNumber>;
+                    maxAttempts: z.ZodOptional<z.ZodNumber>;
+                    interactiveLatestTurnCompression: z.ZodOptional<z.ZodEnum<{
+                        truncate: "truncate";
+                        summarize: "summarize";
+                        drop: "drop";
+                    }>>;
+                    nonInteractiveLatestTurnCompression: z.ZodOptional<z.ZodEnum<{
+                        truncate: "truncate";
+                        summarize: "summarize";
+                        drop: "drop";
+                    }>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            openrouter: z.ZodOptional<z.ZodObject<{
+                only: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            logitBias: z.ZodOptional<z.ZodEnum<{
+                "suppress-cjk": "suppress-cjk";
+            }>>;
+            disableCache: z.ZodOptional<z.ZodBoolean>;
+            source: z.ZodOptional<z.ZodEnum<{
+                managed: "managed";
+                user: "user";
+            }>>;
+            label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            description: z.ZodOptional<z.ZodString>;
+            provider_connection: z.ZodOptional<z.ZodString>;
+            status: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                active: "active";
+                disabled: "disabled";
+            }>>>;
+            mix: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                profile: z.ZodString;
+                weight: z.ZodNumber;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+        profileOrder: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        callSites: z.ZodDefault<z.ZodRecord<z.ZodEnum<{
+            mainAgent: "mainAgent";
+            subagentSpawn: "subagentSpawn";
+            heartbeatAgent: "heartbeatAgent";
+            filingAgent: "filingAgent";
+            compactionAgent: "compactionAgent";
+            callAgent: "callAgent";
+            memoryExtraction: "memoryExtraction";
+            memoryConsolidation: "memoryConsolidation";
+            memoryRetrieval: "memoryRetrieval";
+            memoryV2Migration: "memoryV2Migration";
+            memoryV2Sweep: "memoryV2Sweep";
+            memoryRouter: "memoryRouter";
+            memoryV3SelectL2: "memoryV3SelectL2";
+            memoryV2Consolidation: "memoryV2Consolidation";
+            memoryRetrospective: "memoryRetrospective";
+            recall: "recall";
+            narrativeRefinement: "narrativeRefinement";
+            patternScan: "patternScan";
+            conversationSummarization: "conversationSummarization";
+            conversationStarters: "conversationStarters";
+            replySuggestion: "replySuggestion";
+            conversationTitle: "conversationTitle";
+            commitMessage: "commitMessage";
+            identityIntro: "identityIntro";
+            emptyStateGreeting: "emptyStateGreeting";
+            notificationDecision: "notificationDecision";
+            preferenceExtraction: "preferenceExtraction";
+            guardianQuestionCopy: "guardianQuestionCopy";
+            approvalCopy: "approvalCopy";
+            approvalConversation: "approvalConversation";
+            interactionClassifier: "interactionClassifier";
+            styleAnalyzer: "styleAnalyzer";
+            inviteInstructionGenerator: "inviteInstructionGenerator";
+            skillCategoryInference: "skillCategoryInference";
+            inference: "inference";
+            vision: "vision";
+            trustRuleSuggestion: "trustRuleSuggestion";
+            homeGreeting: "homeGreeting";
+            homeSuggestedPrompts: "homeSuggestedPrompts";
+            workflowLeaf: "workflowLeaf";
+        }> & z.core.$partial, z.ZodObject<{
+            provider: z.ZodOptional<z.ZodEnum<{
+                anthropic: "anthropic";
+                openai: "openai";
+                gemini: "gemini";
+                fireworks: "fireworks";
+                openrouter: "openrouter";
+                ollama: "ollama";
+                "vercel-ai-gateway": "vercel-ai-gateway";
+                "openai-compatible": "openai-compatible";
+                minimax: "minimax";
+                atlascloud: "atlascloud";
+                together: "together";
+            }>>;
+            model: z.ZodOptional<z.ZodString>;
+            maxTokens: z.ZodOptional<z.ZodNumber>;
+            effort: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                none: "none";
+                xhigh: "xhigh";
+                max: "max";
+            }>>;
+            speed: z.ZodOptional<z.ZodEnum<{
+                standard: "standard";
+                fast: "fast";
+            }>>;
+            verbosity: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+            }>>;
+            temperature: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            topP: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            thinking: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                streamThinking: z.ZodOptional<z.ZodBoolean>;
+                level: z.ZodOptional<z.ZodEnum<{
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    minimal: "minimal";
+                }>>;
+            }, z.core.$strip>>;
+            contextWindow: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                maxInputTokens: z.ZodOptional<z.ZodNumber>;
+                targetBudgetRatio: z.ZodOptional<z.ZodNumber>;
+                compactThreshold: z.ZodOptional<z.ZodNumber>;
+                summaryBudgetRatio: z.ZodOptional<z.ZodNumber>;
+                overflowRecovery: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodOptional<z.ZodBoolean>;
+                    safetyMarginRatio: z.ZodOptional<z.ZodNumber>;
+                    maxAttempts: z.ZodOptional<z.ZodNumber>;
+                    interactiveLatestTurnCompression: z.ZodOptional<z.ZodEnum<{
+                        truncate: "truncate";
+                        summarize: "summarize";
+                        drop: "drop";
+                    }>>;
+                    nonInteractiveLatestTurnCompression: z.ZodOptional<z.ZodEnum<{
+                        truncate: "truncate";
+                        summarize: "summarize";
+                        drop: "drop";
+                    }>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            openrouter: z.ZodOptional<z.ZodObject<{
+                only: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            logitBias: z.ZodOptional<z.ZodEnum<{
+                "suppress-cjk": "suppress-cjk";
+            }>>;
+            disableCache: z.ZodOptional<z.ZodBoolean>;
+            profile: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        activeProfile: z.ZodOptional<z.ZodString>;
+        advisorProfile: z.ZodOptional<z.ZodString>;
+        defaultProvider: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                anthropic: "anthropic";
+                openai: "openai";
+                gemini: "gemini";
+                fireworks: "fireworks";
+                openrouter: "openrouter";
+                vellum: "vellum";
+            }>;
+            connectionName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        profileSession: z.ZodDefault<z.ZodObject<{
+            defaultTtlSeconds: z.ZodDefault<z.ZodNumber>;
+            maxTtlSeconds: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        pricingOverrides: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            provider: z.ZodString;
+            modelPattern: z.ZodString;
+            inputPer1M: z.ZodNumber;
+            outputPer1M: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    llmRequestLogs: z.ZodDefault<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        readSource: z.ZodLiteral<"local">;
+    }, z.core.$strip>, z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        readSource: z.ZodLiteral<"clickhouse">;
+        clickhouse: z.ZodDefault<z.ZodObject<{
+            database: z.ZodDefault<z.ZodString>;
+            table: z.ZodDefault<z.ZodString>;
+            user: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>], "readSource">>>;
+    filing: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        intervalMs: z.ZodDefault<z.ZodNumber>;
+        compactionEnabled: z.ZodDefault<z.ZodBoolean>;
+        compactionIntervalMs: z.ZodDefault<z.ZodNumber>;
+        activeHoursStart: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        activeHoursEnd: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>>;
+    heartbeat: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        intervalMs: z.ZodDefault<z.ZodNumber>;
+        cronExpression: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        timezone: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        activeHoursStart: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        activeHoursEnd: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        maxConsecutiveRuns: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        maxDailyRuns: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        disposition: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    hostBrowser: z.ZodDefault<z.ZodObject<{
+        cdpInspect: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            host: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            port: z.ZodDefault<z.ZodNumber>;
+            probeTimeoutMs: z.ZodDefault<z.ZodNumber>;
+            desktopAuto: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                cooldownMs: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    conversations: z.ZodDefault<z.ZodObject<{
+        skipAutoRetitling: z.ZodDefault<z.ZodBoolean>;
+        backgroundInjection: z.ZodDefault<z.ZodString>;
+        resumeProcessingOnStartup: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    journal: z.ZodDefault<z.ZodObject<{
+        contextWindowSize: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    backup: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        intervalHours: z.ZodDefault<z.ZodNumber>;
+        retention: z.ZodDefault<z.ZodNumber>;
+        offsite: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            destinations: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                encrypt: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>>>;
+        }, z.core.$strip>>;
+        localDirectory: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    mcp: z.ZodDefault<z.ZodObject<{
+        servers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            transport: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"stdio">;
+                command: z.ZodString;
+                args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"sse">;
+                url: z.ZodString;
+                headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"streamable-http">;
+                url: z.ZodString;
+                headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$strip>], "type">;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            defaultRiskLevel: z.ZodDefault<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+            }>>;
+            maxTools: z.ZodDefault<z.ZodNumber>;
+            allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            blockedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        globalMaxTools: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    acp: z.ZodDefault<z.ZodObject<{
+        maxConcurrentSessions: z.ZodDefault<z.ZodNumber>;
+        agents: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            command: z.ZodString;
+            args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            description: z.ZodOptional<z.ZodString>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    skills: z.ZodDefault<z.ZodObject<{
+        entries: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            apiKey: z.ZodOptional<z.ZodString>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>>;
+        load: z.ZodDefault<z.ZodObject<{
+            extraDirs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            watch: z.ZodDefault<z.ZodBoolean>;
+            watchDebounceMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        install: z.ZodDefault<z.ZodObject<{
+            nodeManager: z.ZodDefault<z.ZodEnum<{
+                npm: "npm";
+                pnpm: "pnpm";
+                yarn: "yarn";
+                bun: "bun";
+            }>>;
+        }, z.core.$strip>>;
+        allowBundled: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        remoteProviders: z.ZodDefault<z.ZodObject<{
+            skillssh: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            clawhub: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        remotePolicy: z.ZodDefault<z.ZodObject<{
+            blockSuspicious: z.ZodDefault<z.ZodBoolean>;
+            blockMalware: z.ZodDefault<z.ZodBoolean>;
+            maxSkillsShRisk: z.ZodDefault<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                safe: "safe";
+                critical: "critical";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    workspaceGit: z.ZodDefault<z.ZodObject<{
+        turnCommitMaxWaitMs: z.ZodDefault<z.ZodNumber>;
+        failureBackoffBaseMs: z.ZodDefault<z.ZodNumber>;
+        failureBackoffMaxMs: z.ZodDefault<z.ZodNumber>;
+        interactiveGitTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        enrichmentQueueSize: z.ZodDefault<z.ZodNumber>;
+        enrichmentConcurrency: z.ZodDefault<z.ZodNumber>;
+        enrichmentJobTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        enrichmentMaxRetries: z.ZodDefault<z.ZodNumber>;
+        commitMessageLLM: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            timeoutMs: z.ZodDefault<z.ZodNumber>;
+            maxFilesInPrompt: z.ZodDefault<z.ZodNumber>;
+            maxDiffBytes: z.ZodDefault<z.ZodNumber>;
+            minRemainingTurnBudgetMs: z.ZodDefault<z.ZodNumber>;
+            breaker: z.ZodDefault<z.ZodObject<{
+                openAfterFailures: z.ZodDefault<z.ZodNumber>;
+                backoffBaseMs: z.ZodDefault<z.ZodNumber>;
+                backoffMaxMs: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    compaction: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        autoThreshold: z.ZodDefault<z.ZodNumber>;
+        prompt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    compactionLogs: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        destination: z.ZodLiteral<"none">;
+    }, z.core.$strip>, z.ZodObject<{
+        destination: z.ZodLiteral<"clickhouse">;
+        clickhouse: z.ZodDefault<z.ZodObject<{
+            database: z.ZodDefault<z.ZodString>;
+            table: z.ZodDefault<z.ZodString>;
+            user: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>], "destination">>;
+    twilio: z.ZodDefault<z.ZodObject<{
+        accountSid: z.ZodDefault<z.ZodString>;
+        phoneNumber: z.ZodDefault<z.ZodString>;
+        setupStarted: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    calls: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        provider: z.ZodDefault<z.ZodEnum<{
+            twilio: "twilio";
+        }>>;
+        maxDurationSeconds: z.ZodDefault<z.ZodNumber>;
+        userConsultTimeoutSeconds: z.ZodDefault<z.ZodNumber>;
+        ttsPlaybackDelayMs: z.ZodDefault<z.ZodNumber>;
+        accessRequestPollIntervalMs: z.ZodDefault<z.ZodNumber>;
+        guardianWaitUpdateInitialIntervalMs: z.ZodDefault<z.ZodNumber>;
+        guardianWaitUpdateInitialWindowMs: z.ZodDefault<z.ZodNumber>;
+        guardianWaitUpdateSteadyMinIntervalMs: z.ZodDefault<z.ZodNumber>;
+        guardianWaitUpdateSteadyMaxIntervalMs: z.ZodDefault<z.ZodNumber>;
+        disclosure: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            text: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>;
+        safety: z.ZodDefault<z.ZodObject<{
+            denyCategories: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        voice: z.ZodDefault<z.ZodObject<{
+            language: z.ZodDefault<z.ZodString>;
+            interruptSensitivity: z.ZodDefault<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+            }>>;
+            telephonyStreaming: z.ZodDefault<z.ZodBoolean>;
+            utteranceEndMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        callerIdentity: z.ZodDefault<z.ZodObject<{
+            allowPerCallOverride: z.ZodDefault<z.ZodBoolean>;
+            userNumber: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        verification: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            maxAttempts: z.ZodDefault<z.ZodNumber>;
+            codeLength: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    liveVoice: z.ZodDefault<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            ptt: "ptt";
+            "open-mic": "open-mic";
+        }>>;
+        vad: z.ZodDefault<z.ZodObject<{
+            speechEnergyThreshold: z.ZodDefault<z.ZodNumber>;
+            silenceThresholdMs: z.ZodDefault<z.ZodNumber>;
+            maxTurnDurationMs: z.ZodDefault<z.ZodNumber>;
+            bargeInMinSpeechMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        maxSessionDurationSeconds: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    whatsapp: z.ZodDefault<z.ZodObject<{
+        phoneNumber: z.ZodDefault<z.ZodString>;
+        deliverAuthBypass: z.ZodDefault<z.ZodBoolean>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+        maxRetries: z.ZodDefault<z.ZodNumber>;
+        initialBackoffMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    telegram: z.ZodDefault<z.ZodObject<{
+        botId: z.ZodDefault<z.ZodString>;
+        botUsername: z.ZodDefault<z.ZodString>;
+        apiBaseUrl: z.ZodDefault<z.ZodString>;
+        deliverAuthBypass: z.ZodDefault<z.ZodBoolean>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+        maxRetries: z.ZodDefault<z.ZodNumber>;
+        initialBackoffMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    slack: z.ZodDefault<z.ZodObject<{
+        deliverAuthBypass: z.ZodDefault<z.ZodBoolean>;
+        teamId: z.ZodDefault<z.ZodString>;
+        teamName: z.ZodDefault<z.ZodString>;
+        teamUrl: z.ZodDefault<z.ZodString>;
+        botUserId: z.ZodDefault<z.ZodString>;
+        botUsername: z.ZodDefault<z.ZodString>;
+        threadMode: z.ZodDefault<z.ZodEnum<{
+            mention_only: "mention_only";
+            mention_then_thread: "mention_then_thread";
+        }>>;
+    }, z.core.$strip>>;
+    a2a: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    ingress: z.ZodPipe<z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        publicBaseUrl: z.ZodDefault<z.ZodString>;
+        webhook: z.ZodDefault<z.ZodObject<{
+            secret: z.ZodDefault<z.ZodString>;
+            timeoutMs: z.ZodDefault<z.ZodNumber>;
+            maxRetries: z.ZodDefault<z.ZodNumber>;
+            initialBackoffMs: z.ZodDefault<z.ZodNumber>;
+            maxPayloadBytes: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        rateLimit: z.ZodDefault<z.ZodObject<{
+            maxRequestsPerMinute: z.ZodDefault<z.ZodNumber>;
+            maxRequestsPerHour: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        shutdownDrainMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>, z.ZodTransform<{
+        enabled: boolean | undefined;
+        publicBaseUrl: string;
+        webhook: {
+            secret: string;
+            timeoutMs: number;
+            maxRetries: number;
+            initialBackoffMs: number;
+            maxPayloadBytes: number;
+        };
+        rateLimit: {
+            maxRequestsPerMinute: number;
+            maxRequestsPerHour: number;
+        };
+        shutdownDrainMs: number;
+    }, {
+        publicBaseUrl: string;
+        webhook: {
+            secret: string;
+            timeoutMs: number;
+            maxRetries: number;
+            initialBackoffMs: number;
+            maxPayloadBytes: number;
+        };
+        rateLimit: {
+            maxRequestsPerMinute: number;
+            maxRequestsPerHour: number;
+        };
+        shutdownDrainMs: number;
+        enabled?: boolean | undefined;
+    }>>;
+    platform: z.ZodDefault<z.ZodObject<{
+        baseUrl: z.ZodDefault<z.ZodString>;
+        subdomain: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    daemon: z.ZodDefault<z.ZodObject<{
+        startupSocketWaitMs: z.ZodDefault<z.ZodNumber>;
+        stopTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        sigkillGracePeriodMs: z.ZodDefault<z.ZodNumber>;
+        standaloneRecording: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    notifications: z.ZodDefault<z.ZodObject<{}, z.core.$strip>>;
+    ui: z.ZodDefault<z.ZodObject<{
+        userTimezone: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        detectedTimezone: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        emptyStateGreetingCacheTtlMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    tools: z.ZodDefault<z.ZodObject<{
+        exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    workflows: z.ZodDefault<z.ZodObject<{
+        maxAgentsPerRun: z.ZodDefault<z.ZodNumber>;
+        maxConcurrentLeaves: z.ZodDefault<z.ZodNumber>;
+        maxConcurrentRuns: z.ZodDefault<z.ZodNumber>;
+        journalRetentionDays: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    plugins: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    legacyTelemetryOptOut: z.ZodOptional<z.ZodBoolean>;
+    legacyDiagnosticsOptOut: z.ZodOptional<z.ZodBoolean>;
+    maxStepsPerSession: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+
 /** Daemon-side specialization of the generic event envelope. */
 export declare type AssistantEvent = BaseAssistantEvent<ServerMessage>;
 
@@ -474,6 +1584,12 @@ declare const AssistantTurnStartEventSchema: z.ZodObject<{
     conversationId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 
+declare interface AudioEmbeddingInput {
+    type: "audio";
+    data: Buffer;
+    mimeType: string;
+}
+
 declare interface AuthResult {
     type: "auth_result";
     success: boolean;
@@ -508,6 +1624,33 @@ declare interface BackgroundToolStarted {
     startedAt: number;
 }
 
+/**
+ * Media payload for an image or file content block. One unified type covers
+ * both blocks and both storage forms:
+ *
+ * - `base64` — the bytes travel inline with the block. This is the runtime
+ *   shape the provider transforms consume and the shape produced for a live
+ *   (in-flight) turn.
+ * - `workspace_ref` — the bytes live somewhere in the workspace, not inline.
+ *   This is the shape PERSISTED into `messages.content`, keeping large blobs
+ *   out of the DB row and the lexical index. It is resolved back to inline
+ *   bytes at the provider send boundary (`providers/media-resolve.ts`); any
+ *   consumer that needs the raw bytes from stored content resolves it with
+ *   `resolveMediaSourceData(source)`.
+ *
+ * `filename` is optional on both arms (present for file blocks and for
+ * generated-media references). For references, `sizeBytes` (and, for images,
+ * `width`/`height`) are captured at persist time so size-only consumers — the
+ * per-turn token estimator especially — can cost the block without reading the
+ * file back off disk.
+ */
+declare interface Base64MediaSource {
+    type: "base64";
+    media_type: string;
+    data: string;
+    filename?: string;
+}
+
 /**
  * A single assistant event wrapping an outbound message payload.
  *
@@ -605,6 +1748,13 @@ declare interface BookmarkSummary {
     createdAt: number;
 }
 
+/**
+ * Build a model-facing excerpt of stored message content around a query,
+ * preserving external-content envelopes so third-party boundaries stay
+ * visible.
+ */
+export declare function buildMessageExcerpt(rawContent: string, query: string): Promise<string>;
+
 declare interface BundleAppResponse {
     type: "bundle_app_response";
     bundlePath: string;
@@ -759,6 +1909,32 @@ declare interface ClawhubSlimSkill extends SlimSkillBase {
     version: string;
 }
 
+export declare const CLI_COMMAND_HELP: readonly CliCommandHelp[];
+
+/**
+ * Fully declarative description of a top-level `assistant` CLI command and its
+ * subcommands. Plain data by design — no action handlers — so plugins (e.g. the
+ * memory capability indexer) can import a command's help and iterate over it
+ * without dragging in the CLI's daemon/IPC action graph. Command modules apply
+ * the same data via {@link applyCommandHelp}, then attach their handlers.
+ */
+declare interface CliCommandHelp {
+    name: string;
+    /**
+     * Positional-argument spec appended to the name at registration, e.g.
+     * `"<command>"`. Use {@link commandSpec} to build the Commander registration
+     * string; `name` stays the bare command name so consumers (dedup, slugs,
+     * rendering) never parse argument syntax out of it.
+     */
+    args?: string;
+    description: string;
+    /** Options declared directly on the top-level command. */
+    options?: CliOptionHelp[];
+    /** Extra help appended after the option list (`addHelpText("after", …)`). */
+    helpText?: string;
+    subcommands?: CliSubcommandHelp[];
+}
+
 declare interface ClientEntry extends BaseSubscriberEntry {
     type: "client";
     clientId: string;
@@ -786,6 +1962,30 @@ declare interface ClientSettingsUpdate {
     value: string;
 }
 
+declare interface CliOptionHelp {
+    /** Commander flag spec, e.g. `"--path <file>"` or `"-l, --limit <n>"`. */
+    flags: string;
+    description: string;
+    /** When true, applied via `requiredOption` (missing → error) rather than `option`. */
+    required?: boolean;
+    /** Default value passed to `option(flags, description, defaultValue)`. */
+    defaultValue?: string;
+    /** Allowed values, applied via Commander's `Option.choices()` (invalid → error). */
+    choices?: readonly string[];
+}
+
+declare interface CliSubcommandHelp {
+    name: string;
+    /** Positional-argument spec, e.g. `"<path>"` — see {@link CliCommandHelp.args}. */
+    args?: string;
+    description: string;
+    options?: CliOptionHelp[];
+    /** Extra help appended after the option list (`addHelpText("after", …)`). */
+    helpText?: string;
+    /** Nested subcommand groups (e.g. `avatar character update`). */
+    subcommands?: CliSubcommandHelp[];
+}
+
 declare type CompactionCircuitClosedEvent = z.infer<typeof CompactionCircuitClosedEventSchema>;
 
 declare const CompactionCircuitClosedEventSchema: z.ZodObject<{
@@ -1011,6 +2211,9 @@ declare interface ContextCompacted {
     summaryHadMemoryEcho?: boolean;
 }
 
+/** How a conversation was created / its execution mode. */
+declare type ConversationCreateType = "standard" | "background" | "scheduled";
+
 /**
  * The full `conversation-deleted` context a hook receives — the dispatching
  * call site's {@link ConversationDeletedInputContext} plus the
@@ -1110,8 +2313,8 @@ declare type ConversationListInvalidatedEvent = z.infer<typeof ConversationListI
 declare const ConversationListInvalidatedEventSchema: z.ZodObject<{
     type: z.ZodLiteral<"conversation_list_invalidated">;
     reason: z.ZodEnum<{
-        deleted: "deleted";
         created: "created";
+        deleted: "deleted";
         renamed: "renamed";
         reordered: "reordered";
         seen_changed: "seen_changed";
@@ -1178,6 +2381,40 @@ declare const ConversationNoticeEventSchema: z.ZodObject<{
     errorCategory: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 
+export declare interface ConversationRow {
+    id: string;
+    title: string | null;
+    createdAt: number;
+    updatedAt: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalEstimatedCost: number;
+    contextSummary: string | null;
+    contextCompactedMessageCount: number;
+    contextCompactedAt: number | null;
+    historyStrippedAt: number | null;
+    slackContextCompactionWatermarkTs: string | null;
+    slackContextCompactionWatermarkAt: number | null;
+    conversationType: string;
+    source: string;
+    originChannel: string | null;
+    originInterface: string | null;
+    forkParentConversationId: string | null;
+    forkParentMessageId: string | null;
+    isAutoTitle: number;
+    scheduleJobId: string | null;
+    lastMessageAt: number | null;
+    archivedAt: number | null;
+    surfacedAt: number | null;
+    inferenceProfile: string | null;
+    /** Parsed plugin-id list scoping this chat; null = default (all globally-enabled). */
+    enabledPlugins: string[] | null;
+    inferenceProfileSessionId: string | null;
+    inferenceProfileExpiresAt: number | null;
+    lastNotifiedInferenceProfile: string | null;
+    processingStartedAt: number | null;
+}
+
 declare interface ConversationsClearResponse {
     type: "conversations_clear_response";
     cleared: number;
@@ -1216,6 +2453,9 @@ declare const ConversationTitleUpdatedEventSchema: z.ZodObject<{
 
 declare type ConversationType = "standard" | "background" | "scheduled";
 
+/** Read-side alias of {@link ConversationCreateType}. */
+declare type ConversationType_2 = ConversationCreateType;
+
 declare interface CopyBlockSurfaceData {
     text: string;
     label?: string;
@@ -1226,6 +2466,15 @@ declare interface CustomSlimSkill extends SlimSkillBase {
     origin: "custom";
 }
 
+/**
+ * Delete a conversation, yielding the event loop between row batches, and
+ * enqueue vector-store cleanup for the memory segments and summaries the
+ * delete cascaded away — the same vector-cleanup pairing the host's delete
+ * route performs, so facade callers never leave semantic vectors behind. The lexical-index
+ * purge runs inside the delete itself via the persistence hook.
+ */
+export declare function deleteConversation(id: string): Promise<void>;
+
 declare type _DiagnosticsServerMessages = EnvVarsResponse | DictationResponse;
 
 declare interface DictationResponse {
@@ -1253,9 +2502,9 @@ declare const DiskPressureStatusChangedEventSchema: z.ZodObject<{
         state: z.ZodEnum<{
             unknown: "unknown";
             disabled: "disabled";
+            critical: "critical";
             ok: "ok";
             warning: "warning";
-            critical: "critical";
         }>;
         locked: z.ZodBoolean;
         acknowledged: z.ZodBoolean;
@@ -1421,13 +2670,33 @@ declare interface DynamicPageSurfaceData {
     preview?: DynamicPagePreview;
 }
 
+/** Embed a target and upsert its vector into the vector store. */
+export declare function embedAndUpsert(targetType: EmbeddingTargetType, targetId: string, input: EmbeddingInput, extraPayload?: Record<string, unknown>): Promise<void>;
+
+declare function embedAndUpsert_2(config: AssistantConfig, targetType: "segment" | "item" | "summary" | "media" | "graph_node" | "pkb_file", targetId: string, input: EmbeddingInput, extraPayload?: Record<string, unknown>): Promise<void>;
+
+/** Accepts raw strings as shorthand for text inputs. */
+declare type EmbeddingInput = string | MultimodalEmbeddingInput;
+
+/**
+ * Plugin-facing facade over the embeddings subsystem: self-contained
+ * operations that resolve the live workspace config internally, so callers
+ * (plugins importing via `@vellumai/plugin-api`) hold no host config.
+ *
+ * The operations are loaded via dynamic `import()` inside each wrapper so
+ * that importing this module — which every `@vellumai/plugin-api` consumer
+ * does transitively — does not eagerly pull the embed/vector import graph
+ * (`job-utils`, `embedding-backend`). An eager pull would force those
+ * modules' named exports to resolve at instantiation, which breaks the
+ * intentional partial module mocks in tests.
+ */
+declare type EmbeddingTargetType = Parameters<embedAndUpsert_2>[1];
+
 declare interface EnvVarsResponse {
     type: "env_vars_response";
     vars: Record<string, string>;
 }
 
-declare type ErrorCategory = "permission_denied" | "auth" | "tool_failure" | "unexpected";
-
 declare type ErrorEvent_2 = z.infer<typeof ErrorEventSchema>;
 
 declare const ErrorEventSchema: z.ZodObject<{
@@ -1440,74 +2709,19 @@ declare const ErrorEventSchema: z.ZodObject<{
     conversationId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 
-/**
- * Tool-related type declarations: the neutral leaf module describing
- * tools, permission risk, and tool execution results.
- *
- * Pure type-level declarations only (+ the `RiskLevel` enum, which is a
- * value). No runtime helpers live here — the assistant keeps all behavior
- * functions in `assistant/src/tools/` and re-exports the types from this
- * file. This module imports nothing, so it can sit at the bottom of the
- * import graph and be consumed by `tools/types.ts`, `providers/types.ts`,
- * and `permissions/types.ts` without creating cycles.
- *
- * Heavy daemon-internal references (CES client, host-proxy classes, trust
- * classifications, interface IDs, content blocks, CES `ApprovalRequired`)
- * are held as opaque `unknown` / broadened-`string` placeholders here. The
- * assistant redeclares `Tool`, `ToolContext`, `ToolExecutionResult`,
- * `ToolExecutedEvent`, `ToolLifecycleEvent`, `ToolLifecycleEventHandler`,
- * and `ProxyToolResolver` in `assistant/src/tools/types.ts` with the
- * concrete types in place, so existing call sites keep their full type
- * information. The two sides are structurally independent — no inheritance,
- * no intersection — which avoids TypeScript's contravariance mismatches on
- * lifecycle-event handlers.
- */
-declare type ExecutionTarget = "sandbox" | "host";
-
-/**
- * Telemetry fields stamped centrally by the executor's `emitLifecycleEvent`
- * on terminal (executed/error) lifecycle events.
- */
-declare interface ExecutorTelemetryStamp {
-    /**
-     * Model attribution snapshot for the conversation at invocation time.
-     * Copied from {@link ToolContext.attribution} by the executor; `null` when
-     * resolution failed or no attribution was available.
-     */
-    attribution?: UsageAttributionSnapshot | null;
-    /**
-     * Serialized byte size of the RAW tool input, stamped by the executor
-     * before sensitive-field sanitization rewrites `input`. Only the size
-     * leaves the device, never the payload.
-     */
-    inputBytes?: number | null;
-    /**
-     * Byte size of the RAW tool result content, stamped by the executor
-     * before sensitive-output extraction rewrites `result.content`. Only
-     * stamped on `executed` events: error events carry no executor-side
-     * result — the audit listener sizes the error string it builds itself,
-     * which never goes through sanitization, so it is already raw. Only the
-     * size leaves the device, never the payload.
-     */
-    resultBytes?: number | null;
-}
+export declare function extractTextFromStoredMessageContent(raw: string | ContentBlock[]): string;
 
 export declare interface FileContent {
     type: "file";
-    source: {
-        type: "base64";
-        media_type: string;
-        data: string;
-        filename: string;
-    };
+    source: MediaSource_2;
     extracted_text?: string;
     /**
-     * Internal id linking this block to a row in the attachments table.
-     * Set when the file block originates from a persisted user-message
-     * attachment so downstream consumers (DB joins, inline-chip
-     * positioning) can correlate the block back to its attachment id.
-     * Stripped by `daemon/handlers/shared.ts` before sending to the
-     * model.
+     * Internal id linking a base64 file block to a row in the attachments table
+     * so consumers (DB joins, inline-chip positioning) can correlate the block
+     * back to its attachment. Redundant once the block is a reference (use
+     * `source.attachmentId`); retained only while file media is still persisted
+     * inline as base64, and removed when file uploads move to references.
+     * Stripped by `daemon/handlers/shared.ts` before sending to the model.
      */
     _attachmentId?: string;
 }
@@ -1624,6 +2838,9 @@ declare const GenerationHandoffEventSchema: z.ZodObject<{
     attachmentWarnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 
+/** Read the assistant's name from IDENTITY.md for personalized responses. */
+export declare function getAssistantName(): string | null;
+
 /**
  * Resolve the configured provider through the registry.
  * Thin wrapper around `resolveConfiguredProvider()` for callsites
@@ -1637,6 +2854,18 @@ export declare function getConfiguredProvider(callSite: LLMCallSite, opts?: {
     forceOverrideProfile?: boolean;
 }): Promise<Provider | null>;
 
+/** Look up a conversation row by id. */
+export declare function getConversation(id: string): Promise<ConversationRow | null>;
+
+/**
+ * Absolute path of a conversation's disk-view directory under the workspace
+ * naming scheme (timestamp-first, derived from id + creation time).
+ */
+export declare function getConversationDirPath(id: string, createdAtMs: number): Promise<string>;
+
+/** All messages of a conversation in insertion order. */
+export declare function getMessages(conversationId: string): Promise<MessageRow[]>;
+
 /**
  * List the workspace inference profiles a plugin can route to, in the order the
  * `/model` picker presents them (`llm.profileOrder` first, then the rest
@@ -1718,6 +2947,9 @@ declare interface GuardianDecisionPrompt {
     executionTarget?: "sandbox" | "host";
 }
 
+/** Whether the text tokenizes to at least one lexical search token. */
+export declare function hasLexicalTokens(text: string): Promise<boolean>;
+
 declare interface HeartbeatAlert {
     type: "heartbeat_alert";
     title: string;
@@ -1843,6 +3075,8 @@ declare interface HistoryResponseToolCall {
     imageData?: string;
     /** Base64-encoded image data from tool contentBlocks (e.g. browser_screenshot, image generation). */
     imageDataList?: string[];
+    /** Workspace attachment ids for tool-result images persisted as references; clients fetch bytes by id on render instead of embedding base64. */
+    imageAttachmentIds?: string[];
     /** Unix ms when the tool started executing. */
     startedAt?: number;
     /** Unix ms when the tool completed. */
@@ -2101,7 +3335,7 @@ declare interface HostBashRequest {
     command: string;
     working_dir?: string;
     timeout_seconds?: number;
-    /** Extra environment variables to inject into the subprocess (e.g. VELLUM_UNTRUSTED_SHELL). */
+    /** Extra environment variables to inject into the subprocess (e.g. __CONVERSATION_ID). */
     env?: Record<string, string>;
     /** When set, route this request only to the client with this ID. */
     targetClientId?: string;
@@ -2263,11 +3497,13 @@ declare interface IdentityGetResponse {
 
 export declare interface ImageContent {
     type: "image";
-    source: {
-        type: "base64";
-        media_type: string;
-        data: string;
-    };
+    source: MediaSource_2;
+}
+
+declare interface ImageEmbeddingInput {
+    type: "image";
+    data: Buffer;
+    mimeType: string;
 }
 
 declare type _InboxServerMessages = ContactsInviteResponse | AssistantInboxEscalationResponse;
@@ -2319,6 +3555,18 @@ export declare interface InitContext {
     assistantVersion: string;
 }
 
+/** Shape returned by {@link insertMessageCore} and its public wrappers. */
+declare interface InsertedMessage {
+    id: string;
+    conversationId: string;
+    role: MessageRole;
+    content: string;
+    createdAt: number;
+    metadata?: string;
+    clientMessageId?: string;
+    deduplicated: boolean;
+}
+
 declare interface IntegrationConnectResult {
     type: "integration_connect_result";
     integrationId: string;
@@ -2350,11 +3598,11 @@ declare const InteractionResolvedEventSchema: z.ZodObject<{
     requestId: z.ZodString;
     conversationId: z.ZodString;
     state: z.ZodEnum<{
-        approved: "approved";
         cancelled: "cancelled";
+        superseded: "superseded";
+        approved: "approved";
         rejected: "rejected";
         answered: "answered";
-        superseded: "superseded";
     }>;
     kind: z.ZodString;
 }, z.core.$strip>;
@@ -2363,6 +3611,9 @@ declare const INTERFACE_IDS: readonly ["macos", "ios", "cli", "telegram", "phone
 
 declare type InterfaceId = (typeof INTERFACE_IDS)[number];
 
+/** Whether the conversation currently has a turn in flight. */
+export declare function isConversationProcessing(id: string): Promise<boolean>;
+
 /**
  * Provider stop-reason classification.
  *
@@ -2380,6 +3631,33 @@ declare type InterfaceId = (typeof INTERFACE_IDS)[number];
  */
 export declare function isMaxTokensStopReason(stopReason: string | null | undefined): boolean;
 
+/**
+ * The remote skill catalog, fetched via the shared catalog cache. Entries
+ * whose declared feature flag is disabled are reported with
+ * `state: "unavailable"`; all others are `state: "available"`. Not deduplicated
+ * against the installed catalog — callers that merge the two lists filter by
+ * installed ids themselves.
+ *
+ * A fetch failure never rejects: the underlying cache degrades through its
+ * fallback chain (stale cache → bundled local catalog → empty) and this
+ * returns whatever that yields. An empty result therefore means "could not
+ * enumerate the catalog" as much as "the catalog is empty" — callers must
+ * gate destructive reconciliation (pruning against the catalog id set) on a
+ * non-empty result. Unexpected errors from the catalog read propagate.
+ */
+export declare function listCatalogSkills(): Promise<ResolvedSkillEntry[]>;
+
+/** List conversation rows, newest first. */
+export declare function listConversations(limit?: number, conversationType?: ConversationType_2, offset?: number, archiveStatus?: ArchiveStatusFilter, originChannel?: string): Promise<ConversationRow[]>;
+
+/**
+ * The locally installed skill catalog with resolved states. Includes every
+ * catalog entry — skills dropped by flag gating or the bundled allowlist are
+ * reported with `state: "unavailable"` rather than omitted, so the returned
+ * ids are the complete installed universe.
+ */
+export declare function listInstalledSkills(): Promise<ResolvedSkillEntry[]>;
+
 declare interface ListItem {
     id: string;
     title: string;
@@ -2408,7 +3686,6 @@ declare const LLMCallSiteEnum: z.ZodEnum<{
     heartbeatAgent: "heartbeatAgent";
     filingAgent: "filingAgent";
     compactionAgent: "compactionAgent";
-    analyzeConversation: "analyzeConversation";
     callAgent: "callAgent";
     memoryExtraction: "memoryExtraction";
     memoryConsolidation: "memoryConsolidation";
@@ -2446,6 +3723,8 @@ declare const LLMCallSiteEnum: z.ZodEnum<{
     workflowLeaf: "workflowLeaf";
 }>;
 
+declare type MediaSource_2 = Base64MediaSource | WorkspaceRefMediaSource;
+
 declare interface MemoryRecalled {
     type: "memory_recalled";
     provider: string;
@@ -2543,6 +3822,125 @@ declare const MessageDequeuedEventSchema: z.ZodObject<{
     requestId: z.ZodString;
 }, z.core.$strip>;
 
+declare type MessageLexicalSearchResult = Awaited<ReturnType<searchMessageIdsLexical_2>>[number];
+
+declare interface MessageLexicalSearchResult_2 {
+    messageId: string;
+    score: number;
+}
+
+/**
+ * Plugin-facing facade over the host conversation store: reads and writes on
+ * conversations and their message history, plus the lexical message-search
+ * surface. Every operation takes explicit parameters and resolves nothing
+ * from config, so the wrappers are pure pass-throughs.
+ *
+ * The store modules are loaded via dynamic `import()` inside each wrapper —
+ * they carry the DB/drizzle import graph and are among the most
+ * partial-mocked modules in the test suite, so importing this module (which
+ * every `@vellumai/plugin-api` consumer does transitively) must not force
+ * their named exports to resolve at instantiation. All type imports above are
+ * erased at compile time. Async for that reason, including the wrappers whose
+ * underlying functions are synchronous.
+ */
+declare type MessageMetadata = ReturnType<parseMessageMetadata_2>;
+
+/** Validated shape of a persisted message's `metadata` column. */
+declare type MessageMetadata_2 = z.infer<typeof messageMetadataSchema>;
+
+declare const messageMetadataSchema: z.ZodObject<{
+    userMessageChannel: z.ZodOptional<z.ZodEnum<{
+        vellum: "vellum";
+        telegram: "telegram";
+        phone: "phone";
+        whatsapp: "whatsapp";
+        slack: "slack";
+        email: "email";
+        platform: "platform";
+        a2a: "a2a";
+    }>>;
+    assistantMessageChannel: z.ZodOptional<z.ZodEnum<{
+        vellum: "vellum";
+        telegram: "telegram";
+        phone: "phone";
+        whatsapp: "whatsapp";
+        slack: "slack";
+        email: "email";
+        platform: "platform";
+        a2a: "a2a";
+    }>>;
+    userMessageInterface: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<"telegram" | "phone" | "whatsapp" | "slack" | "email" | "a2a" | "macos" | "ios" | "cli" | "web" | "chrome-extension" | null, string>> & z.ZodType<"telegram" | "phone" | "whatsapp" | "slack" | "email" | "a2a" | "macos" | "ios" | "cli" | "web" | "chrome-extension", string, z.core.$ZodTypeInternals<"telegram" | "phone" | "whatsapp" | "slack" | "email" | "a2a" | "macos" | "ios" | "cli" | "web" | "chrome-extension", string>>>;
+    assistantMessageInterface: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<"telegram" | "phone" | "whatsapp" | "slack" | "email" | "a2a" | "macos" | "ios" | "cli" | "web" | "chrome-extension" | null, string>> & z.ZodType<"telegram" | "phone" | "whatsapp" | "slack" | "email" | "a2a" | "macos" | "ios" | "cli" | "web" | "chrome-extension", string, z.core.$ZodTypeInternals<"telegram" | "phone" | "whatsapp" | "slack" | "email" | "a2a" | "macos" | "ios" | "cli" | "web" | "chrome-extension", string>>>;
+    client: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    subagentNotification: z.ZodOptional<z.ZodObject<{
+        subagentId: z.ZodString;
+        label: z.ZodString;
+        status: z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+            running: "running";
+            aborted: "aborted";
+        }>;
+        error: z.ZodOptional<z.ZodString>;
+        conversationId: z.ZodOptional<z.ZodString>;
+        objective: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    acpNotification: z.ZodOptional<z.ZodObject<{
+        acpSessionId: z.ZodString;
+        agent: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    provenanceTrustClass: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        guardian: "guardian";
+        trusted_contact: "trusted_contact";
+        unverified_contact: "unverified_contact";
+    }>>;
+    model: z.ZodOptional<z.ZodString>;
+    provenanceSourceChannel: z.ZodOptional<z.ZodEnum<{
+        vellum: "vellum";
+        telegram: "telegram";
+        phone: "phone";
+        whatsapp: "whatsapp";
+        slack: "slack";
+        email: "email";
+        platform: "platform";
+        a2a: "a2a";
+    }>>;
+    provenanceGuardianExternalUserId: z.ZodOptional<z.ZodString>;
+    provenanceRequesterIdentifier: z.ZodOptional<z.ZodString>;
+    automated: z.ZodOptional<z.ZodBoolean>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    backgroundToolCompletion: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        toolName: z.ZodString;
+        conversationId: z.ZodString;
+        command: z.ZodString;
+        startedAt: z.ZodNumber;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            completed: "completed";
+            failed: "failed";
+        }>;
+        exitCode: z.ZodNullable<z.ZodNumber>;
+        output: z.ZodString;
+        completedAt: z.ZodNumber;
+    }, z.core.$strip>>;
+    forkSourceMessageId: z.ZodOptional<z.ZodString>;
+    imageSourcePaths: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    attachmentStoredPaths: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    memoryInjectedBlock: z.ZodOptional<z.ZodString>;
+    memoryV3InjectedBlock: z.ZodOptional<z.ZodString>;
+    turnContextBlock: z.ZodOptional<z.ZodString>;
+    pkbSystemReminderBlock: z.ZodOptional<z.ZodString>;
+    workspaceBlock: z.ZodOptional<z.ZodString>;
+    nowScratchpadBlock: z.ZodOptional<z.ZodString>;
+    pkbContextBlock: z.ZodOptional<z.ZodString>;
+    memoryV2StaticBlock: z.ZodOptional<z.ZodString>;
+    backgroundTurnBlock: z.ZodOptional<z.ZodString>;
+    channelCapabilitiesBlock: z.ZodOptional<z.ZodString>;
+    nonInteractiveContextBlock: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+
 declare type MessageQueuedDeletedEvent = z.infer<typeof MessageQueuedDeletedEventSchema>;
 
 declare const MessageQueuedDeletedEventSchema: z.ZodObject<{
@@ -2569,6 +3967,27 @@ declare const MessageRequestCompleteEventSchema: z.ZodObject<{
     runStillActive: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 
+/** Allowed values for the `role` column on `messages`. */
+declare type MessageRole = "user" | "assistant" | "system";
+
+declare interface MessageRow {
+    id: string;
+    conversationId: string;
+    role: string;
+    /**
+     * Typed content blocks, resolved at the row-fetch chokepoint by
+     * `resolveMessageContentBlocks`: inline JSON parses, file-backed
+     * `{ ref }` rows fold their delta file, and legacy plain strings arrive
+     * wrapped in a single text block.
+     */
+    content: ContentBlock[];
+    createdAt: number;
+    metadata: string | null;
+    clientMessageId: string | null;
+    /** 1 = content is complete; 0 = message is still streaming. */
+    finalized: number;
+}
+
 declare type _MessagesServerMessages = UserMessageEchoEvent | AssistantTurnStartEvent | AssistantTextDeltaEvent | AssistantThinkingDeltaEvent | ToolUseStartEvent | ToolUsePreviewStartEvent | ToolOutputChunkEvent | ToolInputDelta | ToolResultEvent | ConfirmationRequestEvent | SecretRequestEvent | QuestionRequestEvent | MessageCompleteEvent | ErrorEvent_2 | MessageQueuedEvent | MessageDequeuedEvent | MessageRequestCompleteEvent | MessageQueuedDeletedEvent | MessageSteered | SuggestionResponse | ConfirmationStateChanged | AssistantActivityStateEvent | ConversationInferenceProfileUpdated | InteractionResolvedEvent;
 
 declare interface MessageSteered {
@@ -2627,6 +4046,8 @@ export declare interface ModelProfileInfo {
     readonly isMix: boolean;
 }
 
+declare type MultimodalEmbeddingInput = TextEmbeddingInput | ImageEmbeddingInput | AudioEmbeddingInput | VideoEmbeddingInput;
+
 declare type NavigateSettingsEvent = z.infer<typeof NavigateSettingsEventSchema>;
 
 declare const NavigateSettingsEventSchema: z.ZodObject<{
@@ -2764,18 +4185,37 @@ declare const OpenUrlEventSchema: z.ZodObject<{
 }, z.core.$strip>;
 
 /**
- * Identifies which extension owns a tool (skill / plugin / MCP server).
- * Tracked by the tool registry keyed by tool name, not stored on the `Tool`
- * object itself — query via {@link ../tools/registry.getToolOwner}.
+ * Identifies what owns a tool: the built-in default set, or a skill / plugin /
+ * MCP server / workspace override. Tracked by the tool registry keyed by tool
+ * name, not stored on the `Tool` object itself — query via
+ * {@link ../tools/registry.getToolOwner}.
  */
 declare interface OwnerInfo {
     kind: OwnerKind;
-    /** ID of the owning extension (skill id / plugin name / MCP server id / workspace path). */
+    /** ID of the owner: skill id / plugin name / MCP server id / workspace path, or `"default"` for built-ins. */
     id: string;
 }
 
-/** The kind of extension that owns a tool. Core tools have no owner. */
-declare type OwnerKind = "skill" | "mcp" | "plugin" | "workspace";
+/**
+ * The kind of entity that owns a tool. `"default"` is the built-in tool set
+ * that ships with the assistant; the others are extension surfaces. Every
+ * *registered* tool has an owner — {@link ../tools/registry.getToolOwner}
+ * returns `undefined` only for a name that is not registered at all.
+ */
+declare type OwnerKind = "default" | "skill" | "mcp" | "plugin" | "workspace";
+
+/** Parse a stored message-metadata JSON string; undefined when absent/invalid. */
+export declare function parseMessageMetadata(metadataJson: string | null): Promise<MessageMetadata>;
+
+/**
+ * Parse a persisted message's metadata JSON against {@link messageMetadataSchema}
+ * — the single source of truth for its shape — returning the validated fields,
+ * or `undefined` when the column is absent, not valid JSON, or fails validation.
+ * The single place the raw JSON.parse + safeParse dance lives, so callers read
+ * typed fields (e.g. `provenanceTrustClass`, `automated`, `subagentNotification`)
+ * instead of re-implementing it.
+ */
+declare function parseMessageMetadata_2(metadataJson: string | null): MessageMetadata_2 | undefined;
 
 declare interface PartnerAudit {
     risk: RiskLevel_2;
@@ -3368,6 +4808,70 @@ declare const RelationshipStateUpdatedEventSchema: z.ZodObject<{
     updatedAt: z.ZodString;
 }, z.core.$strip>;
 
+/**
+ * Plugin-facing read API over the skill surface: the locally installed
+ * catalog with resolved enablement states, and the remote skill catalog —
+ * each composed host-side (catalog load + install-state resolution +
+ * feature-flag gating + install-meta read), so callers hold no host config
+ * and perform no flag checks of their own.
+ *
+ * The underlying skill and flag modules are loaded via dynamic `import()`
+ * inside each function so that importing this module — which every
+ * `@vellumai/plugin-api` consumer does transitively — does not eagerly pull
+ * the catalog/flag import graph. An eager pull would force those modules'
+ * named exports to resolve at instantiation, which breaks the intentional
+ * partial module mocks in tests.
+ */
+/** One skill as seen by a plugin: capability fields plus resolved state. */
+export declare interface ResolvedSkillEntry {
+    id: string;
+    displayName: string;
+    description: string;
+    /** Compact routing cues declared in frontmatter / catalog metadata. */
+    activationHints?: string[];
+    /** Conditions under which the skill should not be loaded. */
+    avoidWhen?: string[];
+    /** True when the skill is pinned into the memory selector pool every turn. */
+    alwaysCandidate?: boolean;
+    /** True for locally installed skills; false for remote catalog entries. */
+    installed: boolean;
+    /** Where the installed skill comes from. Unset for remote catalog entries. */
+    source?: SkillSource;
+    /**
+     * Resolved availability:
+     * - `enabled` / `disabled` — installed, per config and source defaults.
+     * - `unavailable` — gated off (feature flag disabled, or a bundled skill
+     *   excluded by the `allowBundled` allowlist). Present so callers can still
+     *   enumerate the full id universe.
+     * - `available` — a remote catalog entry that is not locally installed.
+     */
+    state: "enabled" | "disabled" | "unavailable" | "available";
+    /**
+     * Install metadata for user-installed skills (`managed` / `workspace` /
+     * `extra` sources): `null` when the directory has no install-meta file,
+     * unset for sources that never carry one (bundled, plugin, remote).
+     */
+    installMeta?: SkillInstallMeta | null;
+}
+
+/**
+ * Resolve a media source to inline base64, reading a reference source back from
+ * its workspace location. Returns `null` when a reference can no longer be
+ * read. For consumers that hold an individual in-memory block (image
+ * captioning, media retry) and need its bytes outside the provider transform.
+ */
+export declare function resolveMediaSourceData(source: MediaSource_2): {
+    data: string;
+    media_type: string;
+} | null;
+
+/**
+ * Read the guardian's display name from `users/default.md`. We look for the
+ * markdown-bold "Name" label (matching the IDENTITY.md convention) and fall
+ * back to `null` on any miss; callers substitute a generic label.
+ */
+export declare function resolveUserName(workspaceDir: string): string | null;
+
 export declare enum RiskLevel {
     Low = "low",
     Medium = "medium",
@@ -3430,11 +4934,42 @@ declare interface SchedulesListResponse {
 
 declare type _SchedulesServerMessages = SchedulesListResponse | HeartbeatAlert | HeartbeatConversationCreated | HeartbeatConfigResponse | HeartbeatRunsListResponse | HeartbeatRunNowResponse | HeartbeatChecklistResponse | HeartbeatChecklistWriteResponse | FilingConfigResponse | FilingRunNowResponse;
 
-declare interface ScopeOption {
-    label: string;
-    scope: string;
-}
+/** Sparse lexical search over stored message text; ranked message-id hits. */
+export declare function searchMessageIdsLexical(query: string, limit: number, opts?: {
+    conversationId?: string;
+}): Promise<MessageLexicalSearchResult[]>;
 
+/**
+ * Resolve message-id candidates for `query` from the Qdrant lexical index,
+ * ranked by sparse similarity score (highest first).
+ *
+ * This is a **pure lexical candidate generator**: it returns the top-`limit`
+ * message ids by sparse score with NO visibility, source, or
+ * active-conversation filtering (the only scoping it applies is the optional
+ * `conversationId` restriction). Those exclusions (active conversation,
+ * private conversations, non-message sources) live in SQL at the read sites.
+ *
+ * Callers that apply such post-retrieval SQL filters MUST over-fetch: pass an
+ * inflated `limit` (the `QDRANT_RECALL_CANDIDATE_MULTIPLIER` /
+ * `QDRANT_SEARCH_CANDIDATE_LIMIT` pattern the read sites use) and re-limit
+ * after filtering in SQL. Applying the caller's real limit here first would
+ * let excluded rows consume the candidate slots and drop valid visible
+ * matches below the fold.
+ *
+ * @param query          free-text search query
+ * @param limit          maximum number of candidates to return
+ * @param opts.conversationId  restrict results to a single conversation
+ */
+declare function searchMessageIdsLexical_2(query: string, limit: number, opts?: {
+    conversationId?: string;
+}): Promise<MessageLexicalSearchResult_2[]>;
+
+/**
+ * Result vocabulary for a secret prompt: how the value is delivered and the
+ * outcome of the prompt. Kept in a leaf module (no runtime dependencies) so
+ * type-only consumers can reference the shapes without importing the prompter
+ * implementation and its daemon-internal dependencies.
+ */
 declare type SecretDelivery = "store" | "transient_send";
 
 declare interface SecretPromptResult {
@@ -3445,11 +4980,22 @@ declare interface SecretPromptResult {
     /**
      * Why `value` is null. `"cancelled"` = the user explicitly dismissed the
      * prompt (a valid flow, not a failure); `"timed_out"` = no response within
-     * the permission-timeout window. Only meaningful when `value` is null and
-     * `error` is unset. Lets callers distinguish a deliberate cancel from a
-     * genuine failure instead of treating both as an error.
+     * the permission-timeout window; `"superseded"` = a newer message in the
+     * conversation auto-denied the pending prompt before anyone answered it.
+     * Only meaningful when `value` is null and `error` is unset. Lets callers
+     * distinguish a deliberate cancel from a genuine failure instead of
+     * treating both as an error.
+     */
+    reason?: "cancelled" | "timed_out" | "superseded";
+    /**
+     * One-time collection URL minted when the channel cannot render the secure
+     * prompt. Set together with `error: "unsupported_channel"` — the caller
+     * relays the link so the user can supply the value out of band; the gateway
+     * stores the submitted value via the credential vault.
      */
-    reason?: "cancelled" | "timed_out";
+    collectionUrl?: string;
+    /** Expiry (epoch ms) of {@link SecretPromptResult.collectionUrl}. */
+    collectionExpiresAt?: number;
 }
 
 declare type SecretRequestEvent = z.infer<typeof SecretRequestEventSchema>;
@@ -3469,6 +5015,9 @@ declare const SecretRequestEventSchema: z.ZodObject<{
     allowOneTimeSend: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 
+/** Whether the active embedding backend handles multimodal inputs. */
+export declare function selectedBackendSupportsMultimodal(): Promise<boolean>;
+
 export declare interface SendMessageConfig {
     model?: string;
     /**
@@ -3652,6 +5201,13 @@ declare interface ShowPlatformLogin {
  * The `assistantVersion` field mirrors the init context's so plugins that stash
  * a version stamp at init can compare against the same name on tear-down
  * without keeping their own copy.
+ *
+ * **`shutdown` may run in a different process than `init`.** A managed
+ * `uninstall` runs it in whichever process performs the removal (the CLI or the
+ * daemon), which is not necessarily the daemon process that ran `init`. Do not
+ * close over in-memory state established at `init` (open handles, timers,
+ * module-level singletons) and expect to tear it down here — reconstruct
+ * anything you need from the plugin's config and `data/` directory instead.
  */
 export declare interface ShutdownContext {
     /** Assistant semver for compatibility checks inside the plugin. */
@@ -3668,8 +5224,10 @@ export declare interface ShutdownContext {
  * - `disable` — the plugin was disabled at runtime (e.g. a `.disabled`
  *   sentinel was added, or a feature flag turned it off).
  * - `reload` — a source file inside the plugin directory changed and the
- *   plugin is being redeployed in place; the old version's `shutdown` runs
- *   before the new version is imported and its `init` fires.
+ *   plugin is being redeployed in place; `shutdown` runs before the new version
+ *   is imported and its `init` fires. Note the `shutdown` that runs is the one
+ *   currently on disk, which is the previous version *unless* the edit was to
+ *   `shutdown` itself.
  */
 declare type ShutdownReason = "shutdown" | "uninstall" | "disable" | "reload";
 
@@ -3687,6 +5245,21 @@ declare interface SkillBodyResponse {
     error?: string;
 }
 
+declare interface SkillInstallMeta {
+    origin: "vellum" | "clawhub" | "skillssh" | "custom";
+    installedAt: string;
+    installedBy?: string;
+    backfilledBy?: string;
+    version?: string;
+    slug?: string;
+    sourceRepo?: string;
+    contentHash?: string;
+    author?: "assistant" | "user";
+    sourceConversationId?: string;
+    retrospectiveConversationId?: string;
+    lastUsedAt?: string;
+}
+
 declare interface SkillsDraftResponse {
     type: "skills_draft_response";
     success: boolean;
@@ -3742,6 +5315,20 @@ declare interface SkillsListResponse {
     skills: SlimSkillResponse[];
 }
 
+/**
+ * Origin of a skill in the merged catalog.
+ *
+ * - `bundled`: ships inside the assistant binary under `bundled-skills/`.
+ * - `managed`: installed into `$VELLUM_WORKSPACE_DIR/skills/` from our catalog.
+ * - `workspace`: user-authored skill living in a conversation's working dir.
+ * - `extra`: third-party directory roots passed via `loadSkillCatalog`'s
+ *   `extraDirs` argument (primarily for tests).
+ * - `plugin`: shipped on disk inside an installed plugin at
+ *   `<workspaceDir>/plugins/<name>/skills/<id>/SKILL.md`, attributed back to
+ *   the owning plugin via its `owner` descriptor.
+ */
+declare type SkillSource = "bundled" | "managed" | "workspace" | "extra" | "plugin";
+
 declare type _SkillsServerMessages = SkillsListResponse | SkillBodyResponse | SkillStateChanged | SkillsInspectResponse | SkillsDraftResponse;
 
 declare interface SkillsshSlimSkill extends SlimSkillBase {
@@ -3844,6 +5431,23 @@ declare interface StopInputContext {
     readonly exitReason: AgentLoopExitReason;
 }
 
+/**
+ * Coerce stored message content into a single human-readable text string,
+ * dropping non-text blocks (images, tool calls, tool results, thinking,
+ * …). Used by call sites that want only the spoken text — sweep-model
+ * context, RAG backfill, bookmark previews. For richer renderings that
+ * include tool metadata, use {@link extractTextFromStoredMessageContent}
+ * instead.
+ *
+ * Handles the two on-disk shapes:
+ *   - Modern rows: JSON-serialized `ContentBlock[]`
+ *   - Legacy rows: plain string
+ *
+ * Parse failures fall back to returning the raw input trimmed (the
+ * legacy-string path).
+ */
+export declare function stringifyMessageContent(stored: string | ContentBlock[]): string;
+
 declare interface SubagentDetailResponse {
     type: "subagent_detail_response";
     subagentId: string;
@@ -3930,6 +5534,32 @@ declare const SyncChangedEventSchema: z.ZodObject<{
 
 declare type _SyncInvalidationServerMessages = SyncChangedEvent;
 
+/** Re-sync one persisted message into the conversation's disk view. */
+export declare function syncMessageToDisk(conversationId: string, messageId: string, createdAtMs: number): Promise<void>;
+
+/**
+ * Synthesize text to audio using the globally configured TTS provider.
+ *
+ * 1. Resolves the active provider and its config via `tts-config-resolver`.
+ * 2. Looks up the provider adapter in the registry.
+ * 3. Delegates to the adapter's `synthesize` method.
+ *
+ * Throws {@link TtsSynthesisError} when the provider is not registered
+ * or synthesis fails.
+ */
+export declare function synthesizeText(options: SynthesizeTextOptions): Promise<TtsSynthesisResult>;
+
+export declare interface SynthesizeTextOptions {
+    /** Text to speak. Sanitized internally — callers can pass raw model output. */
+    text: string;
+    /** Product surface requesting synthesis. */
+    useCase: TtsUseCase;
+    /** Optional voice override (provider-specific identifier). */
+    voiceId?: string;
+    /** Optional abort signal. */
+    signal?: AbortSignal;
+}
+
 declare interface TableCellValue {
     text: string;
     icon?: string;
@@ -3990,6 +5620,11 @@ export declare interface TextContent {
     text: string;
 }
 
+declare interface TextEmbeddingInput {
+    type: "text";
+    text: string;
+}
+
 export declare interface ThinkingContent {
     type: "thinking";
     thinking: string;
@@ -4049,11 +5684,6 @@ export declare interface ToolContext {
      * @legacy
      */
     attribution?: UsageAttributionSnapshot | null;
-    /**
-     * Optional callback for tool lifecycle events (start/prompt/deny/execute/error).
-     * @legacy
-     */
-    onToolLifecycleEvent?: ToolLifecycleEventHandler;
     /**
      * Optional resolver for proxy tools - delegates execution to an external client.
      * @legacy
@@ -4109,9 +5739,9 @@ export declare interface ToolContext {
      * "Always Allow" rules, or non-interactive auto-approve shortcuts may
      * bypass the prompt. This flag is independently sufficient: it
      * promotes allow → prompt decisions on its own and suppresses
-     * temporary override options in the prompt UI. Used by
-     * `manage_secure_command_tool` to ensure a human reviews each secure
-     * bundle installation.
+     * temporary override options in the prompt UI. Used by the `run_workflow`
+     * launch path so a human consents to a run whose capability manifest grants
+     * side-effecting tools.
      * @legacy
      */
     requireFreshApproval?: boolean;
@@ -4321,54 +5951,6 @@ declare const ToolDefinitionSchema: z.ZodObject<{
     exclusive: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 
-/**
- * `ToolExecutedEvent` carries a `result: ToolExecutionResult` field, so
- * the assistant re-declares it here to reference the assistant-side
- * `ToolExecutionResult` (which narrows `contentBlocks` to `ContentBlock[]`
- * and `cesApprovalRequired` to `ApprovalRequired`).
- */
-declare interface ToolExecutedEvent extends ExecutorTelemetryStamp {
-    type: "executed";
-    toolName: string;
-    input: Record<string, unknown>;
-    workingDir: string;
-    conversationId: string;
-    requestId?: string;
-    executionTarget?: ExecutionTarget;
-    riskLevel: string;
-    /** ID of the trust rule that matched this invocation (if any). */
-    matchedTrustRuleId?: string;
-    /** How the approval decision was reached. Copied from PermissionDecision for analytics consumers. */
-    approvalMode?: string;
-    /** Why the approval decision was reached (stable enum). Copied from PermissionDecision for analytics consumers. */
-    approvalReason?: string;
-    decision: string;
-    durationMs: number;
-    result: ToolExecutionResult;
-}
-
-/**
- * Extends the contracts declaration with the assistant-side telemetry
- * fields stamped centrally by the executor's `emitLifecycleEvent`.
- */
-declare interface ToolExecutionErrorEvent extends ToolExecutionErrorEvent_2, ExecutorTelemetryStamp {
-}
-
-declare interface ToolExecutionErrorEvent_2 extends ToolLifecycleEventBase {
-    type: "error";
-    riskLevel: string;
-    /** ID of the trust rule that matched this invocation (if any). */
-    matchedTrustRuleId?: string;
-    decision: string;
-    durationMs: number;
-    errorMessage: string;
-    isExpected: boolean;
-    /** Classifies the error for downstream consumers (audit, alerting, monitoring). */
-    errorCategory: ErrorCategory;
-    errorName?: string;
-    errorStack?: string;
-}
-
 export declare interface ToolExecutionResult {
     /** Textual result shown to the model in the tool-result block. Empty string is valid. */
     content: string;
@@ -4439,25 +6021,11 @@ export declare interface ToolExecutionResult {
         scope: string;
         label: string;
     }>;
-    /**
-     * When present, indicates that a CES tool returned an `approval_required`
-     * response. The executor uses the approval bridge to prompt the guardian,
-     * commit the grant decision to CES, and retry the original tool invocation
-     * with the granted grantId. CES tools populate this field rather than
-     * returning a textual error so the executor can intercept and handle the
-     * approval flow transparently.
-     */
-    cesApprovalRequired?: ApprovalRequired;
     /** Structured activity metadata for client rendering (web search, web fetch, etc).
      *  Populated by daemon-internal tools; plugins must not set this. */
     activityMetadata?: ToolActivityMetadata;
 }
 
-declare interface ToolExecutionStartEvent extends ToolLifecycleEventBase {
-    type: "start";
-    startedAtMs: number;
-}
-
 declare interface ToolInputDelta {
     type: "tool_input_delta";
     toolName: string;
@@ -4481,19 +6049,6 @@ declare interface ToolInputSchema {
     required?: string[];
 }
 
-declare type ToolLifecycleEvent = ToolExecutionStartEvent | ToolPermissionPromptEvent | ToolPermissionDeniedEvent | ToolExecutedEvent | ToolExecutionErrorEvent;
-
-declare interface ToolLifecycleEventBase {
-    toolName: string;
-    input: Record<string, unknown>;
-    workingDir: string;
-    conversationId: string;
-    requestId?: string;
-    executionTarget?: ExecutionTarget;
-}
-
-declare type ToolLifecycleEventHandler = (event: ToolLifecycleEvent) => void | Promise<void>;
-
 declare interface ToolNamesListResponse {
     type: "tool_names_list_response";
     /** Sorted list of all registered tool names. */
@@ -4521,30 +6076,6 @@ declare const ToolOutputChunkEventSchema: z.ZodObject<{
     messageId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 
-declare interface ToolPermissionDeniedEvent extends ToolLifecycleEventBase {
-    type: "permission_denied";
-    riskLevel: string;
-    /** Classifier-provided reason explaining why the risk level was assigned (bash/host_bash only). */
-    riskReason?: string;
-    /** ID of the trust rule that matched this invocation (if any). */
-    matchedTrustRuleId?: string;
-    decision: "deny" | "always_deny";
-    reason: string;
-    durationMs: number;
-}
-
-declare interface ToolPermissionPromptEvent extends ToolLifecycleEventBase {
-    type: "permission_prompt";
-    riskLevel: string;
-    /** Classifier-provided reason explaining why the risk level was assigned (bash/host_bash only). */
-    riskReason?: string;
-    reason: string;
-    allowlistOptions: AllowlistOption[];
-    scopeOptions: ScopeOption[];
-    diff?: DiffInfo;
-    persistentDecisionsAllowed?: boolean;
-}
-
 declare interface ToolPermissionSimulateResponse {
     type: "tool_permission_simulate_response";
     success: boolean;
@@ -4716,6 +6247,31 @@ declare const trustClassSchema: z.ZodEnum<{
     unverified_contact: "unverified_contact";
 }>;
 
+export declare class TtsSynthesisError extends Error {
+    readonly code: TtsSynthesisErrorCode;
+    constructor(code: TtsSynthesisErrorCode, message: string);
+}
+
+declare type TtsSynthesisErrorCode = "TTS_PROVIDER_NOT_CONFIGURED" | "TTS_SYNTHESIS_FAILED";
+
+/** Output of a completed TTS synthesis call. */
+export declare interface TtsSynthesisResult {
+    /** Complete audio buffer. */
+    audio: Buffer;
+    /** MIME type of the returned audio (e.g. `"audio/mpeg"`, `"audio/wav"`). */
+    contentType: string;
+}
+
+/**
+ * Describes the product surface that is requesting synthesis so providers
+ * can tailor format, latency, and quality trade-offs.
+ */
+declare type TtsUseCase = 
+/** Real-time phone call — prioritize low latency and streaming. */
+"phone-call"
+/** In-app message playback — buffer-oriented, higher quality acceptable. */
+| "message-playback";
+
 declare interface UiSurfaceComplete {
     type: "ui_surface_complete";
     conversationId: string;
@@ -4836,6 +6392,9 @@ declare interface UnpublishPageResponse {
     error?: string;
 }
 
+/** Merge the given keys into a message's metadata JSON. */
+export declare function updateMessageMetadata(messageId: string, updates: Record<string, unknown>): Promise<void>;
+
 declare type _UpgradesServerMessages = ServiceGroupUpdateStarting | ServiceGroupUpdateProgress | ServiceGroupUpdateComplete;
 
 declare type UsageAttributionProfileSource = "call_site" | "conversation" | "active" | "default" | "unknown";
@@ -4971,8 +6530,8 @@ declare interface UserPromptSubmitInputContext {
      *   `requestId` instead. Every path that starts an agent loop persists the
      *   triggering user message under the turn's request ID before running, so
      *   the message row id and the request's correlation ID are the same UUID.
-     *   This holds for the standard submit, queue-drain, subagent, voice, wake,
-     *   and conversation-analysis paths alike. This field will be removed in a
+     *   This holds for the standard submit, queue-drain, subagent, voice, and
+     *   wake paths alike. This field will be removed in a
      *   future API version.
      */
     readonly userMessageId: string;
@@ -5045,6 +6604,12 @@ declare interface VercelApiConfigResponse {
     error?: string;
 }
 
+declare interface VideoEmbeddingInput {
+    type: "video";
+    data: Buffer;
+    mimeType: string;
+}
+
 declare interface WebFetchMetadata {
     url: string;
     finalUrl: string;
@@ -5436,6 +7001,31 @@ declare interface WorkspaceFilesListResponse {
     }>;
 }
 
+/**
+ * A reference to bytes stored in the workspace rather than inlined. The bytes
+ * live in the workspace attachment store, addressed by `attachmentId`, and are
+ * read back at the provider send boundary. User uploads are attachment rows
+ * already; tool-result media is materialized into attachment rows before it is
+ * referenced, so a single `attachmentId` resolves every case and needs no
+ * fallback locator.
+ *
+ * `sizeBytes` (and, for images, `width`/`height`) are the persist-time hints
+ * that let size-only consumers cost the block without a disk read.
+ */
+declare interface WorkspaceRefMediaSource {
+    type: "workspace_ref";
+    media_type: string;
+    /** Attachment row id; resolves to bytes via the attachment store. */
+    attachmentId: string;
+    /** Byte length of the referenced file. */
+    sizeBytes: number;
+    filename?: string;
+    /** Decoded pixel width, when the reference is an image. */
+    width?: number;
+    /** Decoded pixel height, when the reference is an image. */
+    height?: number;
+}
+
 declare type _WorkspaceServerMessages = WorkspaceFilesListResponse | WorkspaceFileReadResponse | IdentityGetResponse | ToolPermissionSimulateResponse | ToolNamesListResponse | IdentityChangedEvent;
 
 export { }