@vellumai/assistant 0.6.2 → 0.6.4

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
@@ -81,7 +93,7 @@ describe("AssistantConfigSchema", () => {
       "inference-provider-native",
     );
     expect(result.services["web-search"].mode).toBe("your-own");
-    expect(result.maxTokens).toBe(16000);
+    expect(result.maxTokens).toBe(64000);
     expect(result.thinking).toEqual({
       enabled: true,
       streamThinking: true,
@@ -107,9 +119,6 @@ describe("AssistantConfigSchema", () => {
       toolExecutionTimeoutSec: 120,
       providerStreamTimeoutSec: 1800,
     });
-    expect(result.sandbox).toEqual({
-      enabled: false,
-    });
     expect(result.rateLimit).toEqual({
       maxRequestsPerMinute: 0,
     });
@@ -169,7 +178,7 @@ describe("AssistantConfigSchema", () => {
       enqueueIntervalMs: 6 * 60 * 60 * 1000,
       supersededItemRetentionMs: 30 * 24 * 60 * 60 * 1000,
       conversationRetentionDays: 0,
-      llmRequestLogRetentionMs: 7 * 24 * 60 * 60 * 1000,
+      llmRequestLogRetentionMs: 1 * 60 * 60 * 1000,
     });
   });
 
@@ -180,6 +189,63 @@ 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" } },
@@ -400,29 +466,10 @@ describe("AssistantConfigSchema", () => {
     }
   });
 
-  test("sandbox with only enabled still parses", () => {
-    const result = AssistantConfigSchema.parse({ sandbox: { enabled: false } });
-    expect(result.sandbox.enabled).toBe(false);
-  });
-
-  test("rejects unknown sandbox fields", () => {
-    const result = AssistantConfigSchema.safeParse({
-      sandbox: { backend: "docker" },
-    });
-    // Unknown keys are stripped by Zod passthrough/strip, so parse should still succeed
-    // but the unknown field should not appear in the output
-    if (result.success) {
-      expect(
-        (result.data.sandbox as Record<string, unknown>)["backend"],
-      ).toBeUndefined();
-    }
-  });
-
   test("defaults permissions.mode to workspace", () => {
     const result = AssistantConfigSchema.parse({});
     expect(result.permissions).toEqual({
       mode: "workspace",
-      askBeforeActing: true,
       hostAccess: false,
     });
   });
@@ -624,8 +671,6 @@ describe("AssistantConfigSchema", () => {
       },
       voice: {
         language: "en-US",
-        transcriptionProvider: "Deepgram",
-        ttsProvider: "elevenlabs",
         hints: [],
         interruptSensitivity: "low",
       },
@@ -733,29 +778,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", () => {
@@ -763,39 +787,20 @@ 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", () => {
@@ -861,169 +866,1116 @@ describe("AssistantConfigSchema", () => {
     });
     expect(result.calls.callerIdentity.allowPerCallOverride).toBe(true);
   });
-});
 
-// ---------------------------------------------------------------------------
-// Tests: Voice quality profile resolver
-// ---------------------------------------------------------------------------
+  // ── hostBrowser.cdpInspect 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 hostBrowser.cdpInspect defaults", () => {
+    const result = AssistantConfigSchema.parse({});
+    expect(result.hostBrowser).toEqual({
+      cdpInspect: {
+        enabled: false,
+        host: "localhost",
+        port: 9222,
+        probeTimeoutMs: 500,
+        desktopAuto: {
+          enabled: true,
+          cooldownMs: 30_000,
+        },
+      },
+    });
   });
 
-  test("uses shared elevenlabs.voiceId for voice", () => {
-    const config = AssistantConfigSchema.parse({
-      elevenlabs: { voiceId: "test-voice-id" },
+  test("accepts hostBrowser.cdpInspect enabled with custom host/port", () => {
+    const result = AssistantConfigSchema.parse({
+      hostBrowser: {
+        cdpInspect: {
+          enabled: true,
+          host: "127.0.0.1",
+          port: 9333,
+        },
+      },
     });
-    const profile = resolveVoiceQualityProfile(config);
-    expect(profile.ttsProvider).toBe("ElevenLabs");
-    expect(profile.voice).toBe("test-voice-id");
+    expect(result.hostBrowser.cdpInspect.enabled).toBe(true);
+    expect(result.hostBrowser.cdpInspect.host).toBe("127.0.0.1");
+    expect(result.hostBrowser.cdpInspect.port).toBe(9333);
+    // Unset field should still receive its default.
+    expect(result.hostBrowser.cdpInspect.probeTimeoutMs).toBe(500);
   });
 
-  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 hostBrowser.cdpInspect custom probeTimeoutMs", () => {
+    const result = AssistantConfigSchema.parse({
+      hostBrowser: { cdpInspect: { probeTimeoutMs: 1000 } },
+    });
+    expect(result.hostBrowser.cdpInspect.probeTimeoutMs).toBe(1000);
   });
 
-  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("rejects hostBrowser.cdpInspect.port below 1", () => {
+    const result = AssistantConfigSchema.safeParse({
+      hostBrowser: { cdpInspect: { port: 0 } },
     });
-    const profile = resolveVoiceQualityProfile(config);
-    expect(profile.voice).toBe("abc123-turbo_v2_5-0.9_0.8_0.9");
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(
+        result.error.issues.some((issue) =>
+          issue.path.join(".").includes("hostBrowser.cdpInspect.port"),
+        ),
+      ).toBe(true);
+    }
   });
-});
 
-// ---------------------------------------------------------------------------
-// Tests: buildElevenLabsVoiceSpec
-// ---------------------------------------------------------------------------
+  test("rejects hostBrowser.cdpInspect.port above 65535", () => {
+    const result = AssistantConfigSchema.safeParse({
+      hostBrowser: { cdpInspect: { port: 70000 } },
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(
+        result.error.issues.some((issue) =>
+          issue.path.join(".").includes("hostBrowser.cdpInspect.port"),
+        ),
+      ).toBe(true);
+    }
+  });
 
-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("rejects non-integer hostBrowser.cdpInspect.port", () => {
+    const result = AssistantConfigSchema.safeParse({
+      hostBrowser: { cdpInspect: { port: 9222.5 } },
     });
-    expect(spec).toBe("abc123-turbo_v2_5-1_0.5_0.75");
+    expect(result.success).toBe(false);
   });
 
-  test("returns empty string when voiceId is empty", () => {
-    const spec = buildElevenLabsVoiceSpec({
-      voiceId: "",
-      voiceModelId: "turbo_v2_5",
-      speed: 1.0,
-      stability: 0.5,
-      similarityBoost: 0.75,
+  test("rejects hostBrowser.cdpInspect.probeTimeoutMs below 50", () => {
+    const result = AssistantConfigSchema.safeParse({
+      hostBrowser: { cdpInspect: { probeTimeoutMs: 10 } },
     });
-    expect(spec).toBe("");
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(
+        result.error.issues.some((issue) =>
+          issue.path
+            .join(".")
+            .includes("hostBrowser.cdpInspect.probeTimeoutMs"),
+        ),
+      ).toBe(true);
+    }
   });
 
-  test("formats custom parameters correctly", () => {
-    const spec = buildElevenLabsVoiceSpec({
-      voiceId: "myVoice",
-      voiceModelId: "eleven_multilingual_v2",
-      speed: 0.9,
-      stability: 0.8,
-      similarityBoost: 0.9,
+  test("rejects hostBrowser.cdpInspect.probeTimeoutMs above 5000", () => {
+    const result = AssistantConfigSchema.safeParse({
+      hostBrowser: { cdpInspect: { probeTimeoutMs: 10000 } },
     });
-    expect(spec).toBe("myVoice-eleven_multilingual_v2-0.9_0.8_0.9");
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(
+        result.error.issues.some((issue) =>
+          issue.path
+            .join(".")
+            .includes("hostBrowser.cdpInspect.probeTimeoutMs"),
+        ),
+      ).toBe(true);
+    }
   });
 
-  test("default config uses a bare voiceId when no model override is set", () => {
-    const config = AssistantConfigSchema.parse({
-      elevenlabs: { voiceId: "test" },
+  test("rejects non-integer hostBrowser.cdpInspect.probeTimeoutMs", () => {
+    const result = AssistantConfigSchema.safeParse({
+      hostBrowser: { cdpInspect: { probeTimeoutMs: 500.5 } },
     });
-    const spec = buildElevenLabsVoiceSpec(config.elevenlabs);
-    expect(spec).toBe("test");
+    expect(result.success).toBe(false);
   });
-});
 
-// ---------------------------------------------------------------------------
-// Tests: loader integration (config file -> loadConfig with fallback)
-// ---------------------------------------------------------------------------
+  test("rejects non-boolean hostBrowser.cdpInspect.enabled", () => {
+    const result = AssistantConfigSchema.safeParse({
+      hostBrowser: { cdpInspect: { enabled: "yes" } },
+    });
+    expect(result.success).toBe(false);
+  });
 
-describe("loadConfig with schema validation", () => {
-  beforeEach(() => {
-    // Keep WORKSPACE_DIR and logs in place to avoid racing async logger stream init.
-    ensureTestDir();
-    const resetPaths = [
-      CONFIG_PATH,
-      join(WORKSPACE_DIR, "keys.enc"),
-      join(WORKSPACE_DIR, "data"),
-      join(WORKSPACE_DIR, "data", "memory"),
-    ];
-    for (const path of resetPaths) {
-      if (existsSync(path)) {
-        rmSync(path, { recursive: true, force: true });
-      }
-    }
-    ensureTestDir();
-    _setStorePath(join(WORKSPACE_DIR, "keys.enc"));
-    invalidateConfigCache();
+  // ── services.tts config ──────────────────────────────────────────────
+
+  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");
   });
 
-  afterEach(() => {
-    _setStorePath(null);
-    invalidateConfigCache();
+  test("accepts valid services.tts provider override", () => {
+    const result = AssistantConfigSchema.parse({
+      services: { tts: { provider: "fish-audio" } },
+    });
+    expect(result.services.tts.provider).toBe("fish-audio");
+    expect(result.services.tts.mode).toBe("your-own");
   });
 
-  // Intentionally do not remove WORKSPACE_DIR in afterAll.
-  // A late async logger flush may still target logs under this path and can
-  // intermittently trigger unhandled ENOENT in CI if the directory is removed.
-  test("loads valid config", () => {
-    writeConfig({
+  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("accepts valid services.tts.providers.elevenlabs overrides", () => {
+    const result = AssistantConfigSchema.parse({
       services: {
-        inference: { provider: "openai", model: "gpt-4" },
+        tts: {
+          providers: {
+            elevenlabs: { voiceId: "custom-voice", speed: 0.8 },
+          },
+        },
       },
-      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(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);
   });
 
-  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(16000);
-    expect(config.thinking).toEqual({
-      enabled: true,
-      streamThinking: true,
-    });
-    expect(config.contextWindow).toEqual({
-      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",
+  test("accepts valid services.tts.providers.fish-audio overrides", () => {
+    const result = AssistantConfigSchema.parse({
+      services: {
+        tts: {
+          providers: {
+            "fish-audio": { referenceId: "my-voice", format: "wav" },
+          },
+        },
       },
     });
+    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("falls back to default for invalid provider", () => {
+  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,
+      stability: 0.5,
+      similarityBoost: 0.75,
+    });
+    expect(spec).toBe("");
+  });
+
+  test("formats custom parameters correctly", () => {
+    const spec = buildElevenLabsVoiceSpec({
+      voiceId: "myVoice",
+      voiceModelId: "eleven_multilingual_v2",
+      speed: 0.9,
+      stability: 0.8,
+      similarityBoost: 0.9,
+    });
+    expect(spec).toBe("myVoice-eleven_multilingual_v2-0.9_0.8_0.9");
+  });
+
+  test("default config uses a bare voiceId when no model override is set", () => {
+    const config = AssistantConfigSchema.parse({
+      services: {
+        tts: {
+          providers: { elevenlabs: { voiceId: "test" } },
+        },
+      },
+    });
+    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)
+// ---------------------------------------------------------------------------
+
+describe("loadConfig with schema validation", () => {
+  beforeEach(() => {
+    // Keep WORKSPACE_DIR and logs in place to avoid racing async logger stream init.
+    ensureTestDir();
+    const resetPaths = [
+      CONFIG_PATH,
+      join(WORKSPACE_DIR, "keys.enc"),
+      join(WORKSPACE_DIR, "data"),
+      join(WORKSPACE_DIR, "data", "memory"),
+    ];
+    for (const path of resetPaths) {
+      if (existsSync(path)) {
+        rmSync(path, { recursive: true, force: true });
+      }
+    }
+    ensureTestDir();
+    _setStorePath(join(WORKSPACE_DIR, "keys.enc"));
+    invalidateConfigCache();
+  });
+
+  afterEach(() => {
+    _setStorePath(null);
+    invalidateConfigCache();
+  });
+
+  // Intentionally do not remove WORKSPACE_DIR in afterAll.
+  // A late async logger flush may still target logs under this path and can
+  // intermittently trigger unhandled ENOENT in CI if the directory is removed.
+  test("loads valid config", () => {
+    writeConfig({
+      services: {
+        inference: { provider: "openai", model: "gpt-4" },
+      },
+      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);
+  });
+
+  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({
+      enabled: true,
+      streamThinking: true,
+    });
+    expect(config.contextWindow).toEqual({
+      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",
+      },
+    });
+  });
+
+  test("falls back to default for invalid provider", () => {
     writeConfig({
       services: { inference: { provider: "invalid-provider" } },
     });
@@ -1034,7 +1986,7 @@ describe("loadConfig with schema validation", () => {
   test("falls back to default for invalid maxTokens", () => {
     writeConfig({ maxTokens: -100 });
     const config = loadConfig();
-    expect(config.maxTokens).toBe(16000);
+    expect(config.maxTokens).toBe(64000);
   });
 
   test("falls back to defaults for invalid nested values", () => {
@@ -1059,13 +2011,13 @@ describe("loadConfig with schema validation", () => {
     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(16000);
+    expect(config.maxTokens).toBe(64000);
   });
 
   test("handles no config file", () => {
     const config = loadConfig();
     expect(config.services.inference.provider).toBe("anthropic");
-    expect(config.maxTokens).toBe(16000);
+    expect(config.maxTokens).toBe(64000);
   });
 
   test("partial nested objects get defaults for missing fields", () => {
@@ -1084,25 +2036,6 @@ describe("loadConfig with schema validation", () => {
     expect(config.secretDetection.action).toBe("redact");
   });
 
-  test("falls back for invalid sandbox.enabled", () => {
-    writeConfig({ sandbox: { enabled: "yes" } });
-    const config = loadConfig();
-    expect(config.sandbox.enabled).toBe(false);
-  });
-
-  test("loads sandbox with only enabled field", () => {
-    writeConfig({ sandbox: { enabled: false } });
-    const config = loadConfig();
-    expect(config.sandbox.enabled).toBe(false);
-  });
-
-  test("strips unknown sandbox fields", () => {
-    writeConfig({ sandbox: { enabled: true, backend: "docker" } });
-    const config = loadConfig();
-    expect(config.sandbox.enabled).toBe(true);
-    expect("backend" in config.sandbox).toBe(false);
-  });
-
   test("falls back for invalid contextWindow relationship", () => {
     writeConfig({
       contextWindow: { targetBudgetRatio: 0.8, compactThreshold: 0.8 },
@@ -1131,7 +2064,6 @@ describe("loadConfig with schema validation", () => {
     const config = loadConfig();
     expect(config.permissions).toEqual({
       mode: "workspace",
-      askBeforeActing: true,
       hostAccess: false,
     });
   });
@@ -1167,6 +2099,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 maxTokens below to 64000).
+    writeConfig({
+      maxTokens: 4096,
+      filing: { activeHoursStart: 8 },
+    });
+    const config = loadConfig();
+    expect(config.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). maxTokens is unaffected.
+    writeConfig({
+      maxTokens: 4096,
+      heartbeat: { activeHoursStart: null },
+    });
+    const config = loadConfig();
+    expect(config.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 maxTokens.
+    // Dual-emit strips both sides in one pass.
+    writeConfig({
+      maxTokens: 4096,
+      heartbeat: { activeHoursStart: null, activeHoursEnd: 8 },
+    });
+    const config = loadConfig();
+    expect(config.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({
+      maxTokens: 4096,
+      heartbeat: { activeHoursStart: 22, activeHoursEnd: null },
+    });
+    const config = loadConfig();
+    expect(config.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 maxTokens. Dual-emit strips both sides at once.
+    writeConfig({
+      maxTokens: 4096,
+      heartbeat: { activeHoursStart: 22, activeHoursEnd: 22 },
+    });
+    const config = loadConfig();
+    expect(config.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 maxTokens. Dual-emit strips both sides so
+    // both defaults restore to null.
+    writeConfig({
+      maxTokens: 1234,
+      filing: { activeHoursStart: 5, activeHoursEnd: 5 },
+    });
+    const config = loadConfig();
+    expect(config.maxTokens).toBe(1234);
+    expect(config.filing.activeHoursStart).toBeNull();
+    expect(config.filing.activeHoursEnd).toBeNull();
+  });
+
   test("applies calls defaults when not specified", () => {
     writeConfig({});
     const config = loadConfig();
@@ -1176,7 +2195,12 @@ 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.voice as Record<string, unknown>).transcriptionProvider,
+    ).toBeUndefined();
+    expect(
+      (config.calls.voice as Record<string, unknown>).ttsProvider,
+    ).toBeUndefined();
     expect(config.calls.model).toBeUndefined();
     expect(config.calls.callerIdentity).toEqual({
       allowPerCallOverride: true,