@mycadet/assistant 0.12.9 → 0.12.11

package/src/__tests__/cloud-profile-guard.test.ts

@@ -67,21 +67,18 @@ function makeDefaultRawConfig(): Record<string, unknown> {
     llm: {
       profiles: {
         "quality-optimized": {
-          provider: "anthropic",
-          model: "claude-sonnet",
-          source: "managed",
+          provider: "cadet",
+          model: "claude-sonnet-4-6",
         },
         balanced: {
-          provider: "anthropic",
-          model: "claude-sonnet",
-          source: "managed",
+          provider: "cadet",
+          model: "claude-sonnet-4-6",
         },
         "cost-optimized": {
-          provider: "anthropic",
-          model: "claude-haiku",
-          source: "managed",
+          provider: "cadet",
+          model: "claude-sonnet-4-6",
         },
-        "my-custom": { provider: "openai", model: "gpt-4o", source: "user" },
+        "my-custom": { provider: "openai", model: "gpt-4o" },
       },
     },
   };
@@ -141,6 +138,42 @@ function savedProfile(name: string): Record<string, unknown> {
   >;
 }
 
+describe("partial default-provider config", () => {
+  for (const provider of ["cadet", "chatgpt"]) {
+    test(`timezone PATCH accepts a model-less ${provider} default`, async () => {
+      seedRawConfig({ llm: { default: { provider } } });
+      await patchRoute.handler({
+        body: { ui: { userTimezone: "America/New_York" } },
+      });
+      const saved = committedRaw() as {
+        ui: { userTimezone: string };
+        llm: { default: { provider: string; model?: string } };
+      };
+      expect(saved.ui.userTimezone).toBe("America/New_York");
+      expect(saved.llm.default).toEqual({ provider });
+      expectOneCommitCycle();
+    });
+    test(`PATCH can select ${provider} as default without a model`, async () => {
+      seedRawConfig({});
+      await patchRoute.handler({ body: { llm: { default: { provider } } } });
+      expect(
+        (committedRaw() as { llm: { default: { provider: string } } }).llm
+          .default,
+      ).toEqual({ provider });
+    });
+  }
+  test("Zod rejects a default model with the wrong type", async () => {
+    await expect(
+      patchRoute.handler({
+        body: {
+          llm: { default: { provider: "cadet", model: 42 } },
+        },
+      }),
+    ).rejects.toThrow(/model|expected string/i);
+    expectNothingCommitted();
+  });
+});
+
 // ---------------------------------------------------------------------------
 // PUT /v1/config/llm/profiles/:name — replace inference profile
 // ---------------------------------------------------------------------------
@@ -213,13 +246,13 @@ describe("PUT /v1/config/llm/profiles/:name — cloud profile guard", () => {
     ).toBeUndefined();
   });
 
-  test("rejects a routing identity with an unroutable model at the write choke point", async () => {
+  test("Zod rejects invalid fields in a replacement profile", async () => {
     await expect(
       replaceRoute.handler({
         pathParams: { name: "my-custom" },
-        body: { provider: "cadet", model: "not-a-real-model" },
+        body: { provider: "cadet", model: "claude-opus-4-8", maxTokens: 0 },
       }),
-    ).rejects.toThrow(/not served by the Cadet Cloud route/);
+    ).rejects.toThrow(/expected number to be >0/);
     expect(committedRaw()).toBeNull();
   });
 
@@ -246,10 +279,9 @@ describe("PUT /v1/config/llm/profiles/:name — cloud profile guard", () => {
       llm: {
         profiles: {
           balanced: {
-            provider: "anthropic",
-            model: "claude-sonnet",
+            provider: "cadet",
+            model: "claude-sonnet-4-6",
             label: "My Custom Name",
-            source: "managed",
           },
         },
       },
@@ -319,10 +351,9 @@ describe("PUT /v1/config/llm/profiles/:name — cloud profile guard", () => {
       llm: {
         profiles: {
           "quality-optimized": {
-            provider: "anthropic",
-            model: "claude-opus",
+            provider: "cadet",
+            model: "claude-sonnet-4-6",
             status: "disabled",
-            source: "managed",
           },
         },
       },
@@ -334,8 +365,8 @@ describe("PUT /v1/config/llm/profiles/:name — cloud profile guard", () => {
     expect(result).toEqual({ ok: true });
     const profile = savedProfile("quality-optimized");
     expect("status" in profile).toBe(false);
-    expect(profile.provider).toBe("anthropic");
-    expect(profile.model).toBe("claude-opus");
+    expect(profile.provider).toBe("cadet");
+    expect(profile.model).toBe("claude-sonnet-4-6");
   });
 
   test("PUT { label: null, status: null } on managed os-beta is rejected (label is frozen)", async () => {
@@ -343,11 +374,10 @@ describe("PUT /v1/config/llm/profiles/:name — cloud profile guard", () => {
       llm: {
         profiles: {
           "os-beta": {
-            provider: "together",
+            provider: "cadet",
             model: "zai-org/GLM-5.2",
             label: "OS Beta (Custom)",
             status: "disabled",
-            source: "managed",
           },
         },
       },
@@ -368,10 +398,9 @@ describe("PUT /v1/config/llm/profiles/:name — cloud profile guard", () => {
       llm: {
         profiles: {
           "os-beta": {
-            provider: "together",
+            provider: "cadet",
             model: "zai-org/GLM-5.2",
             label: "Custom Label",
-            source: "managed",
           },
         },
       },
@@ -392,9 +421,8 @@ describe("PUT /v1/config/llm/profiles/:name — cloud profile guard", () => {
       llm: {
         profiles: {
           "os-beta": {
-            provider: "together",
+            provider: "cadet",
             model: "zai-org/GLM-5.2",
-            source: "managed",
           },
         },
       },
@@ -413,10 +441,9 @@ describe("PUT /v1/config/llm/profiles/:name — cloud profile guard", () => {
       llm: {
         profiles: {
           "os-beta": {
-            provider: "together",
+            provider: "cadet",
             model: "zai-org/GLM-5.2",
             topP: 0.7,
-            source: "managed",
           },
         },
       },
@@ -435,10 +462,9 @@ describe("PUT /v1/config/llm/profiles/:name — cloud profile guard", () => {
       llm: {
         profiles: {
           "os-beta": {
-            provider: "together",
-            model: "zai-org/GLM-5.2",
+            provider: "cadet",
+            model: "claude-sonnet-4-6",
             status: "disabled",
-            source: "managed",
           },
         },
       },
@@ -451,8 +477,8 @@ describe("PUT /v1/config/llm/profiles/:name — cloud profile guard", () => {
     expectOneCommitCycle();
     const profile = savedProfile("os-beta");
     expect(profile.status).toBe("active");
-    expect(profile.provider).toBe("together");
-    expect(profile.model).toBe("zai-org/GLM-5.2");
+    expect(profile.provider).toBe("cadet");
+    expect(profile.model).toBe("claude-sonnet-4-6");
   });
 
   test("allows edits to a user-owned profile sharing a cloud name (os-beta)", async () => {
@@ -461,8 +487,7 @@ describe("PUT /v1/config/llm/profiles/:name — cloud profile guard", () => {
         profiles: {
           "os-beta": {
             provider: "anthropic",
-            model: "claude-sonnet",
-            source: "user",
+            model: "gpt-4o",
           },
         },
       },
@@ -482,9 +507,8 @@ describe("PUT /v1/config/llm/profiles/:name — cloud profile guard", () => {
       llm: {
         profiles: {
           "os-beta": {
-            provider: "fireworks",
+            provider: "cadet",
             model: "accounts/fireworks/models/glm-5p2",
-            source: "managed",
           },
         },
       },
@@ -532,30 +556,6 @@ describe("PUT /v1/config/llm/profiles/:name — cloud profile guard", () => {
 // ---------------------------------------------------------------------------
 
 describe("PATCH /v1/config — cloud profile deletion guard", () => {
-  test("rejects deletion of quality-optimized via null with descriptive message", async () => {
-    await expect(
-      patchRoute.handler({
-        body: { llm: { profiles: { "quality-optimized": null } } },
-      }),
-    ).rejects.toThrow('Cannot delete cloud profile "quality-optimized".');
-  });
-
-  test("rejects deletion of balanced via null", async () => {
-    await expect(
-      patchRoute.handler({
-        body: { llm: { profiles: { balanced: null } } },
-      }),
-    ).rejects.toThrow(BadRequestError);
-  });
-
-  test("rejects deletion of cost-optimized via null", async () => {
-    await expect(
-      patchRoute.handler({
-        body: { llm: { profiles: { "cost-optimized": null } } },
-      }),
-    ).rejects.toThrow(BadRequestError);
-  });
-
   test("allows deletion of custom-balanced via null (user-owned)", async () => {
     const result = await patchRoute.handler({
       body: { llm: { profiles: { "custom-balanced": null } } },
@@ -616,9 +616,8 @@ describe("PATCH /v1/config — cloud profile deletion guard", () => {
       llm: {
         profiles: {
           "os-beta": {
-            provider: "anthropic",
-            model: "claude-sonnet",
-            source: "user",
+            provider: "cadet",
+            model: "claude-sonnet-4-6",
           },
         },
       },
@@ -628,33 +627,6 @@ describe("PATCH /v1/config — cloud profile deletion guard", () => {
     });
     expect(result).toHaveProperty("llm");
   });
-
-  test("rejects deletion of a cloud os-beta profile", async () => {
-    seedRawConfig({
-      llm: {
-        profiles: {
-          "os-beta": {
-            provider: "fireworks",
-            model: "accounts/fireworks/models/glm-5p2",
-            source: "managed",
-          },
-        },
-      },
-    });
-    await expect(
-      patchRoute.handler({
-        body: { llm: { profiles: { "os-beta": null } } },
-      }),
-    ).rejects.toThrow('Cannot delete cloud profile "os-beta".');
-  });
-
-  test("rejects nulling the entire profiles map", async () => {
-    await expect(
-      patchRoute.handler({
-        body: { llm: { profiles: null } },
-      }),
-    ).rejects.toThrow("Cannot null llm.profiles");
-  });
 });
 
 // ---------------------------------------------------------------------------
@@ -664,93 +636,10 @@ describe("PATCH /v1/config — cloud profile deletion guard", () => {
 // os-beta) is read-only to every config-write route while its on-disk entry
 // is managed-source; the only writable transition is re-enabling a disabled
 // profile. A user-owned entry sharing a cloud name is not locked. Enforced
-// by `assertInvariantProfilesPreserved` at the commitConfigWrite choke
 // point, so PATCH, SET, and PUT are all covered by the same checks.
 // ---------------------------------------------------------------------------
 
 describe("cloud-profile invariant guard — rejected writes", () => {
-  test("PATCH disabling balanced is rejected (active → disabled)", async () => {
-    await expect(
-      patchRoute.handler({
-        body: { llm: { profiles: { balanced: { status: "disabled" } } } },
-      }),
-    ).rejects.toThrow('Cannot disable cloud profile "balanced".');
-    expectNothingCommitted();
-  });
-
-  test("PATCH setting a label on balanced is rejected", async () => {
-    await expect(
-      patchRoute.handler({
-        body: { llm: { profiles: { balanced: { label: "X" } } } },
-      }),
-    ).rejects.toThrow(
-      'Cannot edit cloud profile "balanced" fields [label]. ' +
-        "Cloud profiles are read-only; duplicate to a custom profile to customize.",
-    );
-    expectNothingCommitted();
-  });
-
-  test("PATCH { label: null } on balanced is rejected when a label exists", async () => {
-    (rawConfig as Record<string, any>).llm.profiles.balanced.label = "Balanced";
-    seedRawConfig(rawConfig);
-    await expect(
-      patchRoute.handler({
-        body: { llm: { profiles: { balanced: { label: null } } } },
-      }),
-    ).rejects.toThrow('Cannot edit cloud profile "balanced" fields [label]');
-    expectNothingCommitted();
-  });
-
-  test("PATCH { topP: 0.8 } on balanced is rejected", async () => {
-    await expect(
-      patchRoute.handler({
-        body: { llm: { profiles: { balanced: { topP: 0.8 } } } },
-      }),
-    ).rejects.toThrow('Cannot edit cloud profile "balanced" fields [topP]');
-    expectNothingCommitted();
-  });
-
-  test("PATCH { topP: null } on balanced is rejected when an on-disk override exists", async () => {
-    (rawConfig as Record<string, any>).llm.profiles.balanced.topP = 0.7;
-    seedRawConfig(rawConfig);
-    await expect(
-      patchRoute.handler({
-        body: { llm: { profiles: { balanced: { topP: null } } } },
-      }),
-    ).rejects.toThrow('Cannot edit cloud profile "balanced" fields [topP]');
-    expectNothingCommitted();
-  });
-
-  test("PATCH disabling a cloud-source os-beta is rejected (active → disabled)", async () => {
-    (rawConfig as Record<string, any>).llm.profiles["os-beta"] = {
-      provider: "together",
-      model: "zai-org/GLM-5.2",
-      source: "managed",
-    };
-    seedRawConfig(rawConfig);
-    await expect(
-      patchRoute.handler({
-        body: { llm: { profiles: { "os-beta": { status: "disabled" } } } },
-      }),
-    ).rejects.toThrow('Cannot disable cloud profile "os-beta".');
-    expectNothingCommitted();
-  });
-
-  test("SET llm.profiles.os-beta.label is rejected on a cloud-source entry", async () => {
-    (rawConfig as Record<string, any>).llm.profiles["os-beta"] = {
-      provider: "together",
-      model: "zai-org/GLM-5.2",
-      source: "managed",
-    };
-    seedRawConfig(rawConfig);
-    await expect(
-      setRoute.handler({
-        body: { path: "llm.profiles.os-beta.label", value: "My OS Beta" },
-      }),
-    ).rejects.toThrow('Cannot edit cloud profile "os-beta" fields [label]');
-    expectNothingCommitted();
-  });
-
   test("PATCH overwriting balanced with a string is rejected", async () => {
     await expect(
       patchRoute.handler({
@@ -785,22 +674,6 @@ describe("cloud-profile invariant guard — rejected writes", () => {
     expectNothingCommitted();
   });
 
-  test("SET llm.profiles.balanced.status = 'disabled' is rejected", async () => {
-    await expect(
-      setRoute.handler({
-        body: { path: "llm.profiles.balanced.status", value: "disabled" },
-      }),
-    ).rejects.toThrow('Cannot disable cloud profile "balanced".');
-    expectNothingCommitted();
-  });
-
-  test("SET llm = {} is rejected (would drop all defaults)", async () => {
-    await expect(
-      setRoute.handler({ body: { path: "llm", value: {} } }),
-    ).rejects.toThrow(/Cannot delete or replace cloud profile/);
-    expectNothingCommitted();
-  });
-
   test("PATCH { status: 'weird' } on balanced is rejected (junk status)", async () => {
     await expect(
       patchRoute.handler({
@@ -905,8 +778,7 @@ describe("default-profile invariant guard — allowed writes", () => {
   test("PUT full edits on a user-sourced os-beta entry are allowed (invariance is source-gated)", async () => {
     (rawConfig as Record<string, any>).llm.profiles["os-beta"] = {
       provider: "anthropic",
-      model: "claude-sonnet",
-      source: "user",
+      model: "claude-sonnet-4-6",
     };
     seedRawConfig(rawConfig);
     const result = await replaceRoute.handler({
@@ -997,8 +869,8 @@ describe("wire-only profile keys are stripped from writes", () => {
     const profile = savedProfile("balanced");
     expect("invariant" in profile).toBe(false);
     expect("supportsVision" in profile).toBe(false);
-    expect(profile.provider).toBe("anthropic");
-    expect(profile.model).toBe("claude-sonnet");
+    expect(profile.provider).toBe("cadet");
+    expect(profile.model).toBe("claude-sonnet-4-6");
   });
 
   test("SET of a wire-only leaf path never persists the key", async () => {
@@ -1035,8 +907,8 @@ describe("wire-only profile keys are stripped from writes", () => {
     expect(profile.status).toBe("active");
     expect("supportsVision" in profile).toBe(false);
     expect("invariant" in profile).toBe(false);
-    expect(profile.provider).toBe("anthropic");
-    expect(profile.model).toBe("claude-sonnet");
+    expect(profile.provider).toBe("cadet");
+    expect(profile.model).toBe("claude-sonnet-4-6");
   });
 
   test("pure no-op SET round-trip with stale on-disk supportsVision succeeds", async () => {
@@ -1053,8 +925,8 @@ describe("wire-only profile keys are stripped from writes", () => {
     const profile = savedProfile("balanced");
     expect("supportsVision" in profile).toBe(false);
     expect("invariant" in profile).toBe(false);
-    expect(profile.provider).toBe("anthropic");
-    expect(profile.model).toBe("claude-sonnet");
+    expect(profile.provider).toBe("cadet");
+    expect(profile.model).toBe("claude-sonnet-4-6");
   });
 
   test("PATCH re-enable carrying wire keys succeeds when the on-disk entry has stale supportsVision", async () => {
@@ -1108,99 +980,18 @@ describe("wire-only profile keys are stripped from writes", () => {
 const getRoute = ROUTES.find((r) => r.operationId === "config_get")!;
 
 describe("code-owned default profiles — wire view and write normalization", () => {
-  test("GET materializes catalog bodies over thin stubs (wire-only)", async () => {
+  test("GET serves thin stubs verbatim — materialization lives on the profiles API", async () => {
     seedRawConfig({
       llm: {
-        profiles: { balanced: { source: "managed", status: "disabled" } },
+        profiles: { balanced: { status: "disabled" } },
       },
     });
     const response = (await getRoute.handler({})) as Record<string, any>;
     const wireBalanced = response.llm.profiles.balanced;
-    expect(wireBalanced.model).toBe("accounts/fireworks/models/glm-5p3-flash");
-    expect(wireBalanced.provider).toBe("cadet");
-    expect(wireBalanced.provider_connection).toBeUndefined();
-    expect(wireBalanced.status).toBe("disabled");
-    expect(wireBalanced.invariant).toBe(true);
-    // Absent defaults are materialized too — the catalog owns their content.
-    expect(response.llm.profiles["quality-optimized"].model).toBeDefined();
-  });
-
-  test("GET → PATCH round-trip of the wire view is accepted and keeps disk stubs thin", async () => {
-    seedRawConfig({
-      llm: {
-        profiles: {
-          balanced: { source: "managed", status: "disabled" },
-          "my-custom": { provider: "openai", model: "gpt-4o", source: "user" },
-        },
-      },
-    });
-    const response = (await getRoute.handler({})) as Record<string, any>;
-    const result = await patchRoute.handler({
-      body: { llm: { profiles: response.llm.profiles } },
-    });
-    expect(result).toHaveProperty("llm");
-    expectOneCommitCycle();
-    expect(savedProfile("balanced")).toEqual({
-      source: "managed",
-      status: "disabled",
-    });
-    // Echoes of absent defaults reduce to a no-op managed stub.
-    expect(savedProfile("quality-optimized")).toEqual({ source: "managed" });
-    expect(savedProfile("my-custom")).toEqual({
-      provider: "openai",
-      model: "gpt-4o",
-      source: "user",
-    });
-  });
-
-  test("creating a new profile under a default name is rejected", async () => {
-    seedRawConfig({ llm: { profiles: {} } });
-    await expect(
-      patchRoute.handler({
-        body: {
-          llm: {
-            profiles: {
-              balanced: { source: "user", provider: "openai", model: "gpt-4o" },
-            },
-          },
-        },
-      }),
-    ).rejects.toThrow(
-      'Cannot create profile "balanced" — the name is reserved for a code-defined default profile.',
-    );
-    expectNothingCommitted();
-  });
-
-  test("writing content to an absent default name is rejected", async () => {
-    seedRawConfig({ llm: { profiles: {} } });
-    await expect(
-      patchRoute.handler({
-        body: {
-          llm: {
-            profiles: {
-              "cost-optimized": { source: "managed", model: "gpt-4o" },
-            },
-          },
-        },
-      }),
-    ).rejects.toThrow(
-      'Cannot edit cloud profile "cost-optimized" fields [model].',
-    );
-    expectNothingCommitted();
-  });
-
-  test("disabling an absent default via a generic write is rejected", async () => {
-    seedRawConfig({ llm: { profiles: {} } });
-    await expect(
-      patchRoute.handler({
-        body: {
-          llm: {
-            profiles: { balanced: { source: "managed", status: "disabled" } },
-          },
-        },
-      }),
-    ).rejects.toThrow('Cannot disable cloud profile "balanced".');
-    expectNothingCommitted();
+    expect(wireBalanced).toEqual({ status: "disabled" });
+    // Catalog-only defaults (no on-disk stub) do not appear at all — the
+    // profiles API's list serves their resolved bodies.
+    expect(response.llm.profiles["quality-optimized"]).toBeUndefined();
   });
 
   test("PUT status re-enable on an absent always-available default creates a thin managed stub", async () => {
@@ -1211,7 +1002,6 @@ describe("code-owned default profiles — wire view and write normalization", ()
     });
     expect(result).toEqual({ ok: true });
     expect(savedProfile("balanced")).toEqual({
-      source: "managed",
       status: "active",
     });
   });
@@ -1251,25 +1041,19 @@ describe("code-owned default profiles — BYO default provider wire view", () =>
   // intent × provider matrix that actually dispatches — not the cadet
   // column — and the write path must echo-strip against that same view or an
   // honest GET → write round-trip is rejected.
-  test("GET materializes the default provider's column for default profiles", async () => {
+  test("GET serves no catalog-only defaults — the profiles API materializes the column", async () => {
     seedRawConfig({
       llm: { default: { provider: "anthropic" }, profiles: {} },
     });
     const response = (await getRoute.handler({})) as Record<string, any>;
-    const wireBalanced = response.llm.profiles.balanced;
-    expect(wireBalanced.provider).toBe("anthropic");
-    expect(wireBalanced.model).toBe("claude-sonnet-4-6");
-    expect(wireBalanced.provider_connection).toBe("anthropic-personal");
-    expect(response.llm.profiles["quality-optimized"].provider).toBe(
-      "anthropic",
-    );
+    expect(response.llm.profiles).toEqual({});
   });
 
-  test("GET → PATCH round-trip of the BYO wire view is accepted and keeps disk stubs thin", async () => {
+  test("GET → PATCH round-trip of the raw profiles is accepted on a BYO install too", async () => {
     seedRawConfig({
       llm: {
         default: { provider: "anthropic" },
-        profiles: { balanced: { source: "managed", status: "disabled" } },
+        profiles: { balanced: { status: "disabled" } },
       },
     });
     const response = (await getRoute.handler({})) as Record<string, any>;
@@ -1279,14 +1063,13 @@ describe("code-owned default profiles — BYO default provider wire view", () =>
     expect(result).toHaveProperty("llm");
     expectOneCommitCycle();
     expect(savedProfile("balanced")).toEqual({
-      source: "managed",
       status: "disabled",
     });
-    // Echoes of absent defaults reduce to a no-op managed stub.
-    expect(savedProfile("quality-optimized")).toEqual({ source: "managed" });
+    // No absent-default echoes exist to reduce — nothing else is written.
+    expect(savedProfile("quality-optimized")).toBeUndefined();
   });
 
-  test("GET → SET llm round-trip of the BYO wire view is accepted", async () => {
+  test("GET → SET llm round-trip of the raw view is accepted and writes no stubs", async () => {
     seedRawConfig({
       llm: { default: { provider: "anthropic" }, profiles: {} },
     });
@@ -1295,109 +1078,9 @@ describe("code-owned default profiles — BYO default provider wire view", () =>
       body: { path: "llm", value: response.llm },
     });
     expect(result).toHaveProperty("ok");
-    expect(savedProfile("balanced")).toEqual({ source: "managed" });
-  });
-});
-
-describe("code-owned default profiles — leaf SET source stamping", () => {
-  test("a leaf SET creating a cloud entry stamps the cloud marker", async () => {
-    seedRawConfig({ llm: { profiles: {} } });
-    const result = await setRoute.handler({
-      body: { path: "llm.profiles.balanced.status", value: "active" },
-    });
-    expect(result).toEqual({ ok: true });
-    expect(savedProfile("balanced")).toEqual({
-      source: "managed",
-      status: "active",
-    });
-  });
-
-  test("a leaf SET on an existing user shadow does not stamp it managed", async () => {
-    seedRawConfig({
-      llm: {
-        profiles: {
-          balanced: { source: "user", provider: "openai", model: "gpt-4o" },
-        },
-      },
-    });
-    const result = await setRoute.handler({
-      body: { path: "llm.profiles.balanced.model", value: "gpt-5.4" },
-    });
-    expect(result).toEqual({ ok: true });
-    // Write normalization completes the changed user entry; the guard's
-    // concern is only that `source` stays user-owned.
-    expect(savedProfile("balanced")).toMatchObject({
-      source: "user",
-      provider: "openai",
-      model: "gpt-5.4",
-    });
-    expect(savedProfile("balanced").source).toBe("user");
-  });
-
-  test("a leaf SET writing content to an absent default is rejected", async () => {
-    seedRawConfig({ llm: { profiles: {} } });
-    await expect(
-      setRoute.handler({
-        body: { path: "llm.profiles.balanced.model", value: "gpt-4o" },
-      }),
-    ).rejects.toThrow(BadRequestError);
-    expectNothingCommitted();
-  });
-});
-
-describe("code-owned default profiles — echoes over stale on-disk bodies", () => {
-  // An overlay can persist a cloud entry whose content differs from the
-  // catalog; GET serves catalog content, so a client echo carries values
-  // that match neither nothing — they match the wire view. The round-trip
-  // must still be a no-op.
-  const staleBody = {
-    source: "managed",
-    provider: "anthropic",
-    model: "claude-sonnet",
-    maxTokens: 16000,
-  };
-
-  test("GET → PATCH round-trip over a stale managed body is accepted and changes nothing", async () => {
-    seedRawConfig({
-      llm: { profiles: { balanced: structuredClone(staleBody) } },
-    });
-    const response = (await getRoute.handler({})) as Record<string, any>;
-    // The wire view serves catalog content, not the stale body.
-    expect(response.llm.profiles.balanced.model).toBe(
-      "accounts/fireworks/models/glm-5p3-flash",
-    );
-    const result = await patchRoute.handler({
-      body: { llm: { profiles: response.llm.profiles } },
-    });
-    expect(result).toHaveProperty("llm");
-    expectOneCommitCycle();
-    expect(savedProfile("balanced")).toEqual(staleBody);
-  });
-
-  test("GET → SET llm round-trip over a stale managed body is accepted and changes nothing", async () => {
-    seedRawConfig({
-      llm: { profiles: { balanced: structuredClone(staleBody) } },
-    });
-    const response = (await getRoute.handler({})) as Record<string, any>;
-    const result = await setRoute.handler({
-      body: { path: "llm.profiles", value: response.llm.profiles },
-    });
-    expect(result).toEqual({ ok: true });
-    expect(savedProfile("balanced")).toEqual(staleBody);
-  });
-
-  test("a genuine content edit over a stale managed body is still rejected", async () => {
-    seedRawConfig({
-      llm: { profiles: { balanced: structuredClone(staleBody) } },
-    });
-    await expect(
-      patchRoute.handler({
-        body: {
-          llm: { profiles: { balanced: { model: "some-other-model" } } },
-        },
-      }),
-    ).rejects.toThrow(BadRequestError);
-    expectNothingCommitted();
+    // The raw response carries no materialized catalog bodies, so the
+    // catalog-only default stays catalog-only.
+    expect(savedProfile("balanced")).toBeUndefined();
   });
 });