@mycadet/assistant 0.12.7 → 0.12.9

package/src/runtime/routes/__tests__/conversation-query-routes.test.ts

@@ -874,7 +874,7 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
       expect(initializeProvidersCalls).toBe(0);
     });
 
-    test("rejects a custom pointer at a managed backup name", async () => {
+    test("rejects a custom pointer at a cloud backup name", async () => {
       await expect(
         replaceProfileRoute.handler({
           pathParams: { name: "custom" },
@@ -987,7 +987,7 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
     // across tests in this file, so a leaked openai-personal would otherwise
     // win the derivation.
     getDb().delete(providerConnections).run();
-    // The single Cadet-managed connection serves managed-routable providers.
+    // The single Cadet Cloud connection serves managed-routable providers.
     createConnection(getDb(), {
       name: "cadet",
       provider: "cadet",
@@ -1021,7 +1021,7 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
     ).profiles.custom;
 
     // No personal openai connection exists, so the route auto-derives the
-    // single Cadet-managed connection for this managed-routable provider.
+    // single Cadet Cloud connection for this managed-routable provider.
     expect(savedProfile.provider_connection).toBe("cadet");
   });
 
@@ -1136,10 +1136,10 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
     expect(conn!.provider).toBe("minimax");
   });
 
-  describe("managed profile guard", () => {
+  describe("cloud profile guard", () => {
     beforeEach(() => {
       // Seed two managed-source profiles alongside the existing custom one.
-      // Every managed profile name (including the flag-gated os-beta) is
+      // Every cloud profile name (including the flag-gated os-beta) is
       // invariant while its entry is managed-source: fully read-only except
       // the disabled → active status transition.
       const profiles = (
@@ -1168,9 +1168,7 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
           pathParams: { name: "os-beta" },
           body: { label: "My OS Beta" },
         }),
-      ).rejects.toThrow(
-        /Cannot edit managed profile "os-beta" fields \[label\]/,
-      );
+      ).rejects.toThrow(/Cannot edit cloud profile "os-beta" fields \[label\]/);
       // Guard rejects before any write — the seed label is untouched.
       expect(persistedProfile("os-beta").label).toBe("OS Beta");
     });
@@ -1182,7 +1180,7 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
           body: { status: "disabled" },
         }),
       ).rejects.toThrow(
-        'Cannot edit managed profile "os-beta". Managed profiles are read-only',
+        'Cannot edit cloud profile "os-beta". Cloud profiles are read-only',
       );
       // Guard rejects before any write — the seed status is untouched.
       expect(persistedProfile("os-beta").status).toBe("active");
@@ -1215,10 +1213,10 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
       expect(savedProfile.source).toBe("managed");
     });
 
-    // The full commit-time rejection matrix for invariant managed profiles
-    // lives in src/__tests__/managed-profile-guard.test.ts.
+    // The full commit-time rejection matrix for invariant cloud profiles
+    // lives in src/__tests__/cloud-profile-guard.test.ts.
 
-    test("rejects provider edit on managed profile with disallowed-keys error", async () => {
+    test("rejects provider edit on cloud profile with disallowed-keys error", async () => {
       // The handler is `async`, so synchronous BadRequest throws still
       // surface as a rejected promise; assert via `.rejects.toThrow`.
       await expect(
@@ -1227,12 +1225,12 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
           body: { provider: "openai", model: "gpt-5" },
         }),
       ).rejects.toThrow(
-        /Cannot edit managed profile "balanced" fields \[provider, model\]/,
+        /Cannot edit cloud profile "balanced" fields \[provider, model\]/,
       );
     });
 
     test("rejects mixed-field bodies without partially applying anything", async () => {
-      // Neither label nor maxTokens is writable on a managed profile — the
+      // Neither label nor maxTokens is writable on a cloud profile — the
       // reject must fire before any write, so the saver is never invoked.
       await expect(
         replaceProfileRoute.handler({
@@ -1240,7 +1238,7 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
           body: { label: "Try", maxTokens: 999 },
         }),
       ).rejects.toThrow(
-        /Cannot edit managed profile "balanced" fields \[maxTokens, label\]/,
+        /Cannot edit cloud profile "balanced" fields \[maxTokens, label\]/,
       );
       // Reject path skips commitConfigWrite entirely — no provider reinit
       // or cache invalidation should fire on a guard rejection.
@@ -1323,7 +1321,7 @@ describe("PATCH /v1/config fallbackProfile write protection", () => {
     expect(initializeProvidersCalls).toBe(0);
   });
 
-  test("rejects a custom pointer at a managed backup name", async () => {
+  test("rejects a custom pointer at a cloud backup name", async () => {
     await expect(
       patchRoute.handler({
         body: {
@@ -1440,12 +1438,13 @@ describe("custom profile write normalization (complete overrides)", () => {
     });
     const saved = savedProfiles().partial;
     const contextWindow = saved.contextWindow as Record<string, unknown>;
-    expect(contextWindow.futureField).toBe("keep-me");
+    // Schema-canonical saves strip keys the schema doesn't know.
+    expect(contextWindow.futureField).toBeUndefined();
     expect(contextWindow.maxInputTokens).toBe(111);
     expect(saved.provider).toBe("anthropic");
   });
 
-  test("unknown profile keys survive completion of a touched entry", async () => {
+  test("unknown profile keys are stripped by the schema parse", async () => {
     (
       rawConfigFixture.llm as { profiles: Record<string, unknown> }
     ).profiles.partial = {
@@ -1458,7 +1457,7 @@ describe("custom profile write normalization (complete overrides)", () => {
       body: { path: "llm.profiles.partial.maxTokens", value: 999 },
     });
     const saved = savedProfiles().partial;
-    expect(saved.futureField).toBe("keep-me");
+    expect(saved.futureField).toBeUndefined();
     expect(saved.maxTokens).toBe(999);
     expect(saved.provider).toBe("anthropic");
   });
@@ -1474,7 +1473,7 @@ describe("custom profile write normalization (complete overrides)", () => {
     expect(saved.maxTokens).toBe(12345);
   });
 
-  test("a managed status re-enable stays a thin stub", async () => {
+  test("a cloud status re-enable stays a thin stub", async () => {
     (
       rawConfigFixture.llm as { profiles: Record<string, unknown> }
     ).profiles.balanced = { source: "managed", status: "disabled" };
@@ -1536,7 +1535,24 @@ describe("call-site override writes stay sparse", () => {
     ).callSites ?? {};
 
   beforeEach(() => {
-    rawConfigFixture = { llm: {} };
+    rawConfigFixture = {
+      llm: {
+        // The schema's superRefine rejects a call site that references an
+        // undefined profile, so the fixtures define the ones they point at.
+        profiles: {
+          mine: {
+            source: "user",
+            provider: "anthropic",
+            model: "claude-sonnet",
+          },
+          old: {
+            source: "user",
+            provider: "anthropic",
+            model: "claude-sonnet",
+          },
+        },
+      },
+    };
     seedRawConfig();
   });
 
@@ -1580,7 +1596,21 @@ describe("call-site override writes stay sparse", () => {
 
   test("an existing entry's own customization is preserved", async () => {
     rawConfigFixture = {
-      llm: { callSites: { recall: { profile: "old", maxTokens: 200 } } },
+      llm: {
+        profiles: {
+          mine: {
+            source: "user",
+            provider: "anthropic",
+            model: "claude-sonnet",
+          },
+          old: {
+            source: "user",
+            provider: "anthropic",
+            model: "claude-sonnet",
+          },
+        },
+        callSites: { recall: { profile: "old", maxTokens: 200 } },
+      },
     };
     seedRawConfig();
     await configPatchRoute.handler({
@@ -1647,7 +1677,7 @@ describe("sparse services.stt patch provider seeding", () => {
     expect(parsed.stt.language).toBe("hi");
     expect(parsed.stt.provider).toBe(effectiveProvider);
     // Unrelated tts settings survive: no services-section reset happened.
-    expect(savedServices().tts).toEqual({ provider: "elevenlabs" });
+    expect(savedServices().tts).toMatchObject({ provider: "elevenlabs" });
   });
 
   test("language patch onto a config that has a provider is a pure merge", async () => {
@@ -1679,13 +1709,17 @@ describe("sparse services.stt patch provider seeding", () => {
     expect(stt.providers).toEqual({ deepgram: {} });
   });
 
-  test("a patch not touching stt invents no stt block", async () => {
+  test("a patch not touching stt leaves the materialized block intact", async () => {
     await configPatchRoute.handler({
       body: { heartbeat: { activeHoursStart: 9 } },
     });
 
-    expect(savedServices().stt).toBeUndefined();
-    expect(savedServices().tts).toEqual({ provider: "elevenlabs" });
+    // The merge base is the parsed config, whose stt block carries the
+    // schema default — complete and provider-backed, so the LUM-2758
+    // salvage family (a sparse invented block) cannot occur.
+    expect(savedServices().stt).toMatchObject({ language: "multi" });
+    expect(typeof savedServices().stt!.provider).toBe("string");
+    expect(savedServices().tts).toMatchObject({ provider: "elevenlabs" });
   });
 
   test("a config_set language write onto a sparse config seeds the provider", async () => {
@@ -1704,7 +1738,7 @@ describe("sparse services.stt patch provider seeding", () => {
     expect(stt.provider).toBe(effectiveProvider);
     const parsed = getConfig().services;
     expect(parsed.stt.language).toBe("hi");
-    expect(savedServices().tts).toEqual({ provider: "elevenlabs" });
+    expect(savedServices().tts).toMatchObject({ provider: "elevenlabs" });
   });
 
   test("a config_set onto a config with a provider leaves it untouched", async () => {
@@ -1754,7 +1788,7 @@ describe("config invariant flag enrichment", () => {
             label: "OS Beta",
             status: "active",
           },
-          // A user-owned profile sharing a managed name: no invariant flag —
+          // A user-owned profile sharing a cloud name: no invariant flag —
           // the stamp is gated on `source: "managed"` to match the guard.
           "cost-optimized": {
             source: "user",
@@ -2016,26 +2050,21 @@ describe("config writes to a per-agent acp entry", () => {
     expect(loadConfig().acp.agents.claude?.command).toBeUndefined();
   });
 
-  test("a nulled command on an id with no bundled profile is dropped too", async () => {
+  test("a nulled command on an id with no bundled profile is rejected", async () => {
     rawConfigFixture = {
       acp: { agents: { mine: { command: "my-acp", args: [] } } },
     };
     seedRawConfig();
 
-    await setRoute.handler({
-      body: { path: "acp.agents.mine.command", value: null },
-    });
-
-    expect("command" in agentEntry(loadRawConfig(), "mine")).toBe(false);
-    const result = AssistantConfigSchema.safeParse(loadRawConfig());
-    expect(result.success).toBe(false);
-    if (result.success) {
-      return;
-    }
-    expect(result.error.issues.map((issue) => issue.path)).toEqual([
-      ["acp", "agents", "mine", "command"],
-    ]);
-    expect(result.error.issues[0]?.message).toContain("acp.agents.mine");
+    // The agents refinement requires a command for an id with no bundled
+    // profile; the schema-validated write rejects instead of persisting a
+    // config whose next load would salvage-drop the whole acp section.
+    await expect(
+      setRoute.handler({
+        body: { path: "acp.agents.mine.command", value: null },
+      }),
+    ).rejects.toMatchObject({ statusCode: 400 });
+    expect(agentEntry(loadRawConfig(), "mine").command).toBe("my-acp");
   });
 
   test("a model set on a bare bundled entry survives the next load", async () => {
@@ -2105,7 +2134,7 @@ describe("persisted chat settings", () => {
       { notifications: { newMessageEnabled: "false" } },
       { notifications: { newMessageEnabled: null } },
     ])(
-      `${writer} unrelated writes preserve untouched legacy values: %j`,
+      `${writer} unrelated writes succeed over malformed sections: %j`,
       async (legacy) => {
         rawConfigFixture = { ...legacy, maxStepsPerSession: 75 };
         seedRawConfig();
@@ -2113,10 +2142,11 @@ describe("persisted chat settings", () => {
 
         await writeSetting(writer, "maxStepsPerSession", 100);
 
-        expect(loadRawConfig()).toEqual({
-          ...rawConfigFixture,
-          maxStepsPerSession: 100,
-        });
+        // The loader's read-time recovery cleans malformed sections before
+        // the merge, so no malformed value can block an unrelated write;
+        // schema-canonical saves materialize defaults around what the user
+        // set (the PATCH/SET writers heal the section, canonical rides).
+        expect(loadRawConfig()).toMatchObject({ maxStepsPerSession: 100 });
         expect(initializeProvidersCalls).toBe(1);
         expect(clearEmbeddingBackendCacheCalls).toBe(1);
       },
@@ -2124,7 +2154,7 @@ describe("persisted chat settings", () => {
 
     test(`${writer} can repair one leaf without changing other legacy values`, async () => {
       rawConfigFixture = {
-        conversations: { autoArchive: { enabled: "true", afterDays: 2 } },
+        conversations: { autoArchive: { enabled: "true", afterDays: 14 } },
         notifications: null,
       };
       seedRawConfig();
@@ -2132,9 +2162,8 @@ describe("persisted chat settings", () => {
 
       await writeSetting(writer, "conversations.autoArchive.enabled", true);
 
-      expect(loadRawConfig()).toEqual({
-        conversations: { autoArchive: { enabled: true, afterDays: 2 } },
-        notifications: null,
+      expect(loadRawConfig()).toMatchObject({
+        conversations: { autoArchive: { enabled: true, afterDays: 14 } },
       });
     });
 
@@ -2202,22 +2231,27 @@ describe("persisted chat settings", () => {
       body: { conversations: { autoArchive: { enabled: null } } },
     });
 
-    expect(loadRawConfig()).toEqual({
-      conversations: { autoArchive: { afterDays: null } },
-      notifications: { newMessageEnabled: null },
+    // Nulled leaves reset to the schema default on the canonical save (the
+    // read-time recovery had already cleaned the stored nulls).
+    expect(loadConfig().conversations.autoArchive).toEqual({
+      enabled: false,
+      afterDays: 7,
     });
   });
 
-  test("sparse GET exposes effective defaults without materializing unrelated fields", async () => {
+  test("sparse GET returns the fully materialized typed config with effective chat settings", async () => {
     rawConfigFixture = {};
     seedRawConfig();
     invalidateConfigCache();
     const result = await getRoute.handler({});
     expect(result).toMatchObject({
-      conversations: { autoArchive: { enabled: false, afterDays: 7 } },
+      conversations: {
+        autoArchive: { enabled: false, afterDays: 7 },
+        skipAutoRetitling: false,
+      },
       notifications: { newMessageEnabled: true },
     });
-    expect(result).not.toHaveProperty("conversations.skipAutoRetitling");
+    // Materialization is wire-only: nothing is written back to disk.
     expect(loadRawConfig()).not.toHaveProperty("conversations");
     expect(loadRawConfig()).not.toHaveProperty("notifications");
   });
@@ -2237,17 +2271,18 @@ describe("persisted chat settings", () => {
       expect(result).toMatchObject({
         conversations: {
           skipAutoRetitling: true,
-          autoArchive: { enabled: true, afterDays: 30, futureOption: "keep" },
+          autoArchive: { enabled: true, afterDays: 30 },
         },
-        notifications: { newMessageEnabled: false, futureOption: "keep" },
+        notifications: { newMessageEnabled: false },
         maxStepsPerSession: 75,
       });
-      expect(loadRawConfig()).toEqual({
-        ...rawConfigFixture,
+      expect(loadRawConfig()).toMatchObject({
+        maxStepsPerSession: 75,
         conversations: {
           skipAutoRetitling: true,
-          autoArchive: { enabled: true, afterDays: 30, futureOption: "keep" },
+          autoArchive: { enabled: true, afterDays: 30 },
         },
+        notifications: { newMessageEnabled: false },
       });
       invalidateConfigCache();
       expect(loadConfig().conversations.autoArchive).toEqual({
@@ -2280,20 +2315,21 @@ describe("persisted chat settings", () => {
     expect(result).toMatchObject({
       conversations: {
         skipAutoRetitling: true,
-        autoArchive: { enabled: false, afterDays: 7, futureOption: "keep" },
+        autoArchive: { enabled: false, afterDays: 7 },
       },
-      notifications: { newMessageEnabled: true, futureOption: "keep" },
+      notifications: { newMessageEnabled: true },
     });
-    expect(loadRawConfig()).toMatchObject({
-      conversations: { autoArchive: { futureOption: "keep" } },
-      notifications: { futureOption: "keep" },
+    // The nulled leaves restore to the schema defaults on the canonical
+    // save; the unknown sibling key (futureOption) doesn't persist.
+    expect(loadConfig().conversations.autoArchive).toEqual({
+      enabled: false,
+      afterDays: 7,
     });
-    expect(loadRawConfig()).not.toHaveProperty(
-      "conversations.autoArchive.enabled",
-    );
-    expect(loadRawConfig()).not.toHaveProperty(
-      "notifications.newMessageEnabled",
-    );
+    expect(loadConfig().notifications.newMessageEnabled).toBe(true);
+    expect(
+      "futureOption" in
+        (loadRawConfig().conversations as Record<string, unknown>),
+    ).toBe(false);
   });
 
   test.each([
@@ -2305,8 +2341,13 @@ describe("persisted chat settings", () => {
       conversations: { autoArchive: { enabled: false, afterDays: 7 } },
       notifications: { newMessageEnabled: true },
     });
-    expect(loadRawConfig()).not.toHaveProperty("conversations.autoArchive");
-    expect(loadRawConfig()).not.toHaveProperty("notifications");
+    // The nulled subtrees restore to the schema defaults on the canonical
+    // save — the same values a fresh read would materialize.
+    expect(loadConfig().conversations.autoArchive).toEqual({
+      enabled: false,
+      afterDays: 7,
+    });
+    expect(loadConfig().notifications.newMessageEnabled).toBe(true);
   });
 
   test.each([
@@ -2351,7 +2392,9 @@ describe("persisted chat settings", () => {
         },
         notifications: { newMessageEnabled: false },
       });
-      expect(loadRawConfig()).toEqual({
+      // The valid legacy values ride; the malformed subtree heals to the
+      // schema defaults on the canonical save.
+      expect(loadRawConfig()).toMatchObject({
         conversations: { skipAutoRetitling: true },
         notifications: { newMessageEnabled: false },
         maxStepsPerSession: 75,
@@ -2378,7 +2421,7 @@ describe("persisted chat settings", () => {
         conversations: { autoArchive: { enabled: false, afterDays: 7 } },
         notifications: { newMessageEnabled: true },
       });
-      expect(loadRawConfig()).toEqual({ maxStepsPerSession: 75 });
+      expect(loadRawConfig()).toMatchObject({ maxStepsPerSession: 75 });
     },
   );
 
@@ -2387,10 +2430,11 @@ describe("persisted chat settings", () => {
       body: { path: "notifications.newMessageEnabled", value: true },
     });
     expect(loadConfig().notifications.newMessageEnabled).toBe(true);
-    expect(loadRawConfig()).toHaveProperty(
-      "notifications.futureOption",
-      "keep",
-    );
+    // Schema-canonical saves strip keys the schema doesn't know.
+    expect(
+      "futureOption" in
+        (loadRawConfig().notifications as Record<string, unknown>),
+    ).toBe(false);
   });
 
   test.each([

package/src/runtime/routes/__tests__/default-plugin-routes.test.ts

@@ -2,12 +2,12 @@
  * Default-plugin route resolution: a first-party default plugin's routes are
  * served in the `/x/plugins/<name>/` namespace from the app source tree
  * (`plugins/defaults/<dir>/routes/`), where `<name>` is `default-<dir>` (e.g.
- * `default-platform-hosted`) — the same `default-…` name its `.disabled`
+ * `default-cloud-hosted`) — the same `default-…` name its `.disabled`
  * sentinel is keyed by — not its bare directory name. An installed workspace
  * plugin of the same name overrides the default.
  *
- * These tests exercise the real `platform-hosted` default plugin (namespace
- * `default-platform-hosted`), which ships `routes/reengage.ts`, a POST-only
+ * These tests exercise the real `cloud-hosted` default plugin (namespace
+ * `default-cloud-hosted`), which ships `routes/reengage.ts`, a POST-only
  * handler. A GET reaches the resolved source file and 405s — proving
  * resolution + source-tree module load without running the handler's heavy
  * background-turn logic.
@@ -37,7 +37,7 @@ import {
 } from "../user-route-resolution.js";
 
 /** The default plugin's source directory name. */
-const DEFAULT_PLUGIN_DIR = "platform-hosted";
+const DEFAULT_PLUGIN_DIR = "cloud-hosted";
 /** Its route namespace = `default-<dir>` by convention. */
 const DEFAULT_PLUGIN = `default-${DEFAULT_PLUGIN_DIR}`;
 
@@ -86,7 +86,7 @@ describe("default plugin route source resolution", () => {
     expect(getDefaultPluginRoutesDir("default-../util")).toBeNull();
   });
 
-  test("getDefaultPluginRouteRoots includes the platform-hosted plugin under its manifest name", () => {
+  test("getDefaultPluginRouteRoots includes the cloud-hosted plugin under its manifest name", () => {
     const roots = getDefaultPluginRouteRoots();
     const entry = roots.find((r) => r.pluginName === DEFAULT_PLUGIN);
     expect(entry).toBeDefined();

package/src/runtime/routes/__tests__/default-provider-routes.test.ts

@@ -13,10 +13,10 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 let managedProxyEnabled = false;
 let managedProxyBaseUrl = "https://platform.example";
-mock.module("../../../providers/platform-proxy/context.js", () => ({
-  resolveManagedProxyContext: async () => ({
+mock.module("../../../providers/cloud-proxy/context.js", () => ({
+  resolveCloudProxyContext: async () => ({
     enabled: managedProxyEnabled,
-    platformBaseUrl: managedProxyBaseUrl,
+    cloudBaseUrl: managedProxyBaseUrl,
     assistantApiKey: managedProxyEnabled ? "key" : "",
   }),
 }));
@@ -147,7 +147,7 @@ describe("GET config/llm/default-provider", () => {
     managedProxyBaseUrl = "";
     const result = await get();
     expect(availability(result).status).toBe("cadet_unauthenticated");
-    expect(availability(result).message).toContain("platform URL");
+    expect(availability(result).message).toContain("cloud URL");
   });
 
   test("cadet default with no canonical row → missing_connection", async () => {
@@ -157,7 +157,7 @@ describe("GET config/llm/default-provider", () => {
     expect(availability(result).status).toBe("missing_connection");
   });
 
-  test("user-owned connection claiming the cadet name → the platform's own status", async () => {
+  test("user-owned connection claiming the cadet name → the cloud's own status", async () => {
     // seedCanonicalConnections skips reseeding when a user row claims the
     // name. Dispatch ignores that row and routes through cloud auth, so a
     // signed-in platform is genuinely usable and reads as ok.
@@ -174,7 +174,7 @@ describe("GET config/llm/default-provider", () => {
     expect(availability(result).status).toBe("ok");
   });
 
-  test("cloud-auth connection for a non-managed provider → unsupported_auth even when signed in", async () => {
+  test("cloud-auth connection for a non-cloud provider → unsupported_auth even when signed in", async () => {
     seedConnection({
       name: "openrouter-personal",
       provider: "openrouter",
@@ -323,7 +323,7 @@ describe("GET config/llm/default-provider", () => {
     expect(availability(result).message).toContain('"openai"');
   });
 
-  test("cadet-managed connection pinned for a managed-routable provider follows cloud auth", async () => {
+  test("cadet-cloud connection pinned for a cloud-routable provider follows cloud auth", async () => {
     seedConnection({
       name: "cadet",
       provider: "cadet",
@@ -338,7 +338,7 @@ describe("GET config/llm/default-provider", () => {
     expect(availability(await get()).status).toBe("ok");
   });
 
-  test("cadet-managed connection pinned for a non-managed provider → provider_mismatch", async () => {
+  test("cadet-cloud connection pinned for a non-cloud provider → provider_mismatch", async () => {
     seedConnection({
       name: "cadet",
       provider: "cadet",
@@ -351,7 +351,7 @@ describe("GET config/llm/default-provider", () => {
 
     const result = await get();
     expect(availability(result).status).toBe("provider_mismatch");
-    expect(availability(result).message).toContain("Cadet-managed");
+    expect(availability(result).message).toContain("Cadet Cloud");
   });
 
   test("service_account connection with invalid credential → missing_credential", async () => {
@@ -368,7 +368,7 @@ describe("GET config/llm/default-provider", () => {
     expect(availability(result).message).toContain("service-account");
   });
 
-  test("platform-auth connection follows managed-proxy state", async () => {
+  test("cloud-auth connection follows cloud-proxy state", async () => {
     seedConnection({
       name: "anthropic-personal",
       provider: "anthropic",