@vellumai/assistant 0.10.8 → 0.10.9-dev.202607152225.ec6fdbf

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

@@ -6,7 +6,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 // ---------------------------------------------------------------------------
 // Mocks — declared before imports that depend on platform/logger
@@ -30,27 +30,6 @@ function ensureTestDir(): void {
   }
 }
 
-function makeLoggerStub(): Record<string, unknown> {
-  const stub: Record<string, unknown> = {};
-  for (const m of [
-    "info",
-    "warn",
-    "error",
-    "debug",
-    "trace",
-    "fatal",
-    "silent",
-    "child",
-  ]) {
-    stub[m] = m === "child" ? () => makeLoggerStub() : () => {};
-  }
-  return stub;
-}
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () => makeLoggerStub(),
-}));
-
 import { invalidateConfigCache, loadConfig } from "../config/loader.js";
 import {
   AssistantConfigSchema,
@@ -79,11 +58,12 @@ function writeConfig(obj: unknown): void {
 describe("AssistantConfigSchema", () => {
   test("parses empty object with full defaults", () => {
     const result = AssistantConfigSchema.parse({});
-    // services.inference is now an empty object; provider/model live under
-    // llm.default.{provider,model}, auth routing via provider_connections.
+    // services.inference is an empty object; model selection lives under
+    // llm.profiles / llm.callSites, auth routing via provider_connections.
     expect(result.services.inference).toEqual({});
-    expect(result.llm.default.provider).toBe("anthropic");
-    expect(result.llm.default.model).toBe("claude-opus-4-8");
+    expect(result.llm.profiles).toEqual({});
+    expect(result.llm.profileOrder).toEqual([]);
+    expect(result.llm.callSites).toEqual({});
     expect(result.services["image-generation"].provider).toBe("gemini");
     expect(result.services["image-generation"].model).toBe(
       "gemini-3.1-flash-image-preview",
@@ -93,24 +73,9 @@ describe("AssistantConfigSchema", () => {
       "inference-provider-native",
     );
     expect(result.services["web-search"].mode).toBe("your-own");
-    expect(result.llm.default.maxTokens).toBe(64000);
-    expect(result.llm.default.thinking).toEqual({
-      enabled: true,
-      streamThinking: true,
-    });
-    expect(result.llm.default.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",
-      },
+    expect(result.llm.profileSession).toEqual({
+      defaultTtlSeconds: 1800,
+      maxTtlSeconds: 43200,
     });
     expect(result.timeouts).toEqual({
       shellDefaultTimeoutSec: 120,
@@ -181,10 +146,12 @@ describe("AssistantConfigSchema", () => {
   test("accepts valid complete config", () => {
     const input = {
       llm: {
-        default: {
-          provider: "openai" as const,
-          model: "gpt-4",
-          maxTokens: 4096,
+        callSites: {
+          mainAgent: {
+            provider: "openai" as const,
+            model: "gpt-4",
+            maxTokens: 4096,
+          },
         },
       },
       timeouts: {
@@ -200,74 +167,28 @@ describe("AssistantConfigSchema", () => {
       auditLog: { retentionDays: 30 },
     };
     const result = AssistantConfigSchema.parse(input);
-    expect(result.llm.default.provider).toBe("openai");
-    expect(result.llm.default.model).toBe("gpt-4");
-    expect(result.llm.default.maxTokens).toBe(4096);
-    expect(result.llm.default.thinking.enabled).toBe(true);
+    expect(result.llm.callSites?.mainAgent?.provider).toBe("openai");
+    expect(result.llm.callSites?.mainAgent?.model).toBe("gpt-4");
+    expect(result.llm.callSites?.mainAgent?.maxTokens).toBe(4096);
     expect(result.secretDetection.enabled).toBe(false);
   });
 
   test("applies llm defaults when llm key is omitted", () => {
     const result = AssistantConfigSchema.parse({});
     expect(result.llm).toBeDefined();
-    expect(result.llm.default).toEqual({
-      provider: "anthropic",
-      model: "claude-opus-4-8",
-      maxTokens: 64000,
-      effort: "max",
-      speed: "standard",
-      verbosity: "medium",
-      temperature: null,
-      topP: null,
-      thinking: { enabled: true, streamThinking: true },
-      contextWindow: {
-        enabled: true,
-        maxInputTokens: 200000,
-        targetBudgetRatio: 0.3,
-        compactThreshold: 0.8,
-        summaryBudgetRatio: 0.05,
-        overflowRecovery: {
-          enabled: true,
-          safetyMarginRatio: 0.05,
-          maxAttempts: 3,
-          interactiveLatestTurnCompression: "summarize",
-          nonInteractiveLatestTurnCompression: "truncate",
-        },
-      },
-      openrouter: { only: [] },
-    });
     expect(result.llm.profiles).toEqual({});
     expect(result.llm.profileOrder).toEqual([]);
     expect(result.llm.callSites).toEqual({});
     expect(result.llm.pricingOverrides).toEqual([]);
+    expect(result.llm.profileSession).toEqual({
+      defaultTtlSeconds: 1800,
+      maxTtlSeconds: 43200,
+    });
   });
 
   test("accepts an explicit llm block with profiles and call sites", () => {
     const input = {
       llm: {
-        default: {
-          provider: "anthropic" as const,
-          model: "claude-opus-4-7",
-          maxTokens: 32000,
-          effort: "high" as const,
-          speed: "fast" as const,
-          temperature: null,
-          thinking: { enabled: true, streamThinking: false },
-          contextWindow: {
-            enabled: true,
-            maxInputTokens: 200000,
-            targetBudgetRatio: 0.3,
-            compactThreshold: 0.8,
-            summaryBudgetRatio: 0.05,
-            overflowRecovery: {
-              enabled: true,
-              safetyMarginRatio: 0.05,
-              maxAttempts: 3,
-              interactiveLatestTurnCompression: "summarize" as const,
-              nonInteractiveLatestTurnCompression: "truncate" as const,
-            },
-          },
-        },
         profiles: {
           fast: { speed: "fast" as const, effort: "low" as const },
         },
@@ -280,8 +201,6 @@ describe("AssistantConfigSchema", () => {
       },
     };
     const result = AssistantConfigSchema.parse(input);
-    expect(result.llm.default.model).toBe("claude-opus-4-7");
-    expect(result.llm.default.speed).toBe("fast");
     expect(result.llm.profiles?.fast).toEqual({
       speed: "fast",
       effort: "low",
@@ -294,29 +213,6 @@ describe("AssistantConfigSchema", () => {
   test("rejects an llm.callSites entry that references an undefined profile", () => {
     const input = {
       llm: {
-        default: {
-          provider: "anthropic" as const,
-          model: "claude-opus-4-6",
-          maxTokens: 64000,
-          effort: "max" as const,
-          speed: "standard" as const,
-          temperature: null,
-          thinking: { enabled: true, streamThinking: true },
-          contextWindow: {
-            enabled: true,
-            maxInputTokens: 200000,
-            targetBudgetRatio: 0.3,
-            compactThreshold: 0.8,
-            summaryBudgetRatio: 0.05,
-            overflowRecovery: {
-              enabled: true,
-              safetyMarginRatio: 0.05,
-              maxAttempts: 3,
-              interactiveLatestTurnCompression: "summarize" as const,
-              nonInteractiveLatestTurnCompression: "truncate" as const,
-            },
-          },
-        },
         callSites: {
           mainAgent: { profile: "missing-profile" },
         },
@@ -351,38 +247,32 @@ describe("AssistantConfigSchema", () => {
     expect(
       (result.services.inference as Record<string, unknown>).model,
     ).toBeUndefined();
-    expect(result.llm.default.provider).toBe("anthropic");
-    expect(result.llm.default.model).toBe("claude-opus-4-8");
+    expect(result.llm.profiles).toEqual({});
+    expect(result.llm.callSites).toEqual({});
   });
 
-  test("partial llm config (empty `llm: {}`) doesn't trigger full config reset", () => {
-    // Regression guard: previously LLMConfigBase had no schema-level defaults,
-    // so any `llm: {}` block would fail validation and the loader's recovery
-    // path would fall through to `cloneDefaultConfig()`, discarding unrelated
-    // valid settings (like a custom `llm.default.maxTokens`). With leaf-level
-    // defaults, `llm: {}` parses cleanly and the user's other settings are
-    // preserved.
+  test("partial llm config doesn't trigger full config reset", () => {
+    // Regression guard: schema-level leaf defaults mean a partial `llm`
+    // block parses cleanly instead of failing validation, so the loader's
+    // recovery path never falls through to `cloneDefaultConfig()` and the
+    // user's other settings are preserved.
     const result = AssistantConfigSchema.parse({
-      llm: { default: { maxTokens: 32000 } },
+      llm: { profileSession: { defaultTtlSeconds: 900 } },
     });
-    expect(result.llm.default.maxTokens).toBe(32000);
-    expect(result.llm.default.provider).toBe("anthropic");
-    expect(result.llm.default.model).toBe("claude-opus-4-8");
+    expect(result.llm.profileSession.defaultTtlSeconds).toBe(900);
+    expect(result.llm.profileSession.maxTtlSeconds).toBe(43200);
+    expect(result.llm.profiles).toEqual({});
   });
 
-  test("llm.default with one missing field still parses (defaults applied)", () => {
-    // A user can override a single field of `llm.default` without specifying
-    // the rest — schema-level defaults fill in everything that wasn't set.
+  test("legacy llm.default blob parses without error and is ignored", () => {
+    // Load-time backwards compat: `llm.default` is not part of the schema.
+    // Old configs that still carry the blob parse cleanly because Zod strips
+    // unknown keys — the parsed config simply has no `default` key.
     const result = AssistantConfigSchema.parse({
-      llm: { default: { model: "claude-haiku-4-5" } },
-    });
-    expect(result.llm.default.model).toBe("claude-haiku-4-5");
-    expect(result.llm.default.provider).toBe("anthropic");
-    expect(result.llm.default.maxTokens).toBe(64000);
-    expect(result.llm.default.thinking).toEqual({
-      enabled: true,
-      streamThinking: true,
+      llm: { default: { provider: "openai", model: "gpt-4" }, profiles: {} },
     });
+    expect((result.llm as Record<string, unknown>).default).toBeUndefined();
+    expect(result.llm.profiles).toEqual({});
   });
 
   test("applies rollout defaults for dynamic budget", () => {
@@ -473,7 +363,7 @@ describe("AssistantConfigSchema", () => {
     }
   });
 
-  test("accepts memory.cleanup.llmRequestLogRetentionMs: 0 (prune immediately)", () => {
+  test("accepts memory.cleanup.llmRequestLogRetentionMs: 0 (disables pruning)", () => {
     const result = AssistantConfigSchema.safeParse({
       memory: { cleanup: { llmRequestLogRetentionMs: 0 } },
     });
@@ -485,14 +375,14 @@ describe("AssistantConfigSchema", () => {
 
   test("rejects invalid provider", () => {
     const result = AssistantConfigSchema.safeParse({
-      llm: { default: { provider: "invalid" } },
+      llm: { profiles: { custom: { provider: "invalid" } } },
     });
     expect(result.success).toBe(false);
   });
 
-  test("rejects negative llm.default.maxTokens", () => {
+  test("rejects negative llm.callSites maxTokens", () => {
     const result = AssistantConfigSchema.safeParse({
-      llm: { default: { maxTokens: -100 } },
+      llm: { callSites: { mainAgent: { maxTokens: -100 } } },
     });
     expect(result.success).toBe(false);
     if (!result.success) {
@@ -502,9 +392,9 @@ describe("AssistantConfigSchema", () => {
     }
   });
 
-  test("rejects non-integer llm.default.maxTokens", () => {
+  test("rejects non-integer llm.callSites maxTokens", () => {
     const result = AssistantConfigSchema.safeParse({
-      llm: { default: { maxTokens: 3.14 } },
+      llm: { callSites: { mainAgent: { maxTokens: 3.14 } } },
     });
     expect(result.success).toBe(false);
     if (!result.success) {
@@ -514,9 +404,9 @@ describe("AssistantConfigSchema", () => {
     }
   });
 
-  test("rejects string llm.default.maxTokens", () => {
+  test("rejects string llm.callSites maxTokens", () => {
     const result = AssistantConfigSchema.safeParse({
-      llm: { default: { maxTokens: "not-a-number" } },
+      llm: { callSites: { mainAgent: { maxTokens: "not-a-number" } } },
     });
     expect(result.success).toBe(false);
     if (!result.success) {
@@ -542,7 +432,7 @@ describe("AssistantConfigSchema", () => {
 
   test("rejects invalid thinking config", () => {
     const result = AssistantConfigSchema.safeParse({
-      llm: { default: { thinking: { enabled: "yes" } } },
+      llm: { callSites: { mainAgent: { thinking: { enabled: "yes" } } } },
     });
     expect(result.success).toBe(false);
     if (!result.success) {
@@ -550,26 +440,23 @@ describe("AssistantConfigSchema", () => {
     }
   });
 
-  test("rejects contextWindow targetBudgetRatio >= compactThreshold", () => {
-    const result = AssistantConfigSchema.safeParse({
-      llm: {
-        default: {
-          contextWindow: { targetBudgetRatio: 0.8, compactThreshold: 0.8 },
+  test("rejects out-of-range contextWindow targetBudgetRatio", () => {
+    for (const bad of [0, -0.1, 1.5]) {
+      const result = AssistantConfigSchema.safeParse({
+        llm: {
+          callSites: {
+            mainAgent: { contextWindow: { targetBudgetRatio: bad } },
+          },
         },
-      },
-    });
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(
-        result.error.issues.some(
-          (issue) =>
-            issue.path.join(".") ===
-              "llm.default.contextWindow.targetBudgetRatio" &&
-            issue.message.includes(
-              "must be less than llm.default.contextWindow.compactThreshold",
-            ),
-        ),
-      ).toBe(true);
+      });
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(
+          result.error.issues.some((issue) =>
+            issue.path.join(".").includes("targetBudgetRatio"),
+          ),
+        ).toBe(true);
+      }
     }
   });
 
@@ -577,8 +464,10 @@ describe("AssistantConfigSchema", () => {
     for (const bad of [0, 1, -0.1, 1.5]) {
       const result = AssistantConfigSchema.safeParse({
         llm: {
-          default: {
-            contextWindow: { overflowRecovery: { safetyMarginRatio: bad } },
+          callSites: {
+            mainAgent: {
+              contextWindow: { overflowRecovery: { safetyMarginRatio: bad } },
+            },
           },
         },
       });
@@ -596,9 +485,11 @@ describe("AssistantConfigSchema", () => {
   test("rejects invalid overflowRecovery interactiveLatestTurnCompression", () => {
     const result = AssistantConfigSchema.safeParse({
       llm: {
-        default: {
-          contextWindow: {
-            overflowRecovery: { interactiveLatestTurnCompression: "explode" },
+        callSites: {
+          mainAgent: {
+            contextWindow: {
+              overflowRecovery: { interactiveLatestTurnCompression: "explode" },
+            },
           },
         },
       },
@@ -616,9 +507,11 @@ describe("AssistantConfigSchema", () => {
   test("rejects invalid overflowRecovery nonInteractiveLatestTurnCompression", () => {
     const result = AssistantConfigSchema.safeParse({
       llm: {
-        default: {
-          contextWindow: {
-            overflowRecovery: { nonInteractiveLatestTurnCompression: "nope" },
+        callSites: {
+          mainAgent: {
+            contextWindow: {
+              overflowRecovery: { nonInteractiveLatestTurnCompression: "nope" },
+            },
           },
         },
       },
@@ -705,7 +598,7 @@ describe("AssistantConfigSchema", () => {
       "ollama",
     ] as const) {
       const result = AssistantConfigSchema.safeParse({
-        llm: { default: { provider } },
+        llm: { profiles: { custom: { provider } } },
       });
       expect(result.success).toBe(true);
     }
@@ -713,12 +606,12 @@ describe("AssistantConfigSchema", () => {
 
   test("provides helpful error messages", () => {
     const result = AssistantConfigSchema.safeParse({
-      llm: { default: { maxTokens: -1 } },
+      llm: { callSites: { mainAgent: { maxTokens: -1 } } },
     });
     expect(result.success).toBe(false);
     if (!result.success) {
       const messages = result.error.issues.map((i) => i.message);
-      // The llm.default.maxTokens validation rejects -1 with a "Too small"
+      // The maxTokens validation rejects -1 with a "Too small"
       // / "expected number to be >0" message from Zod's default issue text.
       expect(
         messages.some(
@@ -734,6 +627,7 @@ describe("AssistantConfigSchema", () => {
       turnCommitMaxWaitMs: 4000,
       failureBackoffBaseMs: 2000,
       failureBackoffMaxMs: 60000,
+      maxFileSizeBytes: 256000,
       interactiveGitTimeoutMs: 10000,
       enrichmentQueueSize: 50,
       enrichmentConcurrency: 1,
@@ -916,11 +810,12 @@ describe("AssistantConfigSchema", () => {
       mode: "open-mic",
       vad: {
         speechEnergyThreshold: 800,
-        silenceThresholdMs: 800,
+        silenceThresholdMs: 1200,
         maxTurnDurationMs: 30000,
-        bargeInMinSpeechMs: 60,
+        bargeInMinSpeechMs: 250,
       },
       maxSessionDurationSeconds: 1800,
+      archiveAudio: false,
     });
   });
 
@@ -1381,16 +1276,21 @@ describe("AssistantConfigSchema", () => {
     expect(result.services.tts.providers.deepgram.format).toBe("opus");
   });
 
-  test("rejects services.tts.mode = managed", () => {
+  test("accepts services.tts.mode = managed", () => {
     const result = AssistantConfigSchema.safeParse({
       services: { tts: { mode: "managed" } },
     });
+    expect(result.success).toBe(true);
+  });
+
+  test("rejects tts provider vellum outside managed mode", () => {
+    const result = AssistantConfigSchema.safeParse({
+      services: { tts: { mode: "your-own", provider: "vellum" } },
+    });
     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);
+      expect(msgs.some((m) => m.includes("managed"))).toBe(true);
     }
   });
 
@@ -1452,14 +1352,14 @@ describe("AssistantConfigSchema", () => {
     }
   });
 
-  test("services.tts.mode only accepts your-own as literal", () => {
+  test("services.tts.mode accepts your-own and managed", () => {
     // 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);
+    // managed is supported; the BYOK provider choice is preserved
+    const managed = TtsServiceSchema.safeParse({ mode: "managed" });
+    expect(managed.success).toBe(true);
 
     // Any other string should be rejected
     const invalid2 = TtsServiceSchema.safeParse({ mode: "self-hosted" });
@@ -1539,16 +1439,21 @@ describe("AssistantConfigSchema", () => {
     });
   });
 
-  test("rejects services.stt.mode = managed", () => {
+  test("accepts services.stt.mode = managed with a provider", () => {
+    const result = AssistantConfigSchema.safeParse({
+      services: { stt: { mode: "managed", provider: "deepgram" } },
+    });
+    expect(result.success).toBe(true);
+  });
+
+  test("rejects provider vellum outside managed mode", () => {
     const result = AssistantConfigSchema.safeParse({
-      services: { stt: { mode: "managed" } },
+      services: { stt: { mode: "your-own", provider: "vellum" } },
     });
     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);
+      expect(msgs.some((m) => m.includes("managed"))).toBe(true);
     }
   });
 
@@ -1627,7 +1532,7 @@ describe("AssistantConfigSchema", () => {
     expect(result.success).toBe(false);
   });
 
-  test("services.stt.mode only accepts your-own as literal", () => {
+  test("services.stt.mode accepts your-own and managed", () => {
     // Explicit your-own should work
     const valid = SttServiceSchema.safeParse({
       mode: "your-own",
@@ -1635,12 +1540,12 @@ describe("AssistantConfigSchema", () => {
     });
     expect(valid.success).toBe(true);
 
-    // managed should be rejected
-    const invalid = SttServiceSchema.safeParse({
+    // managed is supported; the BYOK provider choice is preserved
+    const managed = SttServiceSchema.safeParse({
       mode: "managed",
       provider: "openai-whisper",
     });
-    expect(invalid.success).toBe(false);
+    expect(managed.success).toBe(true);
 
     // Any other string should be rejected
     const invalid2 = SttServiceSchema.safeParse({
@@ -1812,15 +1717,25 @@ describe("resolveTtsConfig", () => {
 // ---------------------------------------------------------------------------
 
 describe("TTS provider catalog integration", () => {
-  test("TTS_PROVIDER_IDS matches catalog provider IDs", () => {
+  test("TTS_PROVIDER_IDS matches catalog provider IDs plus hidden providers", () => {
     const catalogIds = listCatalogProviderIds();
-    expect([...TTS_PROVIDER_IDS]).toEqual(catalogIds);
+    // Every displayed provider is a canonical ID…
+    for (const id of catalogIds) {
+      expect(TTS_PROVIDER_IDS).toContain(id);
+    }
+    // …and the only canonical ID hidden from the display catalog is
+    // vellum: managed mode is selected via services.tts.mode, not the
+    // provider picker.
+    const hidden = TTS_PROVIDER_IDS.filter((id) => !catalogIds.includes(id));
+    expect(hidden).toEqual(["vellum"]);
   });
 
   test("schema accepts all catalog provider IDs as services.tts.provider", () => {
     for (const providerId of listCatalogProviderIds()) {
+      // vellum is connection-based and only valid under managed mode.
+      const mode = providerId === "vellum" ? "managed" : "your-own";
       const result = AssistantConfigSchema.safeParse({
-        services: { tts: { provider: providerId } },
+        services: { tts: { mode, provider: providerId } },
       });
       expect(result.success).toBe(true);
       if (result.success) {
@@ -1839,13 +1754,21 @@ describe("TTS provider catalog integration", () => {
 
   test("resolveTtsConfig returns correct defaults for each catalog provider", () => {
     for (const providerId of listCatalogProviderIds()) {
+      // vellum is connection-based and only valid under managed mode.
+      const mode = providerId === "vellum" ? "managed" : "your-own";
       const config = AssistantConfigSchema.parse({
-        services: { tts: { provider: providerId } },
+        services: { tts: { mode, 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);
+      if (providerId === "vellum") {
+        // The vellum config block is intentionally empty — the platform
+        // pins the voice and model.
+        expect(resolved.providerConfig).toEqual({});
+      } else {
+        // Every BYOK provider resolves to a non-empty config object.
+        expect(Object.keys(resolved.providerConfig).length).toBeGreaterThan(0);
+      }
     }
   });
 
@@ -2135,53 +2058,64 @@ describe("loadConfig with schema validation", () => {
   test("loads valid config", () => {
     writeConfig({
       llm: {
-        default: { provider: "openai", model: "gpt-4", maxTokens: 4096 },
+        callSites: {
+          mainAgent: { provider: "openai", model: "gpt-4", maxTokens: 4096 },
+        },
       },
     });
     const config = loadConfig();
-    expect(config.llm.default.provider).toBe("openai");
-    expect(config.llm.default.model).toBe("gpt-4");
-    expect(config.llm.default.maxTokens).toBe(4096);
+    expect(config.llm.callSites?.mainAgent?.provider).toBe("openai");
+    expect(config.llm.callSites?.mainAgent?.model).toBe("gpt-4");
+    expect(config.llm.callSites?.mainAgent?.maxTokens).toBe(4096);
   });
 
   test("applies defaults for missing fields", () => {
     writeConfig({});
     const config = loadConfig();
-    expect(config.llm.default.provider).toBe("anthropic");
-    expect(config.llm.default.model).toBe("claude-opus-4-8");
-    expect(config.llm.default.maxTokens).toBe(64000);
-    expect(config.llm.default.thinking).toEqual({
-      enabled: true,
-      streamThinking: true,
+    expect(config.llm.profiles).toEqual({});
+    expect(config.llm.profileOrder).toEqual([]);
+    expect(config.llm.callSites).toEqual({});
+    expect(config.llm.profileSession).toEqual({
+      defaultTtlSeconds: 1800,
+      maxTtlSeconds: 43200,
     });
-    expect(config.llm.default.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("legacy llm.default blob loads without error and is ignored", () => {
+    // Load-time backwards compat: old configs still carrying `llm.default`
+    // load cleanly — the key is stripped from the parsed config (not an
+    // error, no fallback to full defaults) and sibling llm fields survive.
+    writeConfig({
+      llm: {
+        default: { provider: "openai", model: "gpt-4" },
+        callSites: { mainAgent: { maxTokens: 4096 } },
       },
     });
+    const config = loadConfig();
+    expect((config.llm as Record<string, unknown>).default).toBeUndefined();
+    expect(config.llm.callSites?.mainAgent?.maxTokens).toBe(4096);
   });
 
   test("falls back to default for invalid provider", () => {
+    // Leaf-deletion recovery: the invalid provider leaf is stripped and the
+    // rest of the profile survives.
     writeConfig({
-      llm: { default: { provider: "invalid-provider" } },
+      llm: {
+        profiles: { custom: { provider: "invalid-provider", model: "gpt-4" } },
+      },
     });
     const config = loadConfig();
-    expect(config.llm.default.provider).toBe("anthropic");
+    expect(config.llm.profiles.custom?.provider).toBeUndefined();
+    expect(config.llm.profiles.custom?.model).toBe("gpt-4");
   });
 
   test("falls back to default for invalid maxTokens", () => {
-    writeConfig({ llm: { default: { maxTokens: -100 } } });
+    writeConfig({
+      llm: { callSites: { mainAgent: { maxTokens: -100, model: "gpt-4" } } },
+    });
     const config = loadConfig();
-    expect(config.llm.default.maxTokens).toBe(64000);
+    expect(config.llm.callSites?.mainAgent?.maxTokens).toBeUndefined();
+    expect(config.llm.callSites?.mainAgent?.model).toBe("gpt-4");
   });
 
   test("falls back to defaults for invalid nested values", () => {
@@ -2197,25 +2131,27 @@ describe("loadConfig with schema validation", () => {
   test("preserves valid fields when other fields are invalid", () => {
     writeConfig({
       llm: {
-        default: {
-          provider: "openai",
-          model: "gpt-4",
-          maxTokens: -1,
-          thinking: { enabled: true },
+        callSites: {
+          mainAgent: {
+            provider: "openai",
+            model: "gpt-4",
+            maxTokens: -1,
+            thinking: { enabled: true },
+          },
         },
       },
     });
     const config = loadConfig();
-    expect(config.llm.default.provider).toBe("openai");
-    expect(config.llm.default.model).toBe("gpt-4");
-    expect(config.llm.default.thinking.enabled).toBe(true);
-    expect(config.llm.default.maxTokens).toBe(64000);
+    expect(config.llm.callSites?.mainAgent?.provider).toBe("openai");
+    expect(config.llm.callSites?.mainAgent?.model).toBe("gpt-4");
+    expect(config.llm.callSites?.mainAgent?.thinking?.enabled).toBe(true);
+    expect(config.llm.callSites?.mainAgent?.maxTokens).toBeUndefined();
   });
 
   test("handles no config file", () => {
     const config = loadConfig();
-    expect(config.llm.default.provider).toBe("anthropic");
-    expect(config.llm.default.maxTokens).toBe(64000);
+    expect(config.llm.profiles).toEqual({});
+    expect(config.llm.profileSession.defaultTtlSeconds).toBe(1800);
   });
 
   test("partial nested objects get defaults for missing fields", () => {
@@ -2228,17 +2164,25 @@ describe("loadConfig with schema validation", () => {
     expect(config.timeouts.permissionTimeoutSec).toBe(300);
   });
 
-  test("falls back for invalid contextWindow relationship", () => {
+  test("falls back for out-of-range contextWindow ratio", () => {
+    // Leaf-deletion recovery: the invalid ratio leaf is stripped while its
+    // valid sibling survives.
     writeConfig({
       llm: {
-        default: {
-          contextWindow: { targetBudgetRatio: 0.8, compactThreshold: 0.8 },
+        callSites: {
+          mainAgent: {
+            contextWindow: { targetBudgetRatio: 1.5, compactThreshold: 0.7 },
+          },
         },
       },
     });
     const config = loadConfig();
-    expect(config.llm.default.contextWindow.targetBudgetRatio).toBe(0.3);
-    expect(config.llm.default.contextWindow.compactThreshold).toBe(0.8);
+    expect(
+      config.llm.callSites?.mainAgent?.contextWindow?.targetBudgetRatio,
+    ).toBeUndefined();
+    expect(
+      config.llm.callSites?.mainAgent?.contextWindow?.compactThreshold,
+    ).toBe(0.7);
   });
 
   test("falls back for invalid rateLimit values", () => {
@@ -2278,13 +2222,13 @@ describe("loadConfig with schema validation", () => {
     // Only activeHoursStart is set. The superRefine must emit the issue so
     // the loader's delete-and-retry can strip the set field; otherwise the
     // mismatch persists and the config falls back to full defaults (which
-    // would reset llm.default.maxTokens below to 64000).
+    // would wipe the user's llm.callSites.mainAgent.maxTokens below).
     writeConfig({
-      llm: { default: { maxTokens: 4096 } },
+      llm: { callSites: { mainAgent: { maxTokens: 4096 } } },
       filing: { activeHoursStart: 8 },
     });
     const config = loadConfig();
-    expect(config.llm.default.maxTokens).toBe(4096);
+    expect(config.llm.callSites?.mainAgent?.maxTokens).toBe(4096);
     expect(config.filing.activeHoursStart).toBeNull();
     expect(config.filing.activeHoursEnd).toBeNull();
   });
@@ -2292,13 +2236,13 @@ describe("loadConfig with schema validation", () => {
   test("recovers from partial heartbeat.activeHours without wiping unrelated fields", () => {
     // activeHoursStart is explicitly nulled while activeHoursEnd defaults to
     // 22 — a mismatch. Dual-emit strips both sides; both defaults restore
-    // (8, 22). llm.default.maxTokens is unaffected.
+    // (8, 22). llm.callSites.mainAgent.maxTokens is unaffected.
     writeConfig({
-      llm: { default: { maxTokens: 4096 } },
+      llm: { callSites: { mainAgent: { maxTokens: 4096 } } },
       heartbeat: { activeHoursStart: null },
     });
     const config = loadConfig();
-    expect(config.llm.default.maxTokens).toBe(4096);
+    expect(config.llm.callSites?.mainAgent?.maxTokens).toBe(4096);
     expect(config.heartbeat.activeHoursStart).toBe(8);
     expect(config.heartbeat.activeHoursEnd).toBe(22);
   });
@@ -2306,14 +2250,15 @@ describe("loadConfig with schema validation", () => {
   test("recovers from heartbeat.activeHours null-mismatch where explicit value equals opposite default", () => {
     // { start: null, end: 8 } — single-emit on the null side would strip
     // start, the default 8 would restore it, and the equal-hours check would
-    // fire, cascading to a full defaults reset that wipes llm.default.maxTokens.
-    // Dual-emit strips both sides in one pass.
+    // fire, cascading to a full defaults reset that wipes the user's
+    // llm.callSites.mainAgent.maxTokens. Dual-emit strips both sides in one
+    // pass.
     writeConfig({
-      llm: { default: { maxTokens: 4096 } },
+      llm: { callSites: { mainAgent: { maxTokens: 4096 } } },
       heartbeat: { activeHoursStart: null, activeHoursEnd: 8 },
     });
     const config = loadConfig();
-    expect(config.llm.default.maxTokens).toBe(4096);
+    expect(config.llm.callSites?.mainAgent?.maxTokens).toBe(4096);
     expect(config.heartbeat.activeHoursStart).toBe(8);
     expect(config.heartbeat.activeHoursEnd).toBe(22);
   });
@@ -2321,11 +2266,11 @@ describe("loadConfig with schema validation", () => {
   test("recovers from heartbeat.activeHours null-mismatch on the end side", () => {
     // { start: 22, end: null } — same cascade class as above, mirrored.
     writeConfig({
-      llm: { default: { maxTokens: 4096 } },
+      llm: { callSites: { mainAgent: { maxTokens: 4096 } } },
       heartbeat: { activeHoursStart: 22, activeHoursEnd: null },
     });
     const config = loadConfig();
-    expect(config.llm.default.maxTokens).toBe(4096);
+    expect(config.llm.callSites?.mainAgent?.maxTokens).toBe(4096);
     expect(config.heartbeat.activeHoursStart).toBe(8);
     expect(config.heartbeat.activeHoursEnd).toBe(22);
   });
@@ -2334,13 +2279,14 @@ describe("loadConfig with schema validation", () => {
     // { start: 22, end: 22 } — both equal to the default for end. Single-emit
     // on one path would strip one side, the default would recreate the
     // equal-hours mismatch, and the loader would fall back to full defaults,
-    // wiping llm.default.maxTokens. Dual-emit strips both sides at once.
+    // wiping the user's llm.callSites.mainAgent.maxTokens. Dual-emit strips
+    // both sides at once.
     writeConfig({
-      llm: { default: { maxTokens: 4096 } },
+      llm: { callSites: { mainAgent: { maxTokens: 4096 } } },
       heartbeat: { activeHoursStart: 22, activeHoursEnd: 22 },
     });
     const config = loadConfig();
-    expect(config.llm.default.maxTokens).toBe(4096);
+    expect(config.llm.callSites?.mainAgent?.maxTokens).toBe(4096);
     expect(config.heartbeat.activeHoursStart).toBe(8);
     expect(config.heartbeat.activeHoursEnd).toBe(22);
   });
@@ -2349,14 +2295,14 @@ describe("loadConfig with schema validation", () => {
     // activeHoursStart === activeHoursEnd is invalid (empty window). Filing's
     // defaults are null/null, so single-emit on one path would strip one side
     // and the null default would recreate a mismatch — cascading to a full
-    // defaults reset that wipes llm.default.maxTokens. Dual-emit strips both
-    // sides so both defaults restore to null.
+    // defaults reset that wipes the user's llm.callSites.mainAgent.maxTokens.
+    // Dual-emit strips both sides so both defaults restore to null.
     writeConfig({
-      llm: { default: { maxTokens: 1234 } },
+      llm: { callSites: { mainAgent: { maxTokens: 1234 } } },
       filing: { activeHoursStart: 5, activeHoursEnd: 5 },
     });
     const config = loadConfig();
-    expect(config.llm.default.maxTokens).toBe(1234);
+    expect(config.llm.callSites?.mainAgent?.maxTokens).toBe(1234);
     expect(config.filing.activeHoursStart).toBeNull();
     expect(config.filing.activeHoursEnd).toBeNull();
   });