@vellumai/assistant 0.6.3 → 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
@@ -166,7 +178,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,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" } },
@@ -602,8 +671,6 @@ describe("AssistantConfigSchema", () => {
       },
       voice: {
         language: "en-US",
-        transcriptionProvider: "Deepgram",
-        ttsProvider: "elevenlabs",
         hints: [],
         interruptSensitivity: "low",
       },
@@ -711,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", () => {
@@ -741,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", () => {
@@ -850,6 +877,10 @@ describe("AssistantConfigSchema", () => {
         host: "localhost",
         port: 9222,
         probeTimeoutMs: 500,
+        desktopAuto: {
+          enabled: true,
+          cooldownMs: 30_000,
+        },
       },
     });
   });
@@ -958,6 +989,410 @@ describe("AssistantConfigSchema", () => {
     });
     expect(result.success).toBe(false);
   });
+
+  // ── 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");
+  });
+
+  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");
+  });
+
+  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: {
+        tts: {
+          providers: {
+            elevenlabs: { voiceId: "custom-voice", speed: 0.8 },
+          },
+        },
+      },
+    });
+    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("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("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,
+    });
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -969,12 +1404,15 @@ describe("resolveVoiceQualityProfile", () => {
     const config = AssistantConfigSchema.parse({});
     const profile = resolveVoiceQualityProfile(config);
     expect(profile.ttsProvider).toBe("ElevenLabs");
-    expect(profile.transcriptionProvider).toBe("Deepgram");
   });
 
-  test("uses shared elevenlabs.voiceId for voice", () => {
+  test("uses services.tts.providers.elevenlabs.voiceId for voice", () => {
     const config = AssistantConfigSchema.parse({
-      elevenlabs: { voiceId: "test-voice-id" },
+      services: {
+        tts: {
+          providers: { elevenlabs: { voiceId: "test-voice-id" } },
+        },
+      },
     });
     const profile = resolveVoiceQualityProfile(config);
     expect(profile.ttsProvider).toBe("ElevenLabs");
@@ -987,14 +1425,20 @@ describe("resolveVoiceQualityProfile", () => {
     expect(profile.voice).toBe(DEFAULT_ELEVENLABS_VOICE_ID);
   });
 
-  test("applies voice tuning params from elevenlabs config", () => {
+  test("applies voice tuning params from services.tts.providers.elevenlabs config", () => {
     const config = AssistantConfigSchema.parse({
-      elevenlabs: {
-        voiceId: "abc123",
-        voiceModelId: "turbo_v2_5",
-        speed: 0.9,
-        stability: 0.8,
-        similarityBoost: 0.9,
+      services: {
+        tts: {
+          providers: {
+            elevenlabs: {
+              voiceId: "abc123",
+              voiceModelId: "turbo_v2_5",
+              speed: 0.9,
+              stability: 0.8,
+              similarityBoost: 0.9,
+            },
+          },
+        },
       },
     });
     const profile = resolveVoiceQualityProfile(config);
@@ -1042,13 +1486,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)
 // ---------------------------------------------------------------------------
@@ -1244,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();
@@ -1253,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,