@vellumai/assistant 0.8.0 → 0.8.1

package/src/config/bundled-skills/messaging/tools/messaging-send.ts

@@ -1,7 +1,6 @@
 import { readFile } from "node:fs/promises";
 import { basename } from "node:path";
 
-import { emitFeedEvent } from "../../../../home/emit-feed-event.js";
 import {
   addMessage,
   getConversation,
@@ -150,14 +149,6 @@ export async function run(
             ccList.length > 0
               ? `To: ${toList.join(", ")}; Cc: ${ccList.join(", ")}`
               : `To: ${toList.join(", ")}`;
-          void emitFeedEvent({
-            source: "gmail",
-            title: "Email Draft Created",
-            summary: `Drafted reply to ${recipientSummary}.`,
-            dedupKey: `email-draft:${draft.id}`,
-          }).catch((err) => {
-            log.warn({ err }, "Failed to emit email draft feed event");
-          });
           return ok(
             `Gmail draft created with ${attachments.length} attachment(s): ${filenames} (Draft ID: ${draft.id}). ${recipientSummary}. Review in Gmail Drafts, then tell me to send it or send it yourself.`,
           );
@@ -178,14 +169,6 @@ export async function run(
           ccList.length > 0
             ? `To: ${toList.join(", ")}; Cc: ${ccList.join(", ")}`
             : `To: ${toList.join(", ")}`;
-        void emitFeedEvent({
-          source: "gmail",
-          title: "Email Draft Created",
-          summary: `Drafted reply to ${recipientSummary}.`,
-          dedupKey: `email-draft:${draft.id}`,
-        }).catch((err) => {
-          log.warn({ err }, "Failed to emit email draft feed event");
-        });
         return ok(
           `Gmail draft created (ID: ${draft.id}). ${recipientSummary}. Review in Gmail Drafts, then tell me to send it or send it yourself.`,
         );
@@ -212,14 +195,6 @@ export async function run(
         const draft = await createDraftRaw(gmailConn, raw, threadId);
 
         const filenames = attachments.map((a) => a.filename).join(", ");
-        void emitFeedEvent({
-          source: "gmail",
-          title: "Email Draft Created",
-          summary: "Created an email draft.",
-          dedupKey: `email-draft:${draft.id}`,
-        }).catch((err) => {
-          log.warn({ err }, "Failed to emit email draft feed event");
-        });
         return ok(
           `Gmail draft created with ${attachments.length} attachment(s): ${filenames} (Draft ID: ${draft.id}). Review in Gmail Drafts, then tell me to send it or send it yourself.`,
         );
@@ -236,14 +211,6 @@ export async function run(
         undefined,
         threadId,
       );
-      void emitFeedEvent({
-        source: "gmail",
-        title: "Email Draft Created",
-        summary: "Created an email draft.",
-        dedupKey: `email-draft:${draft.id}`,
-      }).catch((err) => {
-        log.warn({ err }, "Failed to emit email draft feed event");
-      });
       return ok(
         `Gmail draft created (ID: ${draft.id}). Review it in your Gmail Drafts, then tell me to send it or send it yourself from Gmail.`,
       );
@@ -257,31 +224,6 @@ export async function run(
       assistantId: context.assistantId,
     });
 
-    const sendSummary =
-      provider.id === "slack"
-        ? "Sent a Slack message."
-        : provider.id === "telegram"
-          ? "Sent a Telegram message."
-          : "Sent an email.";
-    void emitFeedEvent({
-      source:
-        provider.id === "slack"
-          ? "slack"
-          : provider.id === "telegram"
-            ? "telegram"
-            : "gmail",
-      title:
-        provider.id === "slack"
-          ? "Slack Message Sent"
-          : provider.id === "telegram"
-            ? "Telegram Message Sent"
-            : "Email Sent",
-      summary: sendSummary,
-      dedupKey: `message-sent:${result.id}`,
-    }).catch((err) => {
-      log.warn({ err }, "Failed to emit message send feed event");
-    });
-
     const threadSuffix = result.threadId
       ? `, "thread_id": "${result.threadId}"`
       : "";

package/src/config/bundled-tool-registry.ts

@@ -49,7 +49,6 @@ import * as computerUseWait from "./bundled-skills/computer-use/tools/computer-u
 // ── contacts ───────────────────────────────────────────────────────────────────
 import * as contactMerge from "./bundled-skills/contacts/tools/contact-merge.js";
 import * as contactSearch from "./bundled-skills/contacts/tools/contact-search.js";
-import * as contactUpsert from "./bundled-skills/contacts/tools/contact-upsert.js";
 import * as googleContacts from "./bundled-skills/contacts/tools/google-contacts.js";
 // ── document ───────────────────────────────────────────────────────────────────
 import * as documentCreate from "./bundled-skills/document/tools/document-create.js";
@@ -163,7 +162,6 @@ export const bundledToolRegistry = new Map<string, SkillToolScript>([
   ["computer-use:tools/computer-use-respond.ts", computerUseRespond],
 
   // contacts
-  ["contacts:tools/contact-upsert.ts", contactUpsert],
   ["contacts:tools/contact-search.ts", contactSearch],
   ["contacts:tools/contact-merge.ts", contactMerge],
   ["contacts:tools/google-contacts.ts", googleContacts],

package/src/config/feature-flag-registry.json

@@ -9,6 +9,14 @@
       "description": "Automatically trigger conversation analysis on the same cadence as memory extraction (batch threshold, idle debounce, end-of-conversation). The analysis agent has full tool access and writes back to memory and skills without user approval.",
       "defaultEnabled": false
     },
+    {
+      "id": "memory-retrospective",
+      "scope": "assistant",
+      "key": "memory-retrospective",
+      "label": "Memory retrospective pass",
+      "description": "Run a focused, memory-only retrospective during active conversations and at conversation lifecycle. The retrospective agent re-reads the messages added since the last successful run, dedupes against memory/archive/, and calls `remember` for what wasn't captured in the moment. Enabling this also relaxes the in-conversation pressure to call `remember` (lighter PKB reminder + relaxed tool description) so the assistant can stay present and trust the retrospective as the backstop.",
+      "defaultEnabled": false
+    },
     {
       "id": "user-hosted-enabled",
       "scope": "client",
@@ -193,6 +201,14 @@
       "description": "Route embedding requests through the platform runtime proxy using Vellum-managed Gemini credentials when available",
       "defaultEnabled": false
     },
+    {
+      "id": "bookmarks",
+      "scope": "client",
+      "key": "bookmarks",
+      "label": "Message Bookmarks",
+      "description": "Show the bookmark icon on messages and enable the Bookmarks tab in Settings",
+      "defaultEnabled": false
+    },
     {
       "id": "fork-from-message",
       "scope": "client",

package/src/config/llm-resolver.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 
+import { getCatalogProviderForModel } from "../providers/model-catalog.js";
 import {
   type LLMCallSite,
   LLMConfigBase,
@@ -67,7 +68,7 @@ export function resolveCallSiteConfig(
     appendCallSiteLayers(layers, callSite, llm, site);
   }
 
-  return finalize(deepMerge(...layers));
+  return finalize(deepMerge(...layers.map(withImpliedProviderForKnownModel)));
 }
 
 // ---------------------------------------------------------------------------
@@ -76,6 +77,20 @@ export function resolveCallSiteConfig(
 
 type Mergeable = Record<string, unknown>;
 
+function withImpliedProviderForKnownModel(source: Mergeable): Mergeable {
+  if (source.provider !== undefined) return source;
+  const model = source.model;
+  if (typeof model !== "string" || model.length === 0) return source;
+
+  const provider = getCatalogProviderForModel(model);
+  if (provider === undefined) return source;
+
+  return {
+    ...source,
+    provider,
+  };
+}
+
 function appendProfileLayer(
   layers: Mergeable[],
   profile: ProfileEntry | undefined,

package/src/config/loader.ts

@@ -124,7 +124,6 @@ export function getDeploymentContextDefaults(): Record<string, unknown> {
   const managed = { mode: "managed" as const };
   return {
     services: {
-      inference: managed,
       "image-generation": managed,
       "web-search": managed,
       "google-oauth": managed,
@@ -520,12 +519,14 @@ export function deepMergeOverwrite(
 }
 
 export type DefaultWorkspaceConfigMergeResult = {
+  hadOverlay: boolean;
   providedLlmProfileNames: Set<string>;
   providedLlmActiveProfile: boolean;
 };
 
 function emptyDefaultWorkspaceConfigMergeResult(): DefaultWorkspaceConfigMergeResult {
   return {
+    hadOverlay: false,
     providedLlmProfileNames: new Set(),
     providedLlmActiveProfile: false,
   };
@@ -571,6 +572,7 @@ export function mergeDefaultWorkspaceConfig(): DefaultWorkspaceConfigMergeResult
   );
   const providedProfiles = readPlainObject(llmDefaults?.profiles);
   const mergeResult: DefaultWorkspaceConfigMergeResult = {
+    hadOverlay: true,
     providedLlmProfileNames: new Set(
       providedProfiles ? Object.keys(providedProfiles) : [],
     ),
@@ -649,7 +651,24 @@ export function loadConfig(): AssistantConfig {
     let configFileExisted = true;
     if (existsSync(configPath)) {
       try {
-        fileConfig = JSON.parse(readFileSync(configPath, "utf-8"));
+        const parsed: unknown = JSON.parse(readFileSync(configPath, "utf-8"));
+        if (!isPlainObject(parsed)) {
+          // Same shape contract as `loadRawConfig`: top-level value must be a
+          // plain object. A `null`, primitive, or array is treated like a
+          // parse error so downstream code (`warnAndStripDeprecatedFields`,
+          // `setNestedValue` in the managed-Gemini migration block, etc.)
+          // never iterates a non-record. Quarantine + fall through to defaults.
+          quarantineCorruptConfig(
+            configPath,
+            new Error(
+              `config.json must contain a JSON object at the top level; got ${describeJsonShape(parsed)}`,
+            ),
+          );
+          fileConfig = {};
+          configFileExisted = false;
+        } else {
+          fileConfig = parsed;
+        }
       } catch (err) {
         // The daemon must never block startup (assistant/CLAUDE.md). A config
         // file that fails JSON.parse — truncated during a mid-write crash, or
@@ -827,24 +846,67 @@ export function invalidateConfigCache(): void {
  * Load the raw config from disk without any secure-storage merging.
  * Used by CLI config commands to read/write the file directly.
  * API keys in secure storage are managed via `assistant keys` commands.
+ *
+ * Contract: returns a plain object (`Record<string, unknown>`). When
+ * `config.json` is missing → returns `{}`. When the file is unparseable
+ * (truncated, hand-edited to invalid JSON) OR when it parses to a value
+ * that is technically valid JSON but NOT a plain object (`null`, a
+ * primitive like `42`, `"hello"`, `true`, or an array `[…]`) → quarantines
+ * the file and returns `{}`. Callers can therefore rely on the return
+ * type without runtime shape-checking — the boundary check happens here.
  */
 export function loadRawConfig(): Record<string, unknown> {
   ensureMigratedDataDir();
   const configPath = getConfigPath();
-  let raw: Record<string, unknown> = {};
-  if (existsSync(configPath)) {
-    try {
-      raw = JSON.parse(readFileSync(configPath, "utf-8"));
-    } catch (err) {
-      // Mirror loadConfig(): quarantine the corrupt file and return an empty
-      // object rather than throwing. This prevents /v1/config from surfacing
-      // a 500 when the user's config.json is malformed.
-      quarantineCorruptConfig(configPath, err);
-      raw = {};
-    }
+  if (!existsSync(configPath)) {
+    return {};
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(readFileSync(configPath, "utf-8"));
+  } catch (err) {
+    // Mirror loadConfig(): quarantine the corrupt file and return an empty
+    // object rather than throwing. This prevents /v1/config from surfacing
+    // a 500 when the user's config.json is malformed.
+    quarantineCorruptConfig(configPath, err);
+    return {};
   }
 
-  return raw;
+  if (!isPlainObject(parsed)) {
+    // Valid JSON but the wrong shape — `null`, a primitive, or an array.
+    // Treat the same as a parse error so the return-type contract above is
+    // truthful and downstream callers (e.g. /v1/config handlers, twilio
+    // integration routes, settings routes) can iterate keys safely.
+    quarantineCorruptConfig(
+      configPath,
+      new Error(
+        `config.json must contain a JSON object at the top level; got ${describeJsonShape(parsed)}`,
+      ),
+    );
+    return {};
+  }
+
+  return parsed;
+}
+
+/**
+ * Predicate for "the value is a plain JSON object" — i.e. not `null`, not
+ * a primitive, and not an array. The cast on the truthy branch is safe
+ * because the caller's static type narrowed accordingly.
+ */
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+/**
+ * Human-readable shape label for error messages. Distinguishes the four
+ * non-object JSON shapes the loader rejects.
+ */
+function describeJsonShape(value: unknown): string {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "an array";
+  return `a ${typeof value}`;
 }
 
 export function saveRawConfig(config: Record<string, unknown>): void {

package/src/config/raw-config-utils.ts

@@ -1,39 +1,11 @@
-/**
- * Safely set a nested field on a raw config object's `llm.default` map.
- *
- * Ensures the `llm` and `llm.default` objects exist before writing, so
- * callers don't need to guard against undefined intermediate keys.
- *
- * Example: `setLlmDefaultField(raw, "model", "claude-sonnet-4-6")`
- * produces `raw.llm.default.model = "claude-sonnet-4-6"`.
- */
-export function setLlmDefaultField(
-  raw: Record<string, unknown>,
-  field: string,
-  value: unknown,
-): void {
-  const llm: Record<string, unknown> =
-    raw.llm != null && typeof raw.llm === "object" && !Array.isArray(raw.llm)
-      ? (raw.llm as Record<string, unknown>)
-      : {};
-  const existing = llm.default;
-  const defaultBlock: Record<string, unknown> =
-    existing != null && typeof existing === "object" && !Array.isArray(existing)
-      ? (existing as Record<string, unknown>)
-      : {};
-  defaultBlock[field] = value;
-  llm.default = defaultBlock;
-  raw.llm = llm;
-}
-
 /**
  * Safely set a nested field on a raw config object's `services` map.
  *
  * Ensures the `services` and service-level objects exist before writing,
  * so callers don't need to guard against undefined intermediate keys.
  *
- * Example: `setServiceField(raw, "inference", "mode", "managed")`
- * produces `raw.services.inference.mode = "managed"`.
+ * Example: `setServiceField(raw, "image-generation", "mode", "managed")`
+ * produces `raw.services["image-generation"].mode = "managed"`.
  */
 export function setServiceField(
   raw: Record<string, unknown>,

package/src/config/schema.ts

@@ -32,6 +32,7 @@ import { HostBrowserConfigSchema } from "./schemas/host-browser.js";
 import { IngressConfigSchema } from "./schemas/ingress.js";
 import { JournalConfigSchema } from "./schemas/journal.js";
 import { LLMSchema } from "./schemas/llm.js";
+import { LlmRequestLogsConfigSchema } from "./schemas/llm-request-logs.js";
 import {
   AuditLogConfigSchema,
   LogFileConfigSchema,
@@ -81,6 +82,9 @@ export const AssistantConfigSchema = z
     // ensures the loader's leaf-deletion recovery path can repair a partially
     // invalid `llm` block without falling back to `cloneDefaultConfig()`.
     llm: LLMSchema.default(LLMSchema.parse({})),
+    llmRequestLogs: LlmRequestLogsConfigSchema.default(
+      LlmRequestLogsConfigSchema.parse({}),
+    ),
     filing: FilingConfigSchema.default(FilingConfigSchema.parse({})),
     heartbeat: HeartbeatConfigSchema.default(HeartbeatConfigSchema.parse({})),
     updates: UpdatesConfigSchema.default(UpdatesConfigSchema.parse({})),

package/src/config/schemas/__tests__/memory-v2.test.ts

@@ -32,6 +32,11 @@ describe("MemoryV2ConfigSchema", () => {
         model: "Alibaba-NLP/gte-reranker-modernbert-base",
         dtype: "q8",
       },
+      router: {
+        enabled: false,
+        max_page_ids: 25,
+        router_prompt_path: null,
+      },
     });
   });
 
@@ -155,6 +160,50 @@ describe("MemoryV2ConfigSchema", () => {
     expect(() => MemoryV2ConfigSchema.parse({ epsilon: -0.01 })).toThrow();
     expect(() => MemoryV2ConfigSchema.parse({ epsilon: 1.5 })).toThrow();
   });
+
+  test("router defaults to disabled with max_page_ids=25", () => {
+    const parsed = MemoryV2ConfigSchema.parse({});
+    expect(parsed.router.enabled).toBe(false);
+    expect(parsed.router.max_page_ids).toBe(25);
+  });
+
+  test("accepts explicit router overrides", () => {
+    const parsed = MemoryV2ConfigSchema.parse({
+      router: { enabled: true, max_page_ids: 50 },
+    });
+    expect(parsed.router.enabled).toBe(true);
+    expect(parsed.router.max_page_ids).toBe(50);
+  });
+
+  test("rejects router.max_page_ids below 1", () => {
+    expect(() =>
+      MemoryV2ConfigSchema.parse({ router: { max_page_ids: 0 } }),
+    ).toThrow();
+  });
+
+  test("rejects router.max_page_ids above 100", () => {
+    expect(() =>
+      MemoryV2ConfigSchema.parse({ router: { max_page_ids: 101 } }),
+    ).toThrow();
+  });
+
+  test("router_prompt_path defaults to null", () => {
+    const parsed = MemoryV2ConfigSchema.parse({});
+    expect(parsed.router.router_prompt_path).toBeNull();
+  });
+
+  test("accepts an explicit router_prompt_path override", () => {
+    const parsed = MemoryV2ConfigSchema.parse({
+      router: { router_prompt_path: "~/prompts/router.md" },
+    });
+    expect(parsed.router.router_prompt_path).toBe("~/prompts/router.md");
+  });
+
+  test("rejects non-string router_prompt_path", () => {
+    expect(() =>
+      MemoryV2ConfigSchema.parse({ router: { router_prompt_path: 42 } }),
+    ).toThrow();
+  });
 });
 
 describe("MemoryConfigSchema integration with v2 block", () => {

package/src/config/schemas/call-site-catalog.ts

@@ -114,6 +114,27 @@ const CATALOG_RECORD: CatalogRecord = {
     description: "Background sweep pass for V2 memory maintenance.",
     domain: "memory",
   },
+  memoryRouter: {
+    id: "memoryRouter",
+    displayName: "Memory Router",
+    description:
+      "Selects which concept pages to inject for the next agent turn by routing over a cached page index.",
+    domain: "memory",
+  },
+  memoryV2Consolidation: {
+    id: "memoryV2Consolidation",
+    displayName: "Memory V2 Consolidation",
+    description:
+      "Routes accumulated buffer entries into concept pages and rewrites the recent summary during V2 memory maintenance.",
+    domain: "memory",
+  },
+  memoryRetrospective: {
+    id: "memoryRetrospective",
+    displayName: "Memory Retrospective",
+    description:
+      "Background agent that re-reads recent conversation messages and saves what wasn't captured in the moment by calling the `remember` tool.",
+    domain: "memory",
+  },
   recall: {
     id: "recall",
     displayName: "Recall",
@@ -152,7 +173,14 @@ const CATALOG_RECORD: CatalogRecord = {
     id: "conversationStarters",
     displayName: "Conversation Starters",
     description:
-      "Generates suggested conversation openers for the home screen.",
+      "Generates the personalized starter chips on the empty conversation page.",
+    domain: "ui",
+  },
+  replySuggestion: {
+    id: "replySuggestion",
+    displayName: "Reply Suggestion",
+    description:
+      "Generates the tab-to-accept reply hint shown in the chat composer after each assistant turn.",
     domain: "ui",
   },
   conversationTitle: {
@@ -191,12 +219,6 @@ const CATALOG_RECORD: CatalogRecord = {
     description: "Handles conversational approval flows.",
     domain: "ui",
   },
-  feedEventCopy: {
-    id: "feedEventCopy",
-    displayName: "Feed Event Copy",
-    description: "Generates copy for home feed event cards.",
-    domain: "ui",
-  },
   trustRuleSuggestion: {
     id: "trustRuleSuggestion",
     displayName: "Trust Rule Suggestion",

package/src/config/schemas/llm-request-logs.ts

@@ -0,0 +1,57 @@
+/**
+ * Configuration for LLM request log read source.
+ *
+ * Writes always land in the local SQLite `llm_request_logs` table; reads
+ * can be switched between local and ClickHouse via `readSource`.
+ *
+ * When `readSource === "clickhouse"` the URL and password are resolved
+ * from the credential store (`clickhouse:url`, `clickhouse:password`).
+ * The connection options below describe everything else (database/table/user).
+ *
+ * Note: the existing retention setting lives under
+ * `memory.cleanup.llmRequestLogRetentionMs` and is independent of this block.
+ * That covers when local rows get pruned; this block governs where reads
+ * are served from.
+ */
+import { z } from "zod";
+
+export const LlmRequestLogsClickHouseConfigSchema = z
+  .object({
+    database: z
+      .string({ error: "llmRequestLogs.clickhouse.database must be a string" })
+      .min(1, "llmRequestLogs.clickhouse.database cannot be empty")
+      .default("default")
+      .describe("ClickHouse database containing the llm_request_logs table"),
+    table: z
+      .string({ error: "llmRequestLogs.clickhouse.table must be a string" })
+      .min(1, "llmRequestLogs.clickhouse.table cannot be empty")
+      .default("llm_request_logs")
+      .describe("ClickHouse table name to read from"),
+    user: z
+      .string({ error: "llmRequestLogs.clickhouse.user must be a string" })
+      .min(1, "llmRequestLogs.clickhouse.user cannot be empty")
+      .default("default")
+      .describe("ClickHouse user (password is read from credential store)"),
+  })
+  .describe(
+    "ClickHouse connection settings used when `readSource` is `clickhouse`",
+  );
+
+export const LlmRequestLogsConfigSchema = z
+  .object({
+    readSource: z
+      .enum(["local", "clickhouse"])
+      .default("local")
+      .describe(
+        "Where to read LLM request logs from for Inspector queries. `local` reads the SQLite source-of-truth (default, lowest latency). `clickhouse` reads the mirror, which retains data longer than local but only sees writes that the mirror job has flushed.",
+      ),
+    clickhouse: LlmRequestLogsClickHouseConfigSchema.default(
+      LlmRequestLogsClickHouseConfigSchema.parse({}),
+    ),
+  })
+  .describe("LLM request log read source configuration");
+
+export type LlmRequestLogsConfig = z.infer<typeof LlmRequestLogsConfigSchema>;
+export type LlmRequestLogsClickHouseConfig = z.infer<
+  typeof LlmRequestLogsClickHouseConfigSchema
+>;

package/src/config/schemas/llm.ts

@@ -47,11 +47,15 @@ export const LLMCallSiteEnum = z.enum([
   "memoryRetrieval",
   "memoryV2Migration",
   "memoryV2Sweep",
+  "memoryRouter",
+  "memoryV2Consolidation",
+  "memoryRetrospective",
   "recall",
   "narrativeRefinement",
   "patternScan",
   "conversationSummarization",
   "conversationStarters",
+  "replySuggestion",
   "conversationTitle",
   "commitMessage",
   "identityIntro",
@@ -68,7 +72,6 @@ export const LLMCallSiteEnum = z.enum([
   "meetConsentMonitor",
   "meetChatOpportunity",
   "inference",
-  "feedEventCopy",
   "trustRuleSuggestion",
   "proactiveArtifactDecision",
   "proactiveArtifactBuild",
@@ -281,6 +284,16 @@ const PricingOverrideSchema = z.object({
  */
 export const LLMConfigBase = z.object({
   provider: LLMProvider.default("anthropic"),
+  /**
+   * Name of a `provider_connections` row to use for this resolved config.
+   * Optional and additive: when set, the dispatcher resolves auth from the
+   * connection (mix-and-match managed/your-own per profile). When unset,
+   * the dispatcher falls back to the legacy `provider` lookup.
+   *
+   * Lives on the merged base type so it flows through `resolveCallSiteConfig`
+   * naturally — the underlying profile-level field is on `ProfileEntry`.
+   */
+  provider_connection: z.string().min(1).optional(),
   model: ModelSchema.default("claude-opus-4-7"),
   maxTokens: MaxTokensSchema.default(64000),
   effort: EffortEnum.default("max"),
@@ -313,6 +326,9 @@ const LLMConfigFragment = z.object({
 });
 type LLMConfigFragment = z.infer<typeof LLMConfigFragment>;
 
+export const ProfileStatusSchema = z.enum(["active", "disabled"]);
+export type ProfileStatus = z.infer<typeof ProfileStatusSchema>;
+
 /**
  * A named profile entry: an `LLMConfigFragment` augmented with
  * presentation/ownership metadata. These fields are intentionally kept off
@@ -321,8 +337,33 @@ type LLMConfigFragment = z.infer<typeof LLMConfigFragment>;
  */
 export const ProfileEntry = LLMConfigFragment.extend({
   source: ProfileSource.optional(),
-  label: z.string().min(1).optional(),
+  /**
+   * `.nullable()` is intentional: the PUT `/v1/config/llm/profiles/:name`
+   * route uses `null` as the "clear this override" sentinel for managed
+   * profiles (see `patchManagedProfileFields` in
+   * `runtime/routes/conversation-query-routes.ts`). Without `.nullable()`,
+   * Zod rejects `{ label: null }` at parse time before the route handler
+   * ever sees it, and the clear-back-to-seed path is unreachable from any
+   * client. `.min(1)` still applies to string values so empty strings
+   * remain rejected — `null` is the only non-string-non-undefined input
+   * accepted.
+   */
+  label: z.string().min(1).nullable().optional(),
   description: z.string().optional(),
+  /**
+   * Name of a `provider_connections` row to use for this profile.
+   * The dispatcher resolves auth from this connection; the legacy `provider`
+   * and `source` fields remain as read-only deprecated fallbacks for profiles
+   * not yet backfilled by the boot-time migration.
+   */
+  provider_connection: z.string().min(1).optional(),
+  /**
+   * Absent means active. `.nullable()` matches `label` so the PUT route's
+   * "send `null` to clear" sentinel works for status edits too — see
+   * `patchManagedProfileFields`, which has handled `status === null` since
+   * #30362 even though the schema didn't accept it until now.
+   */
+  status: ProfileStatusSchema.nullable().optional(),
 });
 export type ProfileEntry = z.infer<typeof ProfileEntry>;
 
@@ -355,6 +396,15 @@ export const LLMSchema = z
     // schema level, so `LLMSchema.parse({})` yields an empty map.
     callSites: z.partialRecord(LLMCallSiteEnum, LLMCallSiteConfig).default({}),
     activeProfile: z.string().min(1).optional(),
+    // TTL bounds for inference profile sessions. `defaultTtlSeconds` is read by
+    // the CLI to apply when `--ttl` is omitted; the daemon handler itself only
+    // reads `maxTtlSeconds` (to clamp caller-supplied values).
+    profileSession: z
+      .object({
+        defaultTtlSeconds: z.number().int().min(1).default(1800),
+        maxTtlSeconds: z.number().int().min(1).default(43200),
+      })
+      .default({ defaultTtlSeconds: 1800, maxTtlSeconds: 43200 }),
     pricingOverrides: z.array(PricingOverrideSchema).default([]),
   })
   .superRefine((config, ctx) => {