@vellumai/assistant 0.6.3 → 0.6.5

package/src/__tests__/config-schema.test.ts

@@ -1,4 +1,10 @@
-import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -51,8 +57,14 @@ import { invalidateConfigCache, loadConfig } from "../config/loader.js";
 import {
   AssistantConfigSchema,
   DEFAULT_ELEVENLABS_VOICE_ID,
+  SttServiceSchema,
+  TtsServiceSchema,
+  VALID_TTS_SERVICE_PROVIDERS,
 } from "../config/schema.js";
+import type { AssistantConfig } from "../config/types.js";
 import { _setStorePath } from "../security/encrypted-store.js";
+import { listCatalogProviderIds } from "../tts/provider-catalog.js";
+import { resolveTtsConfig } from "../tts/tts-config-resolver.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -69,9 +81,11 @@ function writeConfig(obj: unknown): void {
 describe("AssistantConfigSchema", () => {
   test("parses empty object with full defaults", () => {
     const result = AssistantConfigSchema.parse({});
-    expect(result.services.inference.provider).toBe("anthropic");
-    expect(result.services.inference.model).toBe("claude-opus-4-6");
+    // services.inference now carries only `mode`; provider/model live under
+    // llm.default.{provider,model} (see PR 19 of unify-llm-callsites).
     expect(result.services.inference.mode).toBe("your-own");
+    expect(result.llm.default.provider).toBe("anthropic");
+    expect(result.llm.default.model).toBe("claude-opus-4-7");
     expect(result.services["image-generation"].provider).toBe("gemini");
     expect(result.services["image-generation"].model).toBe(
       "gemini-3.1-flash-image-preview",
@@ -81,12 +95,12 @@ describe("AssistantConfigSchema", () => {
       "inference-provider-native",
     );
     expect(result.services["web-search"].mode).toBe("your-own");
-    expect(result.maxTokens).toBe(64000);
-    expect(result.thinking).toEqual({
+    expect(result.llm.default.maxTokens).toBe(64000);
+    expect(result.llm.default.thinking).toEqual({
       enabled: true,
       streamThinking: true,
     });
-    expect(result.contextWindow).toEqual({
+    expect(result.llm.default.contextWindow).toEqual({
       enabled: true,
       maxInputTokens: 200000,
       targetBudgetRatio: 0.3,
@@ -122,11 +136,13 @@ describe("AssistantConfigSchema", () => {
 
   test("accepts valid complete config", () => {
     const input = {
-      services: {
-        inference: { provider: "openai", model: "gpt-4" },
+      llm: {
+        default: {
+          provider: "openai" as const,
+          model: "gpt-4",
+          maxTokens: 4096,
+        },
       },
-      maxTokens: 4096,
-      thinking: { enabled: true },
       timeouts: {
         shellDefaultTimeoutSec: 30,
         shellMaxTimeoutSec: 300,
@@ -142,13 +158,186 @@ describe("AssistantConfigSchema", () => {
       auditLog: { retentionDays: 30 },
     };
     const result = AssistantConfigSchema.parse(input);
-    expect(result.services.inference.provider).toBe("openai");
-    expect(result.services.inference.model).toBe("gpt-4");
-    expect(result.maxTokens).toBe(4096);
-    expect(result.thinking.enabled).toBe(true);
+    expect(result.llm.default.provider).toBe("openai");
+    expect(result.llm.default.model).toBe("gpt-4");
+    expect(result.llm.default.maxTokens).toBe(4096);
+    expect(result.llm.default.thinking.enabled).toBe(true);
     expect(result.secretDetection.action).toBe("block");
   });
 
+  test("applies llm defaults when llm key is omitted", () => {
+    const result = AssistantConfigSchema.parse({});
+    expect(result.llm).toBeDefined();
+    expect(result.llm.default).toEqual({
+      provider: "anthropic",
+      model: "claude-opus-4-7",
+      maxTokens: 64000,
+      effort: "max",
+      speed: "standard",
+      temperature: null,
+      thinking: { enabled: true, streamThinking: true },
+      contextWindow: {
+        enabled: true,
+        maxInputTokens: 200000,
+        targetBudgetRatio: 0.3,
+        compactThreshold: 0.8,
+        summaryBudgetRatio: 0.05,
+        overflowRecovery: {
+          enabled: true,
+          safetyMarginRatio: 0.05,
+          maxAttempts: 3,
+          interactiveLatestTurnCompression: "summarize",
+          nonInteractiveLatestTurnCompression: "truncate",
+        },
+      },
+      openrouter: { only: [] },
+    });
+    expect(result.llm.profiles).toEqual({});
+    expect(result.llm.callSites).toEqual({});
+    expect(result.llm.pricingOverrides).toEqual([]);
+  });
+
+  test("accepts an explicit llm block with profiles and call sites", () => {
+    const input = {
+      llm: {
+        default: {
+          provider: "anthropic" as const,
+          model: "claude-opus-4-7",
+          maxTokens: 32000,
+          effort: "high" as const,
+          speed: "fast" as const,
+          temperature: null,
+          thinking: { enabled: true, streamThinking: false },
+          contextWindow: {
+            enabled: true,
+            maxInputTokens: 200000,
+            targetBudgetRatio: 0.3,
+            compactThreshold: 0.8,
+            summaryBudgetRatio: 0.05,
+            overflowRecovery: {
+              enabled: true,
+              safetyMarginRatio: 0.05,
+              maxAttempts: 3,
+              interactiveLatestTurnCompression: "summarize" as const,
+              nonInteractiveLatestTurnCompression: "truncate" as const,
+            },
+          },
+        },
+        profiles: {
+          fast: { speed: "fast" as const, effort: "low" as const },
+        },
+        callSites: {
+          mainAgent: { profile: "fast" },
+          commitMessage: { maxTokens: 256 },
+        },
+        pricingOverrides: [],
+      },
+    };
+    const result = AssistantConfigSchema.parse(input);
+    expect(result.llm.default.model).toBe("claude-opus-4-7");
+    expect(result.llm.default.speed).toBe("fast");
+    expect(result.llm.profiles?.fast).toEqual({
+      speed: "fast",
+      effort: "low",
+    });
+    expect(result.llm.callSites?.mainAgent).toEqual({ profile: "fast" });
+    expect(result.llm.callSites?.commitMessage).toEqual({ maxTokens: 256 });
+  });
+
+  test("rejects an llm.callSites entry that references an undefined profile", () => {
+    const input = {
+      llm: {
+        default: {
+          provider: "anthropic" as const,
+          model: "claude-opus-4-6",
+          maxTokens: 64000,
+          effort: "max" as const,
+          speed: "standard" as const,
+          temperature: null,
+          thinking: { enabled: true, streamThinking: true },
+          contextWindow: {
+            enabled: true,
+            maxInputTokens: 200000,
+            targetBudgetRatio: 0.3,
+            compactThreshold: 0.8,
+            summaryBudgetRatio: 0.05,
+            overflowRecovery: {
+              enabled: true,
+              safetyMarginRatio: 0.05,
+              maxAttempts: 3,
+              interactiveLatestTurnCompression: "summarize" as const,
+              nonInteractiveLatestTurnCompression: "truncate" as const,
+            },
+          },
+        },
+        callSites: {
+          mainAgent: { profile: "missing-profile" },
+        },
+      },
+    };
+    expect(() => AssistantConfigSchema.parse(input)).toThrow(/missing-profile/);
+  });
+
+  test("legacy top-level inference keys are ignored after PR 19 cleanup", () => {
+    // The legacy keys (top-level maxTokens, effort, speed, thinking,
+    // contextWindow, services.inference.{provider,model}) were removed in PR
+    // 19. Configs that still carry them parse cleanly because Zod strips
+    // unknown fields, and migration 039 erases them from the on-disk file
+    // entirely.
+    const input = {
+      services: {
+        inference: { provider: "openai", model: "gpt-4" },
+      },
+      maxTokens: 8000,
+      effort: "medium",
+      speed: "fast",
+      thinking: { enabled: false, streamThinking: false },
+    };
+    const result = AssistantConfigSchema.parse(input);
+    expect((result as Record<string, unknown>).maxTokens).toBeUndefined();
+    expect((result as Record<string, unknown>).effort).toBeUndefined();
+    expect((result as Record<string, unknown>).speed).toBeUndefined();
+    expect((result as Record<string, unknown>).thinking).toBeUndefined();
+    expect(
+      (result.services.inference as Record<string, unknown>).provider,
+    ).toBeUndefined();
+    expect(
+      (result.services.inference as Record<string, unknown>).model,
+    ).toBeUndefined();
+    expect(result.llm.default.provider).toBe("anthropic");
+    expect(result.llm.default.model).toBe("claude-opus-4-7");
+  });
+
+  test("partial llm config (empty `llm: {}`) doesn't trigger full config reset", () => {
+    // Regression guard: previously LLMConfigBase had no schema-level defaults,
+    // so any `llm: {}` block would fail validation and the loader's recovery
+    // path would fall through to `cloneDefaultConfig()`, discarding unrelated
+    // valid settings (like a custom `llm.default.maxTokens`). With leaf-level
+    // defaults, `llm: {}` parses cleanly and the user's other settings are
+    // preserved.
+    const result = AssistantConfigSchema.parse({
+      llm: { default: { maxTokens: 32000 } },
+    });
+    expect(result.llm.default.maxTokens).toBe(32000);
+    expect(result.llm.default.provider).toBe("anthropic");
+    expect(result.llm.default.model).toBe("claude-opus-4-7");
+  });
+
+  test("llm.default with one missing field still parses (defaults applied)", () => {
+    // A user can override a single field of `llm.default` without specifying
+    // the rest — schema-level defaults fill in everything that wasn't set.
+    const result = AssistantConfigSchema.parse({
+      llm: { default: { model: "claude-haiku-4-5" } },
+    });
+    expect(result.llm.default.model).toBe("claude-haiku-4-5");
+    expect(result.llm.default.provider).toBe("anthropic");
+    expect(result.llm.default.maxTokens).toBe(64000);
+    expect(result.llm.default.thinking).toEqual({
+      enabled: true,
+      streamThinking: true,
+    });
+  });
+
   test("applies rollout defaults for dynamic budget", () => {
     const result = AssistantConfigSchema.parse({});
     expect(result.memory.retrieval.dynamicBudget).toEqual({
@@ -166,7 +355,7 @@ describe("AssistantConfigSchema", () => {
       enqueueIntervalMs: 6 * 60 * 60 * 1000,
       supersededItemRetentionMs: 30 * 24 * 60 * 60 * 1000,
       conversationRetentionDays: 0,
-      llmRequestLogRetentionMs: 1 * 24 * 60 * 60 * 1000,
+      llmRequestLogRetentionMs: 1 * 60 * 60 * 1000,
     });
   });
 
@@ -177,15 +366,74 @@ describe("AssistantConfigSchema", () => {
     expect(result.success).toBe(false);
   });
 
+  test("accepts memory.cleanup.llmRequestLogRetentionMs at the 365-day boundary", () => {
+    const max = 365 * 24 * 60 * 60 * 1000;
+    const result = AssistantConfigSchema.safeParse({
+      memory: { cleanup: { llmRequestLogRetentionMs: max } },
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.memory.cleanup.llmRequestLogRetentionMs).toBe(max);
+    }
+  });
+
+  test("rejects memory.cleanup.llmRequestLogRetentionMs above 365 days", () => {
+    // This must match the gateway's MAX_LLM_REQUEST_LOG_RETENTION_MS. Without
+    // the Zod .max(), a manually edited config.json with a large value would
+    // be silently accepted by the daemon and then truncated by the macOS
+    // picker on the next PATCH — a quiet data-loss bug.
+    const overMax = 365 * 24 * 60 * 60 * 1000 + 1;
+    const result = AssistantConfigSchema.safeParse({
+      memory: { cleanup: { llmRequestLogRetentionMs: overMax } },
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(
+        result.error.issues.some((i) =>
+          i.path.includes("llmRequestLogRetentionMs"),
+        ),
+      ).toBe(true);
+    }
+  });
+
+  test("rejects negative memory.cleanup.llmRequestLogRetentionMs", () => {
+    const result = AssistantConfigSchema.safeParse({
+      memory: { cleanup: { llmRequestLogRetentionMs: -1 } },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("accepts null memory.cleanup.llmRequestLogRetentionMs (keep forever)", () => {
+    const result = AssistantConfigSchema.safeParse({
+      memory: { cleanup: { llmRequestLogRetentionMs: null } },
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.memory.cleanup.llmRequestLogRetentionMs).toBeNull();
+    }
+  });
+
+  test("accepts memory.cleanup.llmRequestLogRetentionMs: 0 (prune immediately)", () => {
+    const result = AssistantConfigSchema.safeParse({
+      memory: { cleanup: { llmRequestLogRetentionMs: 0 } },
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.memory.cleanup.llmRequestLogRetentionMs).toBe(0);
+    }
+  });
+
   test("rejects invalid provider", () => {
     const result = AssistantConfigSchema.safeParse({
-      services: { inference: { provider: "invalid" } },
+      llm: { default: { provider: "invalid" } },
     });
     expect(result.success).toBe(false);
   });
 
-  test("rejects negative maxTokens", () => {
-    const result = AssistantConfigSchema.safeParse({ maxTokens: -100 });
+  test("rejects negative llm.default.maxTokens", () => {
+    const result = AssistantConfigSchema.safeParse({
+      llm: { default: { maxTokens: -100 } },
+    });
     expect(result.success).toBe(false);
     if (!result.success) {
       expect(
@@ -194,8 +442,10 @@ describe("AssistantConfigSchema", () => {
     }
   });
 
-  test("rejects non-integer maxTokens", () => {
-    const result = AssistantConfigSchema.safeParse({ maxTokens: 3.14 });
+  test("rejects non-integer llm.default.maxTokens", () => {
+    const result = AssistantConfigSchema.safeParse({
+      llm: { default: { maxTokens: 3.14 } },
+    });
     expect(result.success).toBe(false);
     if (!result.success) {
       expect(
@@ -204,9 +454,9 @@ describe("AssistantConfigSchema", () => {
     }
   });
 
-  test("rejects string maxTokens", () => {
+  test("rejects string llm.default.maxTokens", () => {
     const result = AssistantConfigSchema.safeParse({
-      maxTokens: "not-a-number",
+      llm: { default: { maxTokens: "not-a-number" } },
     });
     expect(result.success).toBe(false);
     if (!result.success) {
@@ -232,7 +482,7 @@ describe("AssistantConfigSchema", () => {
 
   test("rejects invalid thinking config", () => {
     const result = AssistantConfigSchema.safeParse({
-      thinking: { enabled: "yes" },
+      llm: { default: { thinking: { enabled: "yes" } } },
     });
     expect(result.success).toBe(false);
     if (!result.success) {
@@ -242,16 +492,21 @@ describe("AssistantConfigSchema", () => {
 
   test("rejects contextWindow targetBudgetRatio >= compactThreshold", () => {
     const result = AssistantConfigSchema.safeParse({
-      contextWindow: { targetBudgetRatio: 0.8, compactThreshold: 0.8 },
+      llm: {
+        default: {
+          contextWindow: { targetBudgetRatio: 0.8, compactThreshold: 0.8 },
+        },
+      },
     });
     expect(result.success).toBe(false);
     if (!result.success) {
       expect(
         result.error.issues.some(
           (issue) =>
-            issue.path.join(".") === "contextWindow.targetBudgetRatio" &&
+            issue.path.join(".") ===
+              "llm.default.contextWindow.targetBudgetRatio" &&
             issue.message.includes(
-              "must be less than contextWindow.compactThreshold",
+              "must be less than llm.default.contextWindow.compactThreshold",
             ),
         ),
       ).toBe(true);
@@ -261,7 +516,11 @@ describe("AssistantConfigSchema", () => {
   test("rejects overflowRecovery safetyMarginRatio out of (0,1) range", () => {
     for (const bad of [0, 1, -0.1, 1.5]) {
       const result = AssistantConfigSchema.safeParse({
-        contextWindow: { overflowRecovery: { safetyMarginRatio: bad } },
+        llm: {
+          default: {
+            contextWindow: { overflowRecovery: { safetyMarginRatio: bad } },
+          },
+        },
       });
       expect(result.success).toBe(false);
       if (!result.success) {
@@ -276,8 +535,12 @@ describe("AssistantConfigSchema", () => {
 
   test("rejects invalid overflowRecovery interactiveLatestTurnCompression", () => {
     const result = AssistantConfigSchema.safeParse({
-      contextWindow: {
-        overflowRecovery: { interactiveLatestTurnCompression: "explode" },
+      llm: {
+        default: {
+          contextWindow: {
+            overflowRecovery: { interactiveLatestTurnCompression: "explode" },
+          },
+        },
       },
     });
     expect(result.success).toBe(false);
@@ -292,8 +555,12 @@ describe("AssistantConfigSchema", () => {
 
   test("rejects invalid overflowRecovery nonInteractiveLatestTurnCompression", () => {
     const result = AssistantConfigSchema.safeParse({
-      contextWindow: {
-        overflowRecovery: { nonInteractiveLatestTurnCompression: "nope" },
+      llm: {
+        default: {
+          contextWindow: {
+            overflowRecovery: { nonInteractiveLatestTurnCompression: "nope" },
+          },
+        },
       },
     });
     expect(result.success).toBe(false);
@@ -364,7 +631,7 @@ describe("AssistantConfigSchema", () => {
       "ollama",
     ] as const) {
       const result = AssistantConfigSchema.safeParse({
-        services: { inference: { provider } },
+        llm: { default: { provider } },
       });
       expect(result.success).toBe(true);
     }
@@ -381,13 +648,19 @@ describe("AssistantConfigSchema", () => {
 
   test("provides helpful error messages", () => {
     const result = AssistantConfigSchema.safeParse({
-      maxTokens: -1,
+      llm: { default: { maxTokens: -1 } },
       secretDetection: { action: "explode" },
     });
     expect(result.success).toBe(false);
     if (!result.success) {
       const messages = result.error.issues.map((i) => i.message);
-      expect(messages.some((m) => m.includes("positive"))).toBe(true);
+      // The llm.default.maxTokens validation rejects -1 with a "Too small"
+      // / "expected number to be >0" message from Zod's default issue text.
+      expect(
+        messages.some(
+          (m) => m.includes("positive") || /expected number to be >0/i.test(m),
+        ),
+      ).toBe(true);
       expect(
         messages.some(
           (m) =>
@@ -402,6 +675,11 @@ describe("AssistantConfigSchema", () => {
     expect(result.permissions).toEqual({
       mode: "workspace",
       hostAccess: false,
+      autoApproveUpTo: {
+        conversation: "low",
+        background: "medium",
+        headless: "none",
+      },
     });
   });
 
@@ -438,6 +716,119 @@ describe("AssistantConfigSchema", () => {
     }
   });
 
+  test("defaults autoApproveUpTo to per-context object when not specified", () => {
+    const result = AssistantConfigSchema.parse({
+      permissions: { mode: "workspace" },
+    });
+    expect(result.permissions.autoApproveUpTo).toEqual({
+      conversation: "low",
+      background: "medium",
+      headless: "none",
+    });
+  });
+
+  test("accepts autoApproveUpTo none", () => {
+    const result = AssistantConfigSchema.parse({
+      permissions: { autoApproveUpTo: "none" },
+    });
+    expect(result.permissions.autoApproveUpTo).toBe("none");
+  });
+
+  test("accepts autoApproveUpTo low", () => {
+    const result = AssistantConfigSchema.parse({
+      permissions: { autoApproveUpTo: "low" },
+    });
+    expect(result.permissions.autoApproveUpTo).toBe("low");
+  });
+
+  test("accepts autoApproveUpTo medium", () => {
+    const result = AssistantConfigSchema.parse({
+      permissions: { autoApproveUpTo: "medium" },
+    });
+    expect(result.permissions.autoApproveUpTo).toBe("medium");
+  });
+
+  test("rejects autoApproveUpTo high", () => {
+    const result = AssistantConfigSchema.safeParse({
+      permissions: { autoApproveUpTo: "high" },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects invalid autoApproveUpTo string", () => {
+    const result = AssistantConfigSchema.safeParse({
+      permissions: { autoApproveUpTo: "everything" },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("autoApproveUpTo round-trips through JSON serialization", () => {
+    const original = AssistantConfigSchema.parse({
+      permissions: { autoApproveUpTo: "medium" },
+    });
+    const json = JSON.stringify(original);
+    const parsed = AssistantConfigSchema.parse(JSON.parse(json));
+    expect(parsed.permissions.autoApproveUpTo).toBe("medium");
+  });
+
+  test("accepts autoApproveUpTo as per-context object", () => {
+    const result = AssistantConfigSchema.parse({
+      permissions: {
+        autoApproveUpTo: {
+          conversation: "low",
+          background: "medium",
+          headless: "none",
+        },
+      },
+    });
+    expect(result.permissions.autoApproveUpTo).toEqual({
+      conversation: "low",
+      background: "medium",
+      headless: "none",
+    });
+  });
+
+  test("per-context object applies defaults for omitted keys", () => {
+    const result = AssistantConfigSchema.parse({
+      permissions: {
+        autoApproveUpTo: {},
+      },
+    });
+    expect(result.permissions.autoApproveUpTo).toEqual({
+      conversation: "low",
+      background: "medium",
+      headless: "none",
+    });
+  });
+
+  test("per-context object rejects invalid enum values", () => {
+    const result = AssistantConfigSchema.safeParse({
+      permissions: {
+        autoApproveUpTo: { conversation: "high" },
+      },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("per-context object round-trips through JSON serialization", () => {
+    const original = AssistantConfigSchema.parse({
+      permissions: {
+        autoApproveUpTo: {
+          conversation: "none",
+          background: "low",
+          headless: "medium",
+        },
+      },
+    });
+    const json = JSON.stringify(original);
+    const parsed = AssistantConfigSchema.parse(JSON.parse(json));
+    expect(parsed.permissions.autoApproveUpTo).toEqual({
+      conversation: "none",
+      background: "low",
+      headless: "medium",
+    });
+  });
+
   test("applies workspaceGit defaults including interactiveGitTimeoutMs", () => {
     const result = AssistantConfigSchema.parse({});
     expect(result.workspaceGit).toEqual({
@@ -451,11 +842,7 @@ describe("AssistantConfigSchema", () => {
       enrichmentMaxRetries: 2,
       commitMessageLLM: {
         enabled: false,
-        useConfiguredProvider: true,
-        providerFastModelOverrides: {},
         timeoutMs: 600,
-        maxTokens: 120,
-        temperature: 0.2,
         maxFilesInPrompt: 30,
         maxDiffBytes: 12000,
         minRemainingTurnBudgetMs: 1000,
@@ -509,11 +896,7 @@ describe("AssistantConfigSchema", () => {
     const result = AssistantConfigSchema.parse({});
     const llm = result.workspaceGit.commitMessageLLM;
     expect(llm.enabled).toBe(false);
-    expect(llm.useConfiguredProvider).toBe(true);
-    expect(llm.providerFastModelOverrides).toEqual({});
     expect(llm.timeoutMs).toBe(600);
-    expect(llm.maxTokens).toBe(120);
-    expect(llm.temperature).toBe(0.2);
     expect(llm.maxFilesInPrompt).toBe(30);
     expect(llm.maxDiffBytes).toBe(12000);
     expect(llm.minRemainingTurnBudgetMs).toBe(1000);
@@ -526,13 +909,6 @@ describe("AssistantConfigSchema", () => {
     expect(result.success).toBe(false);
   });
 
-  test("rejects commitMessageLLM.temperature > 2", () => {
-    const result = AssistantConfigSchema.safeParse({
-      workspaceGit: { commitMessageLLM: { temperature: 2.5 } },
-    });
-    expect(result.success).toBe(false);
-  });
-
   test("breaker settings have correct defaults", () => {
     const result = AssistantConfigSchema.parse({});
     const breaker = result.workspaceGit.commitMessageLLM.breaker;
@@ -547,14 +923,12 @@ describe("AssistantConfigSchema", () => {
         commitMessageLLM: {
           enabled: true,
           timeoutMs: 1000,
-          temperature: 0.5,
           breaker: { openAfterFailures: 5 },
         },
       },
     });
     expect(result.workspaceGit.commitMessageLLM.enabled).toBe(true);
     expect(result.workspaceGit.commitMessageLLM.timeoutMs).toBe(1000);
-    expect(result.workspaceGit.commitMessageLLM.temperature).toBe(0.5);
     expect(result.workspaceGit.commitMessageLLM.breaker.openAfterFailures).toBe(
       5,
     );
@@ -564,18 +938,18 @@ describe("AssistantConfigSchema", () => {
     );
   });
 
-  test("rejects commitMessageLLM.temperature < 0", () => {
-    const result = AssistantConfigSchema.safeParse({
-      workspaceGit: { commitMessageLLM: { temperature: -0.1 } },
-    });
-    expect(result.success).toBe(false);
-  });
-
-  test("rejects non-integer commitMessageLLM.maxTokens", () => {
-    const result = AssistantConfigSchema.safeParse({
-      workspaceGit: { commitMessageLLM: { maxTokens: 3.5 } },
+  test("ignores legacy commitMessageLLM.{maxTokens,temperature} keys", () => {
+    // PR 19 removed maxTokens/temperature from the schema; Zod silently
+    // strips them on parse. Migration 039 erases them from disk so they
+    // don't accumulate over time.
+    const result = AssistantConfigSchema.parse({
+      workspaceGit: {
+        commitMessageLLM: { maxTokens: 200, temperature: 0.5 },
+      },
     });
-    expect(result.success).toBe(false);
+    const cm = result.workspaceGit.commitMessageLLM as Record<string, unknown>;
+    expect(cm.maxTokens).toBeUndefined();
+    expect(cm.temperature).toBeUndefined();
   });
 
   // ── Calls config ────────────────────────────────────────────────────
@@ -602,8 +976,6 @@ describe("AssistantConfigSchema", () => {
       },
       voice: {
         language: "en-US",
-        transcriptionProvider: "Deepgram",
-        ttsProvider: "elevenlabs",
         hints: [],
         interruptSensitivity: "low",
       },
@@ -711,29 +1083,8 @@ describe("AssistantConfigSchema", () => {
   test("config without calls.voice parses correctly and produces defaults", () => {
     const result = AssistantConfigSchema.parse({});
     expect(result.calls.voice.language).toBe("en-US");
-    expect(result.calls.voice.transcriptionProvider).toBe("Deepgram");
-  });
-
-  test("elevenlabs tuning params have correct defaults", () => {
-    const result = AssistantConfigSchema.parse({});
-    expect(result.elevenlabs.voiceModelId).toBe("");
-    expect(result.elevenlabs.speed).toBe(1.0);
-    expect(result.elevenlabs.stability).toBe(0.5);
-    expect(result.elevenlabs.similarityBoost).toBe(0.75);
-  });
-
-  test("rejects elevenlabs.speed below 0.7", () => {
-    const result = AssistantConfigSchema.safeParse({
-      elevenlabs: { speed: 0.5 },
-    });
-    expect(result.success).toBe(false);
-  });
-
-  test("rejects elevenlabs.speed above 1.2", () => {
-    const result = AssistantConfigSchema.safeParse({
-      elevenlabs: { speed: 1.5 },
-    });
-    expect(result.success).toBe(false);
+    expect(result.calls.voice.hints).toEqual([]);
+    expect(result.calls.voice.interruptSensitivity).toBe("low");
   });
 
   test("accepts valid calls.voice overrides", () => {
@@ -741,51 +1092,29 @@ describe("AssistantConfigSchema", () => {
       calls: {
         voice: {
           language: "es-ES",
-          transcriptionProvider: "Google",
         },
       },
-      elevenlabs: {
-        stability: 0.8,
-      },
     });
     expect(result.calls.voice.language).toBe("es-ES");
-    expect(result.calls.voice.transcriptionProvider).toBe("Google");
-    expect(result.elevenlabs.stability).toBe(0.8);
-    // Defaults preserved for unset fields
-    expect(result.elevenlabs.voiceModelId).toBe("");
-    expect(result.elevenlabs.similarityBoost).toBe(0.75);
-  });
-
-  test("rejects invalid calls.voice.transcriptionProvider", () => {
-    const result = AssistantConfigSchema.safeParse({
-      calls: { voice: { transcriptionProvider: "AWS" } },
-    });
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      const msgs = result.error.issues.map((i) => i.message);
-      expect(
-        msgs.some((m) => m.includes("calls.voice.transcriptionProvider")),
-      ).toBe(true);
-    }
   });
 
-  test("rejects elevenlabs.stability out of range", () => {
-    const result = AssistantConfigSchema.safeParse({
-      elevenlabs: { stability: 1.5 },
+  test("transcriptionProvider is no longer part of the voice config schema", () => {
+    // Zod strips unrecognized keys by default — the legacy field is silently ignored.
+    const result = AssistantConfigSchema.parse({
+      calls: { voice: { transcriptionProvider: "Google" } },
     });
-    expect(result.success).toBe(false);
+    expect(
+      (result.calls.voice as Record<string, unknown>).transcriptionProvider,
+    ).toBeUndefined();
   });
 
-  test("accepts optional calls.model", () => {
+  test("legacy calls.model key is stripped after PR 19 cleanup", () => {
+    // calls.model moved to llm.callSites.callAgent.model in PR 4 and the
+    // legacy field was removed in PR 19. Zod silently strips unknown keys.
     const result = AssistantConfigSchema.parse({
       calls: { model: "claude-haiku-4-5-20251001" },
     });
-    expect(result.calls.model).toBe("claude-haiku-4-5-20251001");
-  });
-
-  test("calls.model is undefined by default", () => {
-    const result = AssistantConfigSchema.parse({});
-    expect(result.calls.model).toBeUndefined();
+    expect((result.calls as Record<string, unknown>).model).toBeUndefined();
   });
 
   // ── Caller identity config ────────────────────────────────────────
@@ -850,6 +1179,10 @@ describe("AssistantConfigSchema", () => {
         host: "localhost",
         port: 9222,
         probeTimeoutMs: 500,
+        desktopAuto: {
+          enabled: true,
+          cooldownMs: 30_000,
+        },
       },
     });
   });
@@ -958,68 +1291,481 @@ describe("AssistantConfigSchema", () => {
     });
     expect(result.success).toBe(false);
   });
-});
 
-// ---------------------------------------------------------------------------
-// Tests: Voice quality profile resolver
-// ---------------------------------------------------------------------------
+  // ── services.tts config ──────────────────────────────────────────────
 
-describe("resolveVoiceQualityProfile", () => {
-  test("always returns ElevenLabs ttsProvider", () => {
-    const config = AssistantConfigSchema.parse({});
-    const profile = resolveVoiceQualityProfile(config);
-    expect(profile.ttsProvider).toBe("ElevenLabs");
-    expect(profile.transcriptionProvider).toBe("Deepgram");
+  test("applies services.tts defaults when not specified", () => {
+    const result = AssistantConfigSchema.parse({});
+    expect(result.services.tts.mode).toBe("your-own");
+    expect(result.services.tts.provider).toBe("elevenlabs");
+    expect(result.services.tts.providers.elevenlabs.voiceId).toBe(
+      DEFAULT_ELEVENLABS_VOICE_ID,
+    );
+    expect(result.services.tts.providers.elevenlabs.speed).toBe(1.0);
+    expect(result.services.tts.providers.elevenlabs.stability).toBe(0.5);
+    expect(result.services.tts.providers.elevenlabs.similarityBoost).toBe(0.75);
+    expect(
+      result.services.tts.providers.elevenlabs.conversationTimeoutSeconds,
+    ).toBe(30);
+    expect(result.services.tts.providers["fish-audio"].referenceId).toBe("");
+    expect(result.services.tts.providers["fish-audio"].chunkLength).toBe(200);
+    expect(result.services.tts.providers["fish-audio"].format).toBe("mp3");
+    expect(result.services.tts.providers["fish-audio"].speed).toBe(1.0);
+    expect(result.services.tts.providers.deepgram.model).toBe(
+      "aura-asteria-en",
+    );
+    expect(result.services.tts.providers.deepgram.format).toBe("mp3");
   });
 
-  test("uses shared elevenlabs.voiceId for voice", () => {
-    const config = AssistantConfigSchema.parse({
-      elevenlabs: { voiceId: "test-voice-id" },
+  test("accepts valid services.tts provider override", () => {
+    const result = AssistantConfigSchema.parse({
+      services: { tts: { provider: "fish-audio" } },
     });
-    const profile = resolveVoiceQualityProfile(config);
-    expect(profile.ttsProvider).toBe("ElevenLabs");
-    expect(profile.voice).toBe("test-voice-id");
+    expect(result.services.tts.provider).toBe("fish-audio");
+    expect(result.services.tts.mode).toBe("your-own");
   });
 
-  test("defaults to Amelia voice ID when elevenlabs.voiceId is not set", () => {
-    const config = AssistantConfigSchema.parse({});
-    const profile = resolveVoiceQualityProfile(config);
-    expect(profile.voice).toBe(DEFAULT_ELEVENLABS_VOICE_ID);
+  test("accepts deepgram as services.tts.provider", () => {
+    const result = AssistantConfigSchema.parse({
+      services: { tts: { provider: "deepgram" } },
+    });
+    expect(result.services.tts.provider).toBe("deepgram");
+    expect(result.services.tts.mode).toBe("your-own");
   });
 
-  test("applies voice tuning params from elevenlabs config", () => {
-    const config = AssistantConfigSchema.parse({
-      elevenlabs: {
-        voiceId: "abc123",
-        voiceModelId: "turbo_v2_5",
-        speed: 0.9,
-        stability: 0.8,
-        similarityBoost: 0.9,
+  test("accepts valid services.tts.providers.elevenlabs overrides", () => {
+    const result = AssistantConfigSchema.parse({
+      services: {
+        tts: {
+          providers: {
+            elevenlabs: { voiceId: "custom-voice", speed: 0.8 },
+          },
+        },
       },
     });
-    const profile = resolveVoiceQualityProfile(config);
-    expect(profile.voice).toBe("abc123-turbo_v2_5-0.9_0.8_0.9");
+    expect(result.services.tts.providers.elevenlabs.voiceId).toBe(
+      "custom-voice",
+    );
+    expect(result.services.tts.providers.elevenlabs.speed).toBe(0.8);
+    // Unset fields preserve defaults
+    expect(result.services.tts.providers.elevenlabs.stability).toBe(0.5);
   });
-});
-
-// ---------------------------------------------------------------------------
-// Tests: buildElevenLabsVoiceSpec
-// ---------------------------------------------------------------------------
 
-describe("buildElevenLabsVoiceSpec", () => {
-  test("produces Twilio-compliant voice string: voiceId-model-speed_stability_similarity", () => {
-    const spec = buildElevenLabsVoiceSpec({
-      voiceId: "abc123",
-      voiceModelId: "turbo_v2_5",
-      speed: 1.0,
-      stability: 0.5,
-      similarityBoost: 0.75,
+  test("accepts valid services.tts.providers.fish-audio overrides", () => {
+    const result = AssistantConfigSchema.parse({
+      services: {
+        tts: {
+          providers: {
+            "fish-audio": { referenceId: "my-voice", format: "wav" },
+          },
+        },
+      },
     });
-    expect(spec).toBe("abc123-turbo_v2_5-1_0.5_0.75");
+    expect(result.services.tts.providers["fish-audio"].referenceId).toBe(
+      "my-voice",
+    );
+    expect(result.services.tts.providers["fish-audio"].format).toBe("wav");
+    // Defaults preserved
+    expect(result.services.tts.providers["fish-audio"].chunkLength).toBe(200);
   });
 
-  test("returns empty string when voiceId is empty", () => {
-    const spec = buildElevenLabsVoiceSpec({
+  test("accepts valid services.tts.providers.deepgram overrides", () => {
+    const result = AssistantConfigSchema.parse({
+      services: {
+        tts: {
+          providers: {
+            deepgram: { model: "aura-luna-en", format: "opus" },
+          },
+        },
+      },
+    });
+    expect(result.services.tts.providers.deepgram.model).toBe("aura-luna-en");
+    expect(result.services.tts.providers.deepgram.format).toBe("opus");
+  });
+
+  test("rejects services.tts.mode = managed", () => {
+    const result = AssistantConfigSchema.safeParse({
+      services: { tts: { mode: "managed" } },
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      const msgs = result.error.issues.map((i) => i.message);
+      expect(
+        msgs.some((m) => m.includes("your-own") || m.includes("managed")),
+      ).toBe(true);
+    }
+  });
+
+  // ── hostBrowser.cdpInspect.desktopAuto config ───────────────────────
+
+  test("applies hostBrowser.cdpInspect.desktopAuto defaults", () => {
+    const result = AssistantConfigSchema.parse({});
+    expect(result.hostBrowser.cdpInspect.desktopAuto).toEqual({
+      enabled: true,
+      cooldownMs: 30_000,
+    });
+  });
+
+  test("accepts hostBrowser.cdpInspect.desktopAuto overrides", () => {
+    const result = AssistantConfigSchema.parse({
+      hostBrowser: {
+        cdpInspect: {
+          desktopAuto: { enabled: false, cooldownMs: 10_000 },
+        },
+      },
+    });
+    expect(result.hostBrowser.cdpInspect.desktopAuto.enabled).toBe(false);
+    expect(result.hostBrowser.cdpInspect.desktopAuto.cooldownMs).toBe(10_000);
+  });
+
+  test("accepts hostBrowser.cdpInspect.desktopAuto.cooldownMs of 0 (disable cooldown)", () => {
+    const result = AssistantConfigSchema.parse({
+      hostBrowser: {
+        cdpInspect: { desktopAuto: { cooldownMs: 0 } },
+      },
+    });
+    expect(result.hostBrowser.cdpInspect.desktopAuto.cooldownMs).toBe(0);
+  });
+
+  test("rejects hostBrowser.cdpInspect.desktopAuto.cooldownMs below 0", () => {
+    const result = AssistantConfigSchema.safeParse({
+      hostBrowser: {
+        cdpInspect: { desktopAuto: { cooldownMs: -1 } },
+      },
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(
+        result.error.issues.some((issue) =>
+          issue.path.join(".").includes("cooldownMs"),
+        ),
+      ).toBe(true);
+    }
+  });
+
+  test("rejects invalid services.tts.provider", () => {
+    const result = AssistantConfigSchema.safeParse({
+      services: { tts: { provider: "aws-polly" } },
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      const msgs = result.error.issues.map((i) => i.message);
+      expect(msgs.some((m) => m.includes("services.tts.provider"))).toBe(true);
+    }
+  });
+
+  test("services.tts.mode only accepts your-own as literal", () => {
+    // Explicit your-own should work
+    const valid = TtsServiceSchema.safeParse({ mode: "your-own" });
+    expect(valid.success).toBe(true);
+
+    // managed should be rejected
+    const invalid = TtsServiceSchema.safeParse({ mode: "managed" });
+    expect(invalid.success).toBe(false);
+
+    // Any other string should be rejected
+    const invalid2 = TtsServiceSchema.safeParse({ mode: "self-hosted" });
+    expect(invalid2.success).toBe(false);
+  });
+
+  // ── services.stt config ──────────────────────────────────────────────
+
+  test("rejects services.stt without explicit provider", () => {
+    const result = AssistantConfigSchema.safeParse({
+      services: { stt: { mode: "your-own" } },
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(
+        result.error.issues.some((i) => i.path.join(".").includes("provider")),
+      ).toBe(true);
+    }
+  });
+
+  test("applies services.stt structural defaults when provider is explicit", () => {
+    const result = AssistantConfigSchema.parse({
+      services: { stt: { provider: "openai-whisper" } },
+    });
+    expect(result.services.stt.mode).toBe("your-own");
+    expect(result.services.stt.provider).toBe("openai-whisper");
+    // providers defaults to empty sparse map
+    expect(result.services.stt.providers).toEqual({});
+  });
+
+  test("accepts valid services.stt provider override", () => {
+    const result = AssistantConfigSchema.parse({
+      services: { stt: { provider: "openai-whisper" } },
+    });
+    expect(result.services.stt.provider).toBe("openai-whisper");
+    expect(result.services.stt.mode).toBe("your-own");
+  });
+
+  test("accepts valid services.stt.providers.openai-whisper overrides", () => {
+    const result = AssistantConfigSchema.parse({
+      services: {
+        stt: {
+          provider: "openai-whisper",
+          providers: {
+            "openai-whisper": {},
+          },
+        },
+      },
+    });
+    expect(result.services.stt.providers["openai-whisper"]).toEqual({});
+  });
+
+  test("parses when providers map is empty (sparse default)", () => {
+    const result = AssistantConfigSchema.parse({
+      services: { stt: { provider: "deepgram", providers: {} } },
+    });
+    expect(result.services.stt.providers).toEqual({});
+    expect(result.services.stt.provider).toBe("deepgram");
+  });
+
+  test("parses when unknown future provider blobs exist under providers", () => {
+    const result = AssistantConfigSchema.parse({
+      services: {
+        stt: {
+          provider: "openai-whisper",
+          providers: {
+            "openai-whisper": {},
+            "future-provider": { model: "next-gen", lang: "en" },
+          },
+        },
+      },
+    });
+    expect(result.services.stt.providers["openai-whisper"]).toEqual({});
+    expect(result.services.stt.providers["future-provider"]).toEqual({
+      model: "next-gen",
+      lang: "en",
+    });
+  });
+
+  test("rejects services.stt.mode = managed", () => {
+    const result = AssistantConfigSchema.safeParse({
+      services: { stt: { mode: "managed" } },
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      const msgs = result.error.issues.map((i) => i.message);
+      expect(
+        msgs.some((m) => m.includes("your-own") || m.includes("managed")),
+      ).toBe(true);
+    }
+  });
+
+  test("rejects invalid services.stt.provider", () => {
+    const result = AssistantConfigSchema.safeParse({
+      services: { stt: { provider: "azure-speech" } },
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      const msgs = result.error.issues.map((i) => i.message);
+      expect(msgs.some((m) => m.includes("services.stt.provider"))).toBe(true);
+    }
+  });
+
+  test("accepts deepgram as services.stt.provider", () => {
+    const result = AssistantConfigSchema.parse({
+      services: { stt: { provider: "deepgram" } },
+    });
+    expect(result.services.stt.provider).toBe("deepgram");
+    expect(result.services.stt.mode).toBe("your-own");
+  });
+
+  test("accepts google-gemini as services.stt.provider", () => {
+    const result = AssistantConfigSchema.parse({
+      services: { stt: { provider: "google-gemini" } },
+    });
+    expect(result.services.stt.provider).toBe("google-gemini");
+    expect(result.services.stt.mode).toBe("your-own");
+  });
+
+  test("applies services.stt structural defaults when google-gemini provider is explicit", () => {
+    const result = AssistantConfigSchema.parse({
+      services: { stt: { provider: "google-gemini" } },
+    });
+    expect(result.services.stt.mode).toBe("your-own");
+    expect(result.services.stt.provider).toBe("google-gemini");
+    expect(result.services.stt.providers).toEqual({});
+  });
+
+  test("accepts valid services.stt.providers.deepgram overrides", () => {
+    const result = AssistantConfigSchema.parse({
+      services: {
+        stt: {
+          provider: "deepgram",
+          providers: {
+            deepgram: {},
+          },
+        },
+      },
+    });
+    expect(result.services.stt.providers.deepgram).toEqual({});
+  });
+
+  test("existing configs with explicit per-provider objects continue to parse", () => {
+    // Configs with explicit per-provider objects must continue to
+    // parse and round-trip successfully.
+    const result = AssistantConfigSchema.parse({
+      services: {
+        stt: {
+          provider: "openai-whisper",
+          providers: {
+            "openai-whisper": {},
+            deepgram: {},
+          },
+        },
+      },
+    });
+    expect(result.services.stt.providers["openai-whisper"]).toEqual({});
+    expect(result.services.stt.providers.deepgram).toEqual({});
+  });
+
+  test("services.stt.provider is required (no implicit default)", () => {
+    const result = AssistantConfigSchema.safeParse({
+      services: { stt: {} },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("services.stt.mode only accepts your-own as literal", () => {
+    // Explicit your-own should work
+    const valid = SttServiceSchema.safeParse({
+      mode: "your-own",
+      provider: "openai-whisper",
+    });
+    expect(valid.success).toBe(true);
+
+    // managed should be rejected
+    const invalid = SttServiceSchema.safeParse({
+      mode: "managed",
+      provider: "openai-whisper",
+    });
+    expect(invalid.success).toBe(false);
+
+    // Any other string should be rejected
+    const invalid2 = SttServiceSchema.safeParse({
+      mode: "self-hosted",
+      provider: "openai-whisper",
+    });
+    expect(invalid2.success).toBe(false);
+  });
+
+  test("rejects hostBrowser.cdpInspect.desktopAuto.cooldownMs above 300000", () => {
+    const result = AssistantConfigSchema.safeParse({
+      hostBrowser: {
+        cdpInspect: { desktopAuto: { cooldownMs: 500_000 } },
+      },
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(
+        result.error.issues.some((issue) =>
+          issue.path.join(".").includes("cooldownMs"),
+        ),
+      ).toBe(true);
+    }
+  });
+
+  test("rejects non-integer hostBrowser.cdpInspect.desktopAuto.cooldownMs", () => {
+    const result = AssistantConfigSchema.safeParse({
+      hostBrowser: {
+        cdpInspect: { desktopAuto: { cooldownMs: 5000.5 } },
+      },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects non-boolean hostBrowser.cdpInspect.desktopAuto.enabled", () => {
+    const result = AssistantConfigSchema.safeParse({
+      hostBrowser: {
+        cdpInspect: { desktopAuto: { enabled: "yes" } },
+      },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("desktopAuto defaults preserved when only cdpInspect.enabled is set", () => {
+    const result = AssistantConfigSchema.parse({
+      hostBrowser: { cdpInspect: { enabled: true } },
+    });
+    expect(result.hostBrowser.cdpInspect.desktopAuto).toEqual({
+      enabled: true,
+      cooldownMs: 30_000,
+    });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: Voice quality profile resolver
+// ---------------------------------------------------------------------------
+
+describe("resolveVoiceQualityProfile", () => {
+  test("always returns ElevenLabs ttsProvider", () => {
+    const config = AssistantConfigSchema.parse({});
+    const profile = resolveVoiceQualityProfile(config);
+    expect(profile.ttsProvider).toBe("ElevenLabs");
+  });
+
+  test("uses services.tts.providers.elevenlabs.voiceId for voice", () => {
+    const config = AssistantConfigSchema.parse({
+      services: {
+        tts: {
+          providers: { elevenlabs: { voiceId: "test-voice-id" } },
+        },
+      },
+    });
+    const profile = resolveVoiceQualityProfile(config);
+    expect(profile.ttsProvider).toBe("ElevenLabs");
+    expect(profile.voice).toBe("test-voice-id");
+  });
+
+  test("defaults to Amelia voice ID when elevenlabs.voiceId is not set", () => {
+    const config = AssistantConfigSchema.parse({});
+    const profile = resolveVoiceQualityProfile(config);
+    expect(profile.voice).toBe(DEFAULT_ELEVENLABS_VOICE_ID);
+  });
+
+  test("applies voice tuning params from services.tts.providers.elevenlabs config", () => {
+    const config = AssistantConfigSchema.parse({
+      services: {
+        tts: {
+          providers: {
+            elevenlabs: {
+              voiceId: "abc123",
+              voiceModelId: "turbo_v2_5",
+              speed: 0.9,
+              stability: 0.8,
+              similarityBoost: 0.9,
+            },
+          },
+        },
+      },
+    });
+    const profile = resolveVoiceQualityProfile(config);
+    expect(profile.voice).toBe("abc123-turbo_v2_5-0.9_0.8_0.9");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: buildElevenLabsVoiceSpec
+// ---------------------------------------------------------------------------
+
+describe("buildElevenLabsVoiceSpec", () => {
+  test("produces Twilio-compliant voice string: voiceId-model-speed_stability_similarity", () => {
+    const spec = buildElevenLabsVoiceSpec({
+      voiceId: "abc123",
+      voiceModelId: "turbo_v2_5",
+      speed: 1.0,
+      stability: 0.5,
+      similarityBoost: 0.75,
+    });
+    expect(spec).toBe("abc123-turbo_v2_5-1_0.5_0.75");
+  });
+
+  test("returns empty string when voiceId is empty", () => {
+    const spec = buildElevenLabsVoiceSpec({
       voiceId: "",
       voiceModelId: "turbo_v2_5",
       speed: 1.0,
@@ -1042,13 +1788,424 @@ describe("buildElevenLabsVoiceSpec", () => {
 
   test("default config uses a bare voiceId when no model override is set", () => {
     const config = AssistantConfigSchema.parse({
-      elevenlabs: { voiceId: "test" },
+      services: {
+        tts: {
+          providers: { elevenlabs: { voiceId: "test" } },
+        },
+      },
     });
-    const spec = buildElevenLabsVoiceSpec(config.elevenlabs);
+    const spec = buildElevenLabsVoiceSpec(
+      config.services.tts.providers.elevenlabs,
+    );
     expect(spec).toBe("test");
   });
 });
 
+// ---------------------------------------------------------------------------
+// Tests: TTS config resolver
+// ---------------------------------------------------------------------------
+
+describe("resolveTtsConfig", () => {
+  test("returns default provider and config from empty config", () => {
+    const config = AssistantConfigSchema.parse({});
+    const resolved = resolveTtsConfig(config);
+    expect(resolved.provider).toBe("elevenlabs");
+    expect(resolved.providerConfig).toMatchObject({
+      voiceId: DEFAULT_ELEVENLABS_VOICE_ID,
+      speed: 1.0,
+      stability: 0.5,
+      similarityBoost: 0.75,
+    });
+  });
+
+  test("uses canonical services.tts.provider when set", () => {
+    const config = AssistantConfigSchema.parse({
+      services: { tts: { provider: "fish-audio" } },
+    });
+    const resolved = resolveTtsConfig(config);
+    expect(resolved.provider).toBe("fish-audio");
+    expect(resolved.providerConfig).toMatchObject({
+      referenceId: "",
+      chunkLength: 200,
+      format: "mp3",
+      speed: 1.0,
+    });
+  });
+
+  test("returns canonical elevenlabs config from services.tts.providers", () => {
+    const config = AssistantConfigSchema.parse({
+      services: {
+        tts: {
+          provider: "elevenlabs",
+          providers: {
+            elevenlabs: { voiceId: "canonical-voice", stability: 0.9 },
+          },
+        },
+      },
+    });
+    const resolved = resolveTtsConfig(config);
+    expect(resolved.provider).toBe("elevenlabs");
+    expect(resolved.providerConfig).toMatchObject({
+      voiceId: "canonical-voice",
+      stability: 0.9,
+    });
+  });
+
+  test("uses canonical elevenlabs config exclusively (no legacy fallback)", () => {
+    const config = AssistantConfigSchema.parse({
+      services: {
+        tts: {
+          providers: {
+            elevenlabs: { voiceId: "canonical-voice", speed: 0.9 },
+          },
+        },
+      },
+    });
+    const resolved = resolveTtsConfig(config);
+    expect(resolved.provider).toBe("elevenlabs");
+    expect(resolved.providerConfig).toMatchObject({
+      voiceId: "canonical-voice",
+      speed: 0.9,
+    });
+  });
+
+  test("uses canonical fish-audio config exclusively (no legacy fallback)", () => {
+    const config = AssistantConfigSchema.parse({
+      services: {
+        tts: {
+          provider: "fish-audio",
+          providers: {
+            "fish-audio": { referenceId: "canonical-ref", format: "wav" },
+          },
+        },
+      },
+    });
+    const resolved = resolveTtsConfig(config);
+    expect(resolved.provider).toBe("fish-audio");
+    expect(resolved.providerConfig).toMatchObject({
+      referenceId: "canonical-ref",
+      format: "wav",
+    });
+  });
+
+  test("returns empty config for unknown provider", () => {
+    // Force an unknown provider via type assertion for coverage.
+    // structuredClone prevents mutation from leaking into Zod's shared
+    // default objects (Zod 4 stores defaults by reference).
+    const config = structuredClone(
+      AssistantConfigSchema.parse({}),
+    ) as AssistantConfig;
+    (config.services.tts as { provider: string }).provider = "aws-polly";
+    const resolved = resolveTtsConfig(config);
+    expect(resolved.provider).toBe("aws-polly");
+    expect(resolved.providerConfig).toEqual({});
+  });
+
+  test("unknown provider resolution is deterministic across repeated calls", () => {
+    const config = structuredClone(
+      AssistantConfigSchema.parse({}),
+    ) as AssistantConfig;
+    (config.services.tts as { provider: string }).provider = "nonexistent";
+    const first = resolveTtsConfig(config);
+    const second = resolveTtsConfig(config);
+    expect(first).toEqual(second);
+    expect(first.providerConfig).toEqual({});
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: TTS provider catalog integration
+// ---------------------------------------------------------------------------
+
+describe("TTS provider catalog integration", () => {
+  test("VALID_TTS_SERVICE_PROVIDERS matches catalog provider IDs", () => {
+    const catalogIds = listCatalogProviderIds();
+    expect([...VALID_TTS_SERVICE_PROVIDERS]).toEqual(catalogIds);
+  });
+
+  test("schema accepts all catalog provider IDs as services.tts.provider", () => {
+    for (const providerId of listCatalogProviderIds()) {
+      const result = AssistantConfigSchema.safeParse({
+        services: { tts: { provider: providerId } },
+      });
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.services.tts.provider).toBe(providerId);
+      }
+    }
+  });
+
+  test("TtsProvidersSchema has a key for every catalog provider", () => {
+    const parsed = AssistantConfigSchema.parse({});
+    const providerKeys = Object.keys(parsed.services.tts.providers);
+    for (const providerId of listCatalogProviderIds()) {
+      expect(providerKeys).toContain(providerId);
+    }
+  });
+
+  test("resolveTtsConfig returns correct defaults for each catalog provider", () => {
+    for (const providerId of listCatalogProviderIds()) {
+      const config = AssistantConfigSchema.parse({
+        services: { tts: { provider: providerId } },
+      });
+      const resolved = resolveTtsConfig(config);
+      expect(resolved.provider).toBe(providerId);
+      // Every catalog provider should resolve to a non-empty config object
+      expect(Object.keys(resolved.providerConfig).length).toBeGreaterThan(0);
+    }
+  });
+
+  test("resolveTtsConfig returns overridden values for elevenlabs", () => {
+    const config = AssistantConfigSchema.parse({
+      services: {
+        tts: {
+          provider: "elevenlabs",
+          providers: {
+            elevenlabs: { voiceId: "override-voice", speed: 0.7 },
+          },
+        },
+      },
+    });
+    const resolved = resolveTtsConfig(config);
+    expect(resolved.provider).toBe("elevenlabs");
+    expect(resolved.providerConfig).toMatchObject({
+      voiceId: "override-voice",
+      speed: 0.7,
+      // Defaults still present for unset fields
+      stability: 0.5,
+      similarityBoost: 0.75,
+    });
+  });
+
+  test("resolveTtsConfig returns overridden values for fish-audio", () => {
+    const config = AssistantConfigSchema.parse({
+      services: {
+        tts: {
+          provider: "fish-audio",
+          providers: {
+            "fish-audio": {
+              referenceId: "override-ref",
+              format: "opus",
+              speed: 1.5,
+            },
+          },
+        },
+      },
+    });
+    const resolved = resolveTtsConfig(config);
+    expect(resolved.provider).toBe("fish-audio");
+    expect(resolved.providerConfig).toMatchObject({
+      referenceId: "override-ref",
+      format: "opus",
+      speed: 1.5,
+      // Defaults for unset fields
+      chunkLength: 200,
+    });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: TTS migration 032
+// ---------------------------------------------------------------------------
+
+describe("032-tts-provider-unification migration", () => {
+  const migrationDir = join(WORKSPACE_DIR, "_mig032");
+
+  beforeEach(() => {
+    if (existsSync(migrationDir)) {
+      rmSync(migrationDir, { recursive: true, force: true });
+    }
+    mkdirSync(migrationDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(migrationDir)) {
+      rmSync(migrationDir, { recursive: true, force: true });
+    }
+  });
+
+  function writeMigConfig(obj: unknown): void {
+    writeFileSync(
+      join(migrationDir, "config.json"),
+      JSON.stringify(obj, null, 2),
+    );
+  }
+
+  function readMigConfig(): Record<string, unknown> {
+    return JSON.parse(
+      readFileSync(join(migrationDir, "config.json"), "utf-8"),
+    ) as Record<string, unknown>;
+  }
+
+  test("backfills provider from calls.voice.ttsProvider", async () => {
+    writeMigConfig({
+      calls: { voice: { ttsProvider: "fish-audio" } },
+    });
+    const { ttsProviderUnificationMigration } =
+      await import("../workspace/migrations/032-tts-provider-unification.js");
+    await ttsProviderUnificationMigration.run(migrationDir);
+    const result = readMigConfig();
+    const tts = (result.services as Record<string, unknown>).tts as Record<
+      string,
+      unknown
+    >;
+    expect(tts.provider).toBe("fish-audio");
+    expect(tts.mode).toBe("your-own");
+  });
+
+  test("backfills elevenlabs provider config from legacy keys", async () => {
+    writeMigConfig({
+      calls: { voice: { ttsProvider: "elevenlabs" } },
+      elevenlabs: { voiceId: "my-voice", speed: 0.8 },
+    });
+    const { ttsProviderUnificationMigration } =
+      await import("../workspace/migrations/032-tts-provider-unification.js");
+    await ttsProviderUnificationMigration.run(migrationDir);
+    const result = readMigConfig();
+    const tts = (result.services as Record<string, unknown>).tts as Record<
+      string,
+      unknown
+    >;
+    const providers = tts.providers as Record<string, Record<string, unknown>>;
+    expect(providers.elevenlabs.voiceId).toBe("my-voice");
+    expect(providers.elevenlabs.speed).toBe(0.8);
+  });
+
+  test("backfills fish-audio provider config from legacy keys", async () => {
+    writeMigConfig({
+      calls: { voice: { ttsProvider: "fish-audio" } },
+      fishAudio: { referenceId: "my-ref", format: "wav" },
+    });
+    const { ttsProviderUnificationMigration } =
+      await import("../workspace/migrations/032-tts-provider-unification.js");
+    await ttsProviderUnificationMigration.run(migrationDir);
+    const result = readMigConfig();
+    const tts = (result.services as Record<string, unknown>).tts as Record<
+      string,
+      unknown
+    >;
+    const providers = tts.providers as Record<string, Record<string, unknown>>;
+    expect(providers["fish-audio"].referenceId).toBe("my-ref");
+    expect(providers["fish-audio"].format).toBe("wav");
+  });
+
+  test("removes legacy fields after migration", async () => {
+    writeMigConfig({
+      calls: { voice: { ttsProvider: "elevenlabs", language: "en-US" } },
+      elevenlabs: { voiceId: "my-voice" },
+    });
+    const { ttsProviderUnificationMigration } =
+      await import("../workspace/migrations/032-tts-provider-unification.js");
+    await ttsProviderUnificationMigration.run(migrationDir);
+    const result = readMigConfig();
+    // Legacy keys removed
+    expect(
+      (
+        (result.calls as Record<string, unknown>).voice as Record<
+          string,
+          unknown
+        >
+      ).ttsProvider,
+    ).toBeUndefined();
+    expect(result.elevenlabs).toBeUndefined();
+    // Other voice fields preserved
+    expect(
+      (
+        (result.calls as Record<string, unknown>).voice as Record<
+          string,
+          unknown
+        >
+      ).language,
+    ).toBe("en-US");
+  });
+
+  test("is idempotent — repeated runs produce no changes", async () => {
+    writeMigConfig({
+      calls: { voice: { ttsProvider: "fish-audio" } },
+      fishAudio: { referenceId: "my-ref" },
+    });
+    const { ttsProviderUnificationMigration } =
+      await import("../workspace/migrations/032-tts-provider-unification.js");
+    await ttsProviderUnificationMigration.run(migrationDir);
+    const afterFirst = readMigConfig();
+    await ttsProviderUnificationMigration.run(migrationDir);
+    const afterSecond = readMigConfig();
+    expect(afterSecond).toEqual(afterFirst);
+  });
+
+  test("does not overwrite existing services.tts.provider", async () => {
+    writeMigConfig({
+      services: { tts: { provider: "elevenlabs" } },
+      calls: { voice: { ttsProvider: "fish-audio" } },
+    });
+    const { ttsProviderUnificationMigration } =
+      await import("../workspace/migrations/032-tts-provider-unification.js");
+    await ttsProviderUnificationMigration.run(migrationDir);
+    const result = readMigConfig();
+    const tts = (result.services as Record<string, unknown>).tts as Record<
+      string,
+      unknown
+    >;
+    // Should keep the existing canonical value, not the legacy one
+    expect(tts.provider).toBe("elevenlabs");
+  });
+
+  test("does not overwrite existing canonical provider config keys", async () => {
+    writeMigConfig({
+      services: {
+        tts: {
+          providers: {
+            elevenlabs: { voiceId: "canonical-voice" },
+          },
+        },
+      },
+      elevenlabs: { voiceId: "legacy-voice", speed: 0.8 },
+    });
+    const { ttsProviderUnificationMigration } =
+      await import("../workspace/migrations/032-tts-provider-unification.js");
+    await ttsProviderUnificationMigration.run(migrationDir);
+    const result = readMigConfig();
+    const tts = (result.services as Record<string, unknown>).tts as Record<
+      string,
+      unknown
+    >;
+    const providers = tts.providers as Record<string, Record<string, unknown>>;
+    // Canonical voiceId preserved, legacy speed backfilled
+    expect(providers.elevenlabs.voiceId).toBe("canonical-voice");
+    expect(providers.elevenlabs.speed).toBe(0.8);
+    // Legacy top-level key removed
+    expect(result.elevenlabs).toBeUndefined();
+  });
+
+  test("skips config without any legacy TTS fields", async () => {
+    writeMigConfig({ maxTokens: 4096 });
+    const { ttsProviderUnificationMigration } =
+      await import("../workspace/migrations/032-tts-provider-unification.js");
+    const before = readMigConfig();
+    await ttsProviderUnificationMigration.run(migrationDir);
+    const after = readMigConfig();
+    // Should remain unchanged (no services.tts added)
+    expect(after).toEqual(before);
+  });
+
+  test("down removes services.tts from config", async () => {
+    writeMigConfig({
+      services: {
+        inference: { provider: "anthropic" },
+        tts: { provider: "elevenlabs", mode: "your-own" },
+      },
+    });
+    const { ttsProviderUnificationMigration } =
+      await import("../workspace/migrations/032-tts-provider-unification.js");
+    await ttsProviderUnificationMigration.down(migrationDir);
+    const result = readMigConfig();
+    const services = result.services as Record<string, unknown>;
+    expect(services.tts).toBeUndefined();
+    // Other services keys preserved
+    expect(services.inference).toBeDefined();
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Tests: loader integration (config file -> loadConfig with fallback)
 // ---------------------------------------------------------------------------
@@ -1083,28 +2240,27 @@ describe("loadConfig with schema validation", () => {
   // intermittently trigger unhandled ENOENT in CI if the directory is removed.
   test("loads valid config", () => {
     writeConfig({
-      services: {
-        inference: { provider: "openai", model: "gpt-4" },
+      llm: {
+        default: { provider: "openai", model: "gpt-4", maxTokens: 4096 },
       },
-      maxTokens: 4096,
     });
     const config = loadConfig();
-    expect(config.services.inference.provider).toBe("openai");
-    expect(config.services.inference.model).toBe("gpt-4");
-    expect(config.maxTokens).toBe(4096);
+    expect(config.llm.default.provider).toBe("openai");
+    expect(config.llm.default.model).toBe("gpt-4");
+    expect(config.llm.default.maxTokens).toBe(4096);
   });
 
   test("applies defaults for missing fields", () => {
     writeConfig({});
     const config = loadConfig();
-    expect(config.services.inference.provider).toBe("anthropic");
-    expect(config.services.inference.model).toBe("claude-opus-4-6");
-    expect(config.maxTokens).toBe(64000);
-    expect(config.thinking).toEqual({
+    expect(config.llm.default.provider).toBe("anthropic");
+    expect(config.llm.default.model).toBe("claude-opus-4-7");
+    expect(config.llm.default.maxTokens).toBe(64000);
+    expect(config.llm.default.thinking).toEqual({
       enabled: true,
       streamThinking: true,
     });
-    expect(config.contextWindow).toEqual({
+    expect(config.llm.default.contextWindow).toEqual({
       enabled: true,
       maxInputTokens: 200000,
       targetBudgetRatio: 0.3,
@@ -1122,16 +2278,16 @@ describe("loadConfig with schema validation", () => {
 
   test("falls back to default for invalid provider", () => {
     writeConfig({
-      services: { inference: { provider: "invalid-provider" } },
+      llm: { default: { provider: "invalid-provider" } },
     });
     const config = loadConfig();
-    expect(config.services.inference.provider).toBe("anthropic");
+    expect(config.llm.default.provider).toBe("anthropic");
   });
 
   test("falls back to default for invalid maxTokens", () => {
-    writeConfig({ maxTokens: -100 });
+    writeConfig({ llm: { default: { maxTokens: -100 } } });
     const config = loadConfig();
-    expect(config.maxTokens).toBe(64000);
+    expect(config.llm.default.maxTokens).toBe(64000);
   });
 
   test("falls back to defaults for invalid nested values", () => {
@@ -1146,23 +2302,26 @@ describe("loadConfig with schema validation", () => {
 
   test("preserves valid fields when other fields are invalid", () => {
     writeConfig({
-      services: {
-        inference: { provider: "openai", model: "gpt-4" },
+      llm: {
+        default: {
+          provider: "openai",
+          model: "gpt-4",
+          maxTokens: -1,
+          thinking: { enabled: true },
+        },
       },
-      maxTokens: -1,
-      thinking: { enabled: true },
     });
     const config = loadConfig();
-    expect(config.services.inference.provider).toBe("openai");
-    expect(config.services.inference.model).toBe("gpt-4");
-    expect(config.thinking.enabled).toBe(true);
-    expect(config.maxTokens).toBe(64000);
+    expect(config.llm.default.provider).toBe("openai");
+    expect(config.llm.default.model).toBe("gpt-4");
+    expect(config.llm.default.thinking.enabled).toBe(true);
+    expect(config.llm.default.maxTokens).toBe(64000);
   });
 
   test("handles no config file", () => {
     const config = loadConfig();
-    expect(config.services.inference.provider).toBe("anthropic");
-    expect(config.maxTokens).toBe(64000);
+    expect(config.llm.default.provider).toBe("anthropic");
+    expect(config.llm.default.maxTokens).toBe(64000);
   });
 
   test("partial nested objects get defaults for missing fields", () => {
@@ -1183,11 +2342,15 @@ describe("loadConfig with schema validation", () => {
 
   test("falls back for invalid contextWindow relationship", () => {
     writeConfig({
-      contextWindow: { targetBudgetRatio: 0.8, compactThreshold: 0.8 },
+      llm: {
+        default: {
+          contextWindow: { targetBudgetRatio: 0.8, compactThreshold: 0.8 },
+        },
+      },
     });
     const config = loadConfig();
-    expect(config.contextWindow.targetBudgetRatio).toBe(0.3);
-    expect(config.contextWindow.compactThreshold).toBe(0.8);
+    expect(config.llm.default.contextWindow.targetBudgetRatio).toBe(0.3);
+    expect(config.llm.default.contextWindow.compactThreshold).toBe(0.8);
   });
 
   test("falls back for invalid rateLimit values", () => {
@@ -1210,6 +2373,11 @@ describe("loadConfig with schema validation", () => {
     expect(config.permissions).toEqual({
       mode: "workspace",
       hostAccess: false,
+      autoApproveUpTo: {
+        conversation: "low",
+        background: "medium",
+        headless: "none",
+      },
     });
   });
 
@@ -1244,6 +2412,93 @@ describe("loadConfig with schema validation", () => {
     expect(config.calls.provider).toBe("twilio");
   });
 
+  test("recovers from partial filing.activeHours without wiping unrelated fields", () => {
+    // Only activeHoursStart is set. The superRefine must emit the issue so
+    // the loader's delete-and-retry can strip the set field; otherwise the
+    // mismatch persists and the config falls back to full defaults (which
+    // would reset llm.default.maxTokens below to 64000).
+    writeConfig({
+      llm: { default: { maxTokens: 4096 } },
+      filing: { activeHoursStart: 8 },
+    });
+    const config = loadConfig();
+    expect(config.llm.default.maxTokens).toBe(4096);
+    expect(config.filing.activeHoursStart).toBeNull();
+    expect(config.filing.activeHoursEnd).toBeNull();
+  });
+
+  test("recovers from partial heartbeat.activeHours without wiping unrelated fields", () => {
+    // activeHoursStart is explicitly nulled while activeHoursEnd defaults to
+    // 22 — a mismatch. Dual-emit strips both sides; both defaults restore
+    // (8, 22). llm.default.maxTokens is unaffected.
+    writeConfig({
+      llm: { default: { maxTokens: 4096 } },
+      heartbeat: { activeHoursStart: null },
+    });
+    const config = loadConfig();
+    expect(config.llm.default.maxTokens).toBe(4096);
+    expect(config.heartbeat.activeHoursStart).toBe(8);
+    expect(config.heartbeat.activeHoursEnd).toBe(22);
+  });
+
+  test("recovers from heartbeat.activeHours null-mismatch where explicit value equals opposite default", () => {
+    // { start: null, end: 8 } — single-emit on the null side would strip
+    // start, the default 8 would restore it, and the equal-hours check would
+    // fire, cascading to a full defaults reset that wipes llm.default.maxTokens.
+    // Dual-emit strips both sides in one pass.
+    writeConfig({
+      llm: { default: { maxTokens: 4096 } },
+      heartbeat: { activeHoursStart: null, activeHoursEnd: 8 },
+    });
+    const config = loadConfig();
+    expect(config.llm.default.maxTokens).toBe(4096);
+    expect(config.heartbeat.activeHoursStart).toBe(8);
+    expect(config.heartbeat.activeHoursEnd).toBe(22);
+  });
+
+  test("recovers from heartbeat.activeHours null-mismatch on the end side", () => {
+    // { start: 22, end: null } — same cascade class as above, mirrored.
+    writeConfig({
+      llm: { default: { maxTokens: 4096 } },
+      heartbeat: { activeHoursStart: 22, activeHoursEnd: null },
+    });
+    const config = loadConfig();
+    expect(config.llm.default.maxTokens).toBe(4096);
+    expect(config.heartbeat.activeHoursStart).toBe(8);
+    expect(config.heartbeat.activeHoursEnd).toBe(22);
+  });
+
+  test("recovers from equal heartbeat.activeHours without wiping unrelated fields", () => {
+    // { start: 22, end: 22 } — both equal to the default for end. Single-emit
+    // on one path would strip one side, the default would recreate the
+    // equal-hours mismatch, and the loader would fall back to full defaults,
+    // wiping llm.default.maxTokens. Dual-emit strips both sides at once.
+    writeConfig({
+      llm: { default: { maxTokens: 4096 } },
+      heartbeat: { activeHoursStart: 22, activeHoursEnd: 22 },
+    });
+    const config = loadConfig();
+    expect(config.llm.default.maxTokens).toBe(4096);
+    expect(config.heartbeat.activeHoursStart).toBe(8);
+    expect(config.heartbeat.activeHoursEnd).toBe(22);
+  });
+
+  test("recovers from equal filing.activeHours without wiping unrelated fields", () => {
+    // activeHoursStart === activeHoursEnd is invalid (empty window). Filing's
+    // defaults are null/null, so single-emit on one path would strip one side
+    // and the null default would recreate a mismatch — cascading to a full
+    // defaults reset that wipes llm.default.maxTokens. Dual-emit strips both
+    // sides so both defaults restore to null.
+    writeConfig({
+      llm: { default: { maxTokens: 1234 } },
+      filing: { activeHoursStart: 5, activeHoursEnd: 5 },
+    });
+    const config = loadConfig();
+    expect(config.llm.default.maxTokens).toBe(1234);
+    expect(config.filing.activeHoursStart).toBeNull();
+    expect(config.filing.activeHoursEnd).toBeNull();
+  });
+
   test("applies calls defaults when not specified", () => {
     writeConfig({});
     const config = loadConfig();
@@ -1253,8 +2508,13 @@ describe("loadConfig with schema validation", () => {
     expect(config.calls.disclosure.enabled).toBe(true);
     expect(config.calls.safety.denyCategories).toEqual([]);
     expect(config.calls.voice.language).toBe("en-US");
-    expect(config.calls.voice.transcriptionProvider).toBe("Deepgram");
-    expect(config.calls.model).toBeUndefined();
+    expect(
+      (config.calls.voice as Record<string, unknown>).transcriptionProvider,
+    ).toBeUndefined();
+    expect(
+      (config.calls.voice as Record<string, unknown>).ttsProvider,
+    ).toBeUndefined();
+    expect((config.calls as Record<string, unknown>).model).toBeUndefined();
     expect(config.calls.callerIdentity).toEqual({
       allowPerCallOverride: true,
     });