@vellumai/assistant 0.6.4 → 0.6.5

package/src/config/schemas/filing.ts

@@ -1,14 +1,12 @@
 import { z } from "zod";
 
-import { SpeedSchema } from "./inference.js";
-
 export const FilingConfigSchema = z
   .object({
     enabled: z
       .boolean({ error: "filing.enabled must be a boolean" })
       .default(true)
       .describe(
-        "Whether periodic PKB filing is enabled — processes buffer.md into topic files and reviews knowledge base organization",
+        "Whether periodic Personal Knowledge Base filing is enabled — processes buffer.md into topic files and reviews knowledge base organization",
       ),
     intervalMs: z
       .number({ error: "filing.intervalMs must be a number" })
@@ -16,9 +14,6 @@ export const FilingConfigSchema = z
       .positive("filing.intervalMs must be a positive integer")
       .default(4 * 3_600_000)
       .describe("Time between filing runs in milliseconds"),
-    speed: SpeedSchema.default("standard").describe(
-      "Inference speed mode for filing conversations",
-    ),
     activeHoursStart: z
       .number({ error: "filing.activeHoursStart must be a number" })
       .int("filing.activeHoursStart must be an integer")
@@ -41,7 +36,7 @@ export const FilingConfigSchema = z
       ),
   })
   .describe(
-    "Periodic PKB (personal knowledge base) filing — processes the buffer into topic files and maintains knowledge organization",
+    "Periodic Personal Knowledge Base filing — processes the buffer into topic files and maintains knowledge organization",
   )
   .superRefine((config, ctx) => {
     const startNull = config.activeHoursStart == null;

package/src/config/schemas/heartbeat.ts

@@ -1,7 +1,5 @@
 import { z } from "zod";
 
-import { SpeedSchema } from "./inference.js";
-
 export const HeartbeatConfigSchema = z
   .object({
     enabled: z
@@ -14,9 +12,6 @@ export const HeartbeatConfigSchema = z
       .positive("heartbeat.intervalMs must be a positive integer")
       .default(6 * 3_600_000)
       .describe("Time between heartbeat checks in milliseconds"),
-    speed: SpeedSchema.default("standard").describe(
-      "Inference speed mode for heartbeat conversations — defaults to standard to avoid inheriting the global fast mode multiplier",
-    ),
     activeHoursStart: z
       .number({ error: "heartbeat.activeHoursStart must be a number" })
       .int("heartbeat.activeHoursStart must be an integer")

package/src/config/schemas/inference.ts

@@ -25,28 +25,6 @@ export const ThinkingConfigSchema = z
   })
   .describe("Extended thinking (chain-of-thought) configuration");
 
-export const EffortSchema = z
-  .enum(["low", "medium", "high", "max"], {
-    error: 'effort must be "low", "medium", "high", or "max"',
-  })
-  .default("max")
-  .describe(
-    "How much effort the model should put into its response — lower effort is faster and cheaper",
-  );
-
-export type Effort = z.infer<typeof EffortSchema>;
-
-export const SpeedSchema = z
-  .enum(["standard", "fast"], {
-    error: 'speed must be "standard" or "fast"',
-  })
-  .default("standard")
-  .describe(
-    'Inference speed mode — "fast" enables higher output token throughput on supported models (Opus 4.6, Opus 4.7) at premium pricing',
-  );
-
-export type Speed = z.infer<typeof SpeedSchema>;
-
 export const ContextOverflowRecoveryConfigSchema = z
   .object({
     enabled: z
@@ -121,7 +99,9 @@ export const ContextWindowConfigSchema = z
       .int("contextWindow.maxInputTokens must be an integer")
       .positive("contextWindow.maxInputTokens must be a positive integer")
       .default(200000)
-      .describe("Maximum number of input tokens allowed in the context window"),
+      .describe(
+        "Conservative cap on input tokens allowed in the context window. Acts as an override that further constrains the model's catalog `contextWindow`; the effective budget is `min(catalog.contextWindow, maxInputTokens)`. Leave at the default to use the model's full native window.",
+      ),
     targetBudgetRatio: z
       .number({ error: "contextWindow.targetBudgetRatio must be a number" })
       .finite("contextWindow.targetBudgetRatio must be finite")

package/src/config/schemas/llm.ts

@@ -0,0 +1,318 @@
+import { z } from "zod";
+
+/**
+ * Unified LLM configuration schema.
+ *
+ * Defines the shape of the top-level `llm` config block that consolidates
+ * provider/model/effort/speed/thinking/contextWindow/pricingOverrides for all
+ * call sites in the assistant. Wired into `AssistantConfigSchema` as the `llm`
+ * field and consumed by `resolveCallSiteConfig` in `llm-resolver.ts`.
+ */
+
+// ---------------------------------------------------------------------------
+// Provider enum
+// ---------------------------------------------------------------------------
+
+export const LLMProvider = z.enum([
+  "anthropic",
+  "openai",
+  "gemini",
+  "ollama",
+  "fireworks",
+  "openrouter",
+]);
+export type LLMProvider = z.infer<typeof LLMProvider>;
+
+// ---------------------------------------------------------------------------
+// Call-site enum
+// ---------------------------------------------------------------------------
+
+/**
+ * The complete set of LLM call-site identifiers the assistant emits.
+ *
+ * Each ID corresponds to a logical place in the codebase that produces an LLM
+ * request. Adding or removing a call site is a config-schema change — keep
+ * this list in sync with the resolver and registry (introduced in PR 2).
+ */
+export const LLMCallSiteEnum = z.enum([
+  "mainAgent",
+  "subagentSpawn",
+  "heartbeatAgent",
+  "filingAgent",
+  "analyzeConversation",
+  "callAgent",
+  "memoryExtraction",
+  "memoryConsolidation",
+  "memoryRetrieval",
+  "narrativeRefinement",
+  "patternScan",
+  "conversationSummarization",
+  "conversationStarters",
+  "conversationTitle",
+  "commitMessage",
+  "identityIntro",
+  "emptyStateGreeting",
+  "notificationDecision",
+  "preferenceExtraction",
+  "guardianQuestionCopy",
+  "approvalCopy",
+  "approvalConversation",
+  "watchCommentary",
+  "watchSummary",
+  "interactionClassifier",
+  "styleAnalyzer",
+  "inviteInstructionGenerator",
+  "skillCategoryInference",
+  "meetConsentMonitor",
+  "meetChatOpportunity",
+  "inference",
+]);
+export type LLMCallSite = z.infer<typeof LLMCallSiteEnum>;
+
+// ---------------------------------------------------------------------------
+// Effort & Speed
+// ---------------------------------------------------------------------------
+
+export const EffortEnum = z.enum(["low", "medium", "high", "xhigh", "max"]);
+export type Effort = z.infer<typeof EffortEnum>;
+
+export const SpeedEnum = z.enum(["standard", "fast"]);
+export type Speed = z.infer<typeof SpeedEnum>;
+
+// ---------------------------------------------------------------------------
+// Leaf primitives (shared between LLMConfigBase and LLMConfigFragment)
+//
+// Each primitive is a Zod schema with no defaults attached. `LLMConfigBase`
+// composes them with `.default(...)` so `LLMConfigBase.parse({})` returns a
+// fully-defaulted object; `LLMConfigFragment` composes them with `.optional()`
+// so absent fields stay absent. Centralizing the validation rules here keeps
+// the two views consistent.
+// ---------------------------------------------------------------------------
+
+const ModelSchema = z.string().min(1);
+const MaxTokensSchema = z.number().int().positive();
+const TemperatureSchema = z.number().min(0).max(2).nullable();
+
+// ---------------------------------------------------------------------------
+// Thinking & ContextWindow
+//
+// These mirror the shapes already declared in `schemas/inference.ts` but are
+// redeclared here so the new `llm` namespace owns its own types. PRs 3 and
+// beyond will deprecate the legacy declarations once the resolver is the
+// single source of truth.
+//
+// Every leaf in the defaulted view carries a `.default(...)`, so
+// `Schema.parse({})` returns a fully-defaulted object. This is critical for
+// the loader's leaf-deletion recovery path: if any leaf in the user's config
+// is invalid, the loader strips that leaf and re-parses; without
+// schema-level defaults the parse would fail on missing required siblings,
+// and the loader would fall back to `cloneDefaultConfig()`, discarding the
+// user's other valid settings.
+//
+// Each defaulted schema has a sibling "fragment" schema with the same leaves
+// wrapped in `.optional()` instead of `.default(...)`. The fragment view is
+// used by `LLMConfigFragment` so partial overrides remain partial — Zod
+// would inject defaults for absent fields if we used `Schema.partial()`, and
+// the fragment contract is "any field may be absent and stays absent".
+// ---------------------------------------------------------------------------
+
+// Leaf primitives for thinking fields — defined once and reused by both the
+// defaulted (`ThinkingSchema`) and fragment (`ThinkingFragmentSchema`) views.
+const ThinkingEnabledSchema = z.boolean();
+const ThinkingStreamThinkingSchema = z.boolean();
+
+export const ThinkingSchema = z.object({
+  enabled: ThinkingEnabledSchema.default(true),
+  streamThinking: ThinkingStreamThinkingSchema.default(true),
+});
+export type Thinking = z.infer<typeof ThinkingSchema>;
+
+// Fragment view: every field optional, no defaults injected. Defining this
+// separately (rather than `ThinkingSchema.partial()`) avoids having Zod
+// inject defaults for absent fields when a partial override is parsed —
+// the fragment contract is "any field may be absent and stays absent".
+const ThinkingFragmentSchema = z.object({
+  enabled: ThinkingEnabledSchema.optional(),
+  streamThinking: ThinkingStreamThinkingSchema.optional(),
+});
+
+// Leaf primitives for context-overflow recovery.
+const OverflowEnabledSchema = z.boolean();
+const OverflowSafetyMarginRatioSchema = z.number().finite().gt(0).lt(1);
+const OverflowMaxAttemptsSchema = z.number().int().positive();
+const OverflowLatestTurnCompressionSchema = z.enum([
+  "truncate",
+  "summarize",
+  "drop",
+]);
+
+const ContextOverflowRecoverySchema = z.object({
+  enabled: OverflowEnabledSchema.default(true),
+  safetyMarginRatio: OverflowSafetyMarginRatioSchema.default(0.05),
+  maxAttempts: OverflowMaxAttemptsSchema.default(3),
+  interactiveLatestTurnCompression:
+    OverflowLatestTurnCompressionSchema.default("summarize"),
+  nonInteractiveLatestTurnCompression:
+    OverflowLatestTurnCompressionSchema.default("truncate"),
+});
+
+const ContextOverflowRecoveryFragmentSchema = z.object({
+  enabled: OverflowEnabledSchema.optional(),
+  safetyMarginRatio: OverflowSafetyMarginRatioSchema.optional(),
+  maxAttempts: OverflowMaxAttemptsSchema.optional(),
+  interactiveLatestTurnCompression:
+    OverflowLatestTurnCompressionSchema.optional(),
+  nonInteractiveLatestTurnCompression:
+    OverflowLatestTurnCompressionSchema.optional(),
+});
+
+// Leaf primitives for context-window fields.
+const ContextEnabledSchema = z.boolean();
+const ContextMaxInputTokensSchema = z.number().int().positive();
+const ContextTargetBudgetRatioSchema = z.number().finite().gt(0).lte(1);
+const ContextCompactThresholdSchema = z.number().finite().gt(0).lte(1);
+const ContextSummaryBudgetRatioSchema = z.number().finite().gt(0).lte(1);
+
+export const ContextWindowSchema = z.object({
+  enabled: ContextEnabledSchema.default(true),
+  maxInputTokens: ContextMaxInputTokensSchema.default(200000),
+  targetBudgetRatio: ContextTargetBudgetRatioSchema.default(0.3),
+  compactThreshold: ContextCompactThresholdSchema.default(0.8),
+  summaryBudgetRatio: ContextSummaryBudgetRatioSchema.default(0.05),
+  overflowRecovery: ContextOverflowRecoverySchema.default(
+    ContextOverflowRecoverySchema.parse({}),
+  ),
+});
+export type ContextWindow = z.infer<typeof ContextWindowSchema>;
+
+// Fragment view of `ContextWindowSchema` — all fields optional and no defaults
+// injected. Nested `overflowRecovery` likewise uses its fragment view, so a
+// partial override like `{ overflowRecovery: { maxAttempts: 5 } }` produces
+// exactly that and nothing else.
+const ContextWindowDeepPartialSchema = z.object({
+  enabled: ContextEnabledSchema.optional(),
+  maxInputTokens: ContextMaxInputTokensSchema.optional(),
+  targetBudgetRatio: ContextTargetBudgetRatioSchema.optional(),
+  compactThreshold: ContextCompactThresholdSchema.optional(),
+  summaryBudgetRatio: ContextSummaryBudgetRatioSchema.optional(),
+  overflowRecovery: ContextOverflowRecoveryFragmentSchema.optional(),
+});
+
+// ---------------------------------------------------------------------------
+// OpenRouter provider-routing preferences
+//
+// OpenRouter's `/v1/chat/completions` and `/v1/messages` endpoints both accept
+// a `provider: { only: [...] }` body field that restricts which upstream
+// providers (Anthropic, Google, etc.) may fulfill a request. Exposed here so
+// users can pin routing via config without touching the wire-format knobs
+// directly. Nested shape keeps room for sibling OpenRouter knobs (`order`,
+// `allow_fallbacks`, …) to be added later without another schema reshape.
+// ---------------------------------------------------------------------------
+
+const OpenRouterOnlyItemSchema = z.string().min(1);
+
+export const OpenRouterSchema = z.object({
+  only: z.array(OpenRouterOnlyItemSchema).default([]),
+});
+export type OpenRouter = z.infer<typeof OpenRouterSchema>;
+
+const OpenRouterDeepPartialSchema = z.object({
+  only: z.array(OpenRouterOnlyItemSchema).optional(),
+});
+
+// ---------------------------------------------------------------------------
+// Pricing overrides
+// ---------------------------------------------------------------------------
+
+export const PricingOverrideSchema = z.object({
+  provider: z.string(),
+  modelPattern: z.string(),
+  inputPer1M: z.number().nonnegative(),
+  outputPer1M: z.number().nonnegative(),
+});
+export type PricingOverride = z.infer<typeof PricingOverrideSchema>;
+
+// ---------------------------------------------------------------------------
+// Base config (all fields defaulted) and Fragment (all fields optional)
+// ---------------------------------------------------------------------------
+
+/**
+ * Fully specified LLM config. Used for `llm.default` — every knob has a
+ * schema-level default, so `LLMConfigBase.parse({})` returns a complete
+ * fallback object. This is essential for the loader's leaf-deletion recovery
+ * path; see the comment on `ThinkingSchema` above.
+ */
+export const LLMConfigBase = z.object({
+  provider: LLMProvider.default("anthropic"),
+  model: ModelSchema.default("claude-opus-4-7"),
+  maxTokens: MaxTokensSchema.default(64000),
+  effort: EffortEnum.default("max"),
+  speed: SpeedEnum.default("standard"),
+  temperature: TemperatureSchema.default(null),
+  thinking: ThinkingSchema.default(ThinkingSchema.parse({})),
+  contextWindow: ContextWindowSchema.default(ContextWindowSchema.parse({})),
+  openrouter: OpenRouterSchema.default(OpenRouterSchema.parse({})),
+});
+export type LLMConfigBase = z.infer<typeof LLMConfigBase>;
+
+/**
+ * Partial LLM config used for profiles and call-site overrides. Each top-level
+ * field is optional; nested `thinking` and `contextWindow` accept partial
+ * objects so callers can override individual leaves (e.g. `{ thinking:
+ * { enabled: false } }`).
+ */
+export const LLMConfigFragment = z.object({
+  provider: LLMProvider.optional(),
+  model: ModelSchema.optional(),
+  maxTokens: MaxTokensSchema.optional(),
+  effort: EffortEnum.optional(),
+  speed: SpeedEnum.optional(),
+  temperature: TemperatureSchema.optional(),
+  thinking: ThinkingFragmentSchema.optional(),
+  contextWindow: ContextWindowDeepPartialSchema.optional(),
+  openrouter: OpenRouterDeepPartialSchema.optional(),
+});
+export type LLMConfigFragment = z.infer<typeof LLMConfigFragment>;
+
+/**
+ * Per-call-site config: a fragment plus an optional `profile` reference.
+ * The resolver merges in the named profile (if any) before applying
+ * call-site-level overrides.
+ */
+export const LLMCallSiteConfig = LLMConfigFragment.extend({
+  profile: z.string().min(1).optional(),
+});
+export type LLMCallSiteConfig = z.infer<typeof LLMCallSiteConfig>;
+
+// ---------------------------------------------------------------------------
+// Top-level LLM schema
+// ---------------------------------------------------------------------------
+
+export const LLMSchema = z
+  .object({
+    default: LLMConfigBase.default(LLMConfigBase.parse({})),
+    profiles: z.record(z.string().min(1), LLMConfigFragment).default({}),
+    // `partialRecord` (vs `record`) makes call-site keys optional while still
+    // rejecting keys that aren't members of `LLMCallSiteEnum` — exactly the
+    // behavior we want (typo detection without requiring callers to declare
+    // every call site). Latency-optimized defaults for background call sites
+    // are seeded into the user's on-disk config by migration 040, not at
+    // schema level, so `LLMSchema.parse({})` yields an empty map.
+    callSites: z.partialRecord(LLMCallSiteEnum, LLMCallSiteConfig).default({}),
+    pricingOverrides: z.array(PricingOverrideSchema).default([]),
+  })
+  .superRefine((config, ctx) => {
+    const profileNames = new Set(Object.keys(config.profiles ?? {}));
+    for (const [siteId, siteConfig] of Object.entries(config.callSites ?? {})) {
+      if (siteConfig?.profile == null) continue;
+      if (!profileNames.has(siteConfig.profile)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["callSites", siteId, "profile"],
+          message: `Profile "${siteConfig.profile}" referenced by call site "${siteId}" is not defined in llm.profiles`,
+        });
+      }
+    }
+  });
+
+export type LLMConfig = z.infer<typeof LLMSchema>;

package/src/config/schemas/memory-processing.ts

@@ -43,17 +43,9 @@ export const MemorySummarizationConfigSchema = z
       .describe(
         "Whether to use an LLM for summarizing and consolidating memory items",
       ),
-    modelIntent: z
-      .enum(["latency-optimized", "quality-optimized", "vision-optimized"], {
-        error: "memory.summarization.modelIntent must be a valid model intent",
-      })
-      .default("quality-optimized")
-      .describe(
-        "Model selection strategy for summarization — trade off speed vs quality",
-      ),
   })
   .describe(
-    "Controls how memory items are summarized and consolidated over time",
+    "Controls how memory items are summarized and consolidated over time. Model selection lives under llm.callSites.conversationSummarization.",
   );
 
 export type MemoryExtractionConfig = z.infer<

package/src/config/schemas/notifications.ts

@@ -1,16 +1,9 @@
 import { z } from "zod";
 
 export const NotificationsConfigSchema = z
-  .object({
-    decisionModelIntent: z
-      .enum(["latency-optimized", "quality-optimized", "vision-optimized"], {
-        error: "notifications.decisionModelIntent must be a valid model intent",
-      })
-      .default("latency-optimized")
-      .describe(
-        "Model selection strategy for deciding whether to send a notification",
-      ),
-  })
-  .describe("Notification delivery configuration");
+  .object({})
+  .describe(
+    "Notification delivery configuration. Model selection lives under llm.callSites.notificationDecision and llm.callSites.preferenceExtraction.",
+  );
 
 export type NotificationsConfig = z.infer<typeof NotificationsConfigSchema>;

package/src/config/schemas/platform.ts

@@ -56,16 +56,10 @@ export const UiConfigSchema = z
       .describe(
         "IANA timezone identifier for displaying dates and times (e.g. 'America/New_York')",
       ),
-    greetingModelIntent: z
-      .enum(["latency-optimized", "quality-optimized"], {
-        error: "ui.greetingModelIntent must be 'latency-optimized' or 'quality-optimized'",
-      })
-      .default("latency-optimized")
-      .describe(
-        "Model intent for empty-state greeting generation (latency-optimized = fast/small model, quality-optimized = primary model)",
-      ),
   })
-  .describe("User interface display settings");
+  .describe(
+    "User interface display settings. Empty-state greeting model selection lives under llm.callSites.emptyStateGreeting.",
+  );
 
 export type DaemonConfig = z.infer<typeof DaemonConfigSchema>;
 export type UiConfig = z.infer<typeof UiConfigSchema>;

package/src/config/schemas/security.ts

@@ -87,6 +87,39 @@ export const PermissionsConfigSchema = z
       .describe(
         "Whether the assistant can execute commands on the host machine without prompting",
       ),
+    autoApproveUpTo: z
+      .union([
+        z.enum(["none", "low", "medium"], {
+          error:
+            "permissions.autoApproveUpTo must be one of: none, low, medium",
+        }),
+        z.object({
+          conversation: z
+            .enum(["none", "low", "medium"])
+            .default("low")
+            .describe(
+              "Threshold for interactive conversation sessions (default: low)",
+            ),
+          background: z
+            .enum(["none", "low", "medium"])
+            .default("medium")
+            .describe(
+              "Threshold for non-interactive guardian sessions (default: medium)",
+            ),
+          headless: z
+            .enum(["none", "low", "medium"])
+            .default("none")
+            .describe(
+              "Threshold for non-interactive non-guardian sessions (default: none)",
+            ),
+        }),
+      ])
+      .default({ conversation: "low", background: "medium", headless: "none" })
+      .describe(
+        "Auto-approve tools at or below this risk level without prompting. " +
+          "Accepts a scalar ('none', 'low', 'medium') applied to all contexts, " +
+          "or an object with per-context overrides: { conversation, background, headless }.",
+      ),
   })
   .describe("Permission enforcement mode for tool operations");
 

package/src/config/schemas/services.ts

@@ -28,10 +28,15 @@ export const BaseServiceSchema = z.object({
 });
 export type BaseService = z.infer<typeof BaseServiceSchema>;
 
-export const InferenceServiceSchema = BaseServiceSchema.extend({
-  provider: z.enum(VALID_INFERENCE_PROVIDERS).default("anthropic"),
-  model: z.string().default("claude-opus-4-6"),
-});
+/**
+ * Inference service entry. Carries only the routing `mode`
+ * (`managed` vs `your-own`) — the provider and model live under
+ * `llm.default.{provider, model}` (see `schemas/llm.ts`). PR 19 of the
+ * unify-llm-callsites plan removed the `provider` and `model` fields here;
+ * legacy configs that still carry them have those keys stripped by
+ * workspace migration `039-drop-legacy-llm-keys`.
+ */
+export const InferenceServiceSchema = BaseServiceSchema;
 export type InferenceService = z.infer<typeof InferenceServiceSchema>;
 
 export const ImageGenerationServiceSchema = BaseServiceSchema.extend({

package/src/config/schemas/stt.ts

@@ -8,6 +8,7 @@ export const VALID_STT_PROVIDERS = [
   "deepgram",
   "google-gemini",
   "openai-whisper",
+  "xai",
 ] as const;
 
 /**

package/src/config/schemas/tts.ts

@@ -167,6 +167,58 @@ export type TtsDeepgramProviderConfig = z.infer<
   typeof TtsDeepgramProviderConfigSchema
 >;
 
+export const TtsXaiProviderConfigSchema = z
+  .object({
+    voiceId: z
+      .string({
+        error: "services.tts.providers.xai.voiceId must be a string",
+      })
+      .transform((v) => v || "eve")
+      .default("eve")
+      .describe(
+        "xAI voice ID — one of: eve, ara, rex, sal, leo (case-insensitive)",
+      ),
+    language: z
+      .string({
+        error: "services.tts.providers.xai.language must be a string",
+      })
+      .default("auto")
+      .describe(
+        "BCP-47 language code (e.g. 'en-US') or 'auto' for auto-detection",
+      ),
+    format: z
+      .enum(["mp3", "wav"], {
+        error: "services.tts.providers.xai.format must be one of: mp3, wav",
+      })
+      .default("mp3")
+      .describe("Output audio format for call/runtime playback"),
+    sampleRate: z
+      .number({
+        error: "services.tts.providers.xai.sampleRate must be a number",
+      })
+      .int("services.tts.providers.xai.sampleRate must be an integer")
+      .refine((v) => [8000, 16000, 22050, 24000, 44100, 48000].includes(v), {
+        message:
+          "services.tts.providers.xai.sampleRate must be one of: 8000, 16000, 22050, 24000, 44100, 48000",
+      })
+      .default(24000)
+      .describe("Output sample rate in Hz"),
+    bitRate: z
+      .number({
+        error: "services.tts.providers.xai.bitRate must be a number",
+      })
+      .int("services.tts.providers.xai.bitRate must be an integer")
+      .refine((v) => [32000, 64000, 96000, 128000, 192000].includes(v), {
+        message:
+          "services.tts.providers.xai.bitRate must be one of: 32000, 64000, 96000, 128000, 192000",
+      })
+      .default(128000)
+      .describe("MP3 bit rate (ignored for non-MP3 codecs)"),
+  })
+  .describe("xAI provider configuration under services.tts");
+
+export type TtsXaiProviderConfig = z.infer<typeof TtsXaiProviderConfigSchema>;
+
 export const TtsProvidersSchema = z.object({
   elevenlabs: TtsElevenLabsProviderConfigSchema.default(
     TtsElevenLabsProviderConfigSchema.parse({}),
@@ -177,6 +229,7 @@ export const TtsProvidersSchema = z.object({
   deepgram: TtsDeepgramProviderConfigSchema.default(
     TtsDeepgramProviderConfigSchema.parse({}),
   ),
+  xai: TtsXaiProviderConfigSchema.default(TtsXaiProviderConfigSchema.parse({})),
 });
 export type TtsProviders = z.infer<typeof TtsProvidersSchema>;
 

package/src/config/schemas/updates.ts

@@ -6,7 +6,7 @@ export const UpdatesConfigSchema = z
       .boolean({ error: "updates.enabled must be a boolean" })
       .default(true)
       .describe(
-        "Whether the release update bulletin (UPDATES.md) is materialized into the workspace on daemon startup",
+        "Whether to dispatch a background conversation when <workspace>/UPDATES.md has unprocessed content. When false, release-update bulletins are written by migrations but never processed by the agent.",
       ),
   })
   .describe("Release update bulletin configuration");