@vellumai/plugin-api 0.10.7-dev.202607102035.64f07ea → 0.10.7-staging.1

package/index.d.ts

@@ -60,40 +60,6 @@ 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,
@@ -135,6 +101,12 @@ 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;
@@ -189,6 +161,29 @@ 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<{
@@ -211,19 +206,6 @@ 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<{
@@ -269,1098 +251,6 @@ 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>;
 
@@ -1584,12 +474,6 @@ 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;
@@ -1624,33 +508,6 @@ 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.
  *
@@ -1748,13 +605,6 @@ 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;
@@ -1909,32 +759,6 @@ 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;
@@ -1962,30 +786,6 @@ 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<{
@@ -2211,9 +1011,6 @@ 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
@@ -2313,8 +1110,8 @@ declare type ConversationListInvalidatedEvent = z.infer<typeof ConversationListI
 declare const ConversationListInvalidatedEventSchema: z.ZodObject<{
     type: z.ZodLiteral<"conversation_list_invalidated">;
     reason: z.ZodEnum<{
-        created: "created";
         deleted: "deleted";
+        created: "created";
         renamed: "renamed";
         reordered: "reordered";
         seen_changed: "seen_changed";
@@ -2381,40 +1178,6 @@ 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;
@@ -2453,9 +1216,6 @@ 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;
@@ -2466,15 +1226,6 @@ 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 {
@@ -2502,9 +1253,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;
@@ -2670,33 +1421,13 @@ 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<{
@@ -2709,19 +1440,74 @@ declare const ErrorEventSchema: z.ZodObject<{
     conversationId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 
-export declare function extractTextFromStoredMessageContent(raw: string | ContentBlock[]): string;
+/**
+ * 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 interface FileContent {
     type: "file";
-    source: MediaSource_2;
+    source: {
+        type: "base64";
+        media_type: string;
+        data: string;
+        filename: string;
+    };
     extracted_text?: string;
     /**
-     * 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.
+     * 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.
      */
     _attachmentId?: string;
 }
@@ -2838,9 +1624,6 @@ 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
@@ -2854,18 +1637,6 @@ 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
@@ -2947,9 +1718,6 @@ 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;
@@ -3075,8 +1843,6 @@ 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. */
@@ -3335,7 +2101,7 @@ declare interface HostBashRequest {
     command: string;
     working_dir?: string;
     timeout_seconds?: number;
-    /** Extra environment variables to inject into the subprocess (e.g. __CONVERSATION_ID). */
+    /** Extra environment variables to inject into the subprocess (e.g. VELLUM_UNTRUSTED_SHELL). */
     env?: Record<string, string>;
     /** When set, route this request only to the client with this ID. */
     targetClientId?: string;
@@ -3497,13 +2263,11 @@ declare interface IdentityGetResponse {
 
 export declare interface ImageContent {
     type: "image";
-    source: MediaSource_2;
-}
-
-declare interface ImageEmbeddingInput {
-    type: "image";
-    data: Buffer;
-    mimeType: string;
+    source: {
+        type: "base64";
+        media_type: string;
+        data: string;
+    };
 }
 
 declare type _InboxServerMessages = ContactsInviteResponse | AssistantInboxEscalationResponse;
@@ -3555,18 +2319,6 @@ 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;
@@ -3598,11 +2350,11 @@ declare const InteractionResolvedEventSchema: z.ZodObject<{
     requestId: z.ZodString;
     conversationId: z.ZodString;
     state: z.ZodEnum<{
-        cancelled: "cancelled";
-        superseded: "superseded";
         approved: "approved";
+        cancelled: "cancelled";
         rejected: "rejected";
         answered: "answered";
+        superseded: "superseded";
     }>;
     kind: z.ZodString;
 }, z.core.$strip>;
@@ -3611,9 +2363,6 @@ 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.
  *
@@ -3631,33 +2380,6 @@ export declare function isConversationProcessing(id: string): Promise<boolean>;
  */
 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;
@@ -3686,6 +2408,7 @@ declare const LLMCallSiteEnum: z.ZodEnum<{
     heartbeatAgent: "heartbeatAgent";
     filingAgent: "filingAgent";
     compactionAgent: "compactionAgent";
+    analyzeConversation: "analyzeConversation";
     callAgent: "callAgent";
     memoryExtraction: "memoryExtraction";
     memoryConsolidation: "memoryConsolidation";
@@ -3723,8 +2446,6 @@ declare const LLMCallSiteEnum: z.ZodEnum<{
     workflowLeaf: "workflowLeaf";
 }>;
 
-declare type MediaSource_2 = Base64MediaSource | WorkspaceRefMediaSource;
-
 declare interface MemoryRecalled {
     type: "memory_recalled";
     provider: string;
@@ -3822,125 +2543,6 @@ 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<{
@@ -3967,27 +2569,6 @@ 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 {
@@ -4046,8 +2627,6 @@ 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<{
@@ -4185,37 +2764,18 @@ declare const OpenUrlEventSchema: z.ZodObject<{
 }, z.core.$strip>;
 
 /**
- * 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}.
+ * 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}.
  */
 declare interface OwnerInfo {
     kind: OwnerKind;
-    /** ID of the owner: skill id / plugin name / MCP server id / workspace path, or `"default"` for built-ins. */
+    /** ID of the owning extension (skill id / plugin name / MCP server id / workspace path). */
     id: string;
 }
 
-/**
- * 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;
+/** The kind of extension that owns a tool. Core tools have no owner. */
+declare type OwnerKind = "skill" | "mcp" | "plugin" | "workspace";
 
 declare interface PartnerAudit {
     risk: RiskLevel_2;
@@ -4808,70 +3368,6 @@ 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",
@@ -4934,42 +3430,11 @@ declare interface SchedulesListResponse {
 
 declare type _SchedulesServerMessages = SchedulesListResponse | HeartbeatAlert | HeartbeatConversationCreated | HeartbeatConfigResponse | HeartbeatRunsListResponse | HeartbeatRunNowResponse | HeartbeatChecklistResponse | HeartbeatChecklistWriteResponse | FilingConfigResponse | FilingRunNowResponse;
 
-/** 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[]>;
+declare interface ScopeOption {
+    label: string;
+    scope: string;
+}
 
-/**
- * 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 {
@@ -4980,22 +3445,11 @@ 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; `"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.
+     * 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.
      */
-    collectionUrl?: string;
-    /** Expiry (epoch ms) of {@link SecretPromptResult.collectionUrl}. */
-    collectionExpiresAt?: number;
+    reason?: "cancelled" | "timed_out";
 }
 
 declare type SecretRequestEvent = z.infer<typeof SecretRequestEventSchema>;
@@ -5015,9 +3469,6 @@ 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;
     /**
@@ -5201,13 +3652,6 @@ 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. */
@@ -5224,10 +3668,8 @@ 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; `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.
+ *   plugin is being redeployed in place; the old version's `shutdown` runs
+ *   before the new version is imported and its `init` fires.
  */
 declare type ShutdownReason = "shutdown" | "uninstall" | "disable" | "reload";
 
@@ -5245,21 +3687,6 @@ 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;
@@ -5315,20 +3742,6 @@ 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 {
@@ -5431,23 +3844,6 @@ 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;
@@ -5534,32 +3930,6 @@ 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;
@@ -5620,11 +3990,6 @@ export declare interface TextContent {
     text: string;
 }
 
-declare interface TextEmbeddingInput {
-    type: "text";
-    text: string;
-}
-
 export declare interface ThinkingContent {
     type: "thinking";
     thinking: string;
@@ -5684,6 +4049,11 @@ 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
@@ -5739,9 +4109,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 the `run_workflow`
-     * launch path so a human consents to a run whose capability manifest grants
-     * side-effecting tools.
+     * temporary override options in the prompt UI. Used by
+     * `manage_secure_command_tool` to ensure a human reviews each secure
+     * bundle installation.
      * @legacy
      */
     requireFreshApproval?: boolean;
@@ -5951,6 +4321,54 @@ 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;
@@ -6021,11 +4439,25 @@ 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;
@@ -6049,6 +4481,19 @@ 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. */
@@ -6076,6 +4521,30 @@ 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;
@@ -6247,31 +4716,6 @@ 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;
@@ -6392,9 +4836,6 @@ 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";
@@ -6530,8 +4971,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, and
-     *   wake paths alike. This field will be removed in a
+     *   This holds for the standard submit, queue-drain, subagent, voice, wake,
+     *   and conversation-analysis paths alike. This field will be removed in a
      *   future API version.
      */
     readonly userMessageId: string;
@@ -6604,12 +5045,6 @@ declare interface VercelApiConfigResponse {
     error?: string;
 }
 
-declare interface VideoEmbeddingInput {
-    type: "video";
-    data: Buffer;
-    mimeType: string;
-}
-
 declare interface WebFetchMetadata {
     url: string;
     finalUrl: string;
@@ -7001,31 +5436,6 @@ 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 { }