@mycadet/assistant 0.12.7 → 0.12.8

package/src/config/__tests__/{platform-identity.test.ts → cloud-identity.test.ts}

@@ -2,27 +2,26 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 import { useMemorySecureKeys } from "../../__tests__/helpers/secure-keys.js";
 import {
-  getPlatformBaseUrl,
-  setPlatformAssistantId,
-  setPlatformBaseUrl,
-  setPlatformOrganizationId,
-  setPlatformUserId,
+  getCloudBaseUrl,
+  setCloudAssistantId,
+  setCloudOrganizationId,
+  setCloudUserId,
 } from "../env.js";
 
 useMemorySecureKeys();
 const {
-  _resetPlatformIdentityEnsureForTests,
-  fetchPlatformIdentityIds,
-  PLATFORM_IDENTITY_VALIDATE_PATH,
-  resolvePlatformAssistantId,
-} = await import("../platform-identity.js");
+  _resetCloudIdentityEnsureForTests,
+  fetchCloudIdentityIds,
+  CLOUD_IDENTITY_VALIDATE_PATH,
+  resolveCloudAssistantId,
+} = await import("../cloud-identity.js");
 
 const BASE_URL = "https://cloud.mycadet.ai";
 const ASSISTANT_ID = "11111111-2222-4333-8444-555555555555";
 const ORG_ID = "22222222-3333-4444-8555-666666666666";
 const USER_ID = "33333333-4444-4555-8666-777777777777";
 
-describe("fetchPlatformIdentityIds", () => {
+describe("fetchCloudIdentityIds", () => {
   const originalFetch = globalThis.fetch;
   const fetchCalls: Array<{ url: string; init?: RequestInit }> = [];
   let fetchImpl: (
@@ -61,14 +60,14 @@ describe("fetchPlatformIdentityIds", () => {
       );
 
     await expect(
-      fetchPlatformIdentityIds(BASE_URL, "assistant-key"),
+      fetchCloudIdentityIds(BASE_URL, "assistant-key"),
     ).resolves.toEqual({
       assistantId: ASSISTANT_ID,
       organizationId: ORG_ID,
       userId: USER_ID,
     });
     expect(fetchCalls[0]?.url).toBe(
-      `${BASE_URL}${PLATFORM_IDENTITY_VALIDATE_PATH}`,
+      `${BASE_URL}${CLOUD_IDENTITY_VALIDATE_PATH}`,
     );
     expect(fetchCalls[0]?.init?.method).toBe("POST");
     const headers = new Headers(fetchCalls[0]?.init?.headers);
@@ -86,16 +85,16 @@ describe("fetchPlatformIdentityIds", () => {
         { status: 200 },
       );
 
-    await fetchPlatformIdentityIds(`${BASE_URL}/`, "assistant-key");
+    await fetchCloudIdentityIds(`${BASE_URL}/`, "assistant-key");
     expect(fetchCalls[0]?.url).toBe(
-      `${BASE_URL}${PLATFORM_IDENTITY_VALIDATE_PATH}`,
+      `${BASE_URL}${CLOUD_IDENTITY_VALIDATE_PATH}`,
     );
   });
 
   test("returns null on 401 without throwing", async () => {
     fetchImpl = async () => new Response("no", { status: 401 });
     await expect(
-      fetchPlatformIdentityIds(BASE_URL, "assistant-key"),
+      fetchCloudIdentityIds(BASE_URL, "assistant-key"),
     ).resolves.toBeNull();
   });
 
@@ -104,15 +103,15 @@ describe("fetchPlatformIdentityIds", () => {
       throw new Error("network down");
     };
     await expect(
-      fetchPlatformIdentityIds(BASE_URL, "assistant-key"),
+      fetchCloudIdentityIds(BASE_URL, "assistant-key"),
     ).resolves.toBeNull();
   });
 });
 
-describe("resolvePlatformAssistantId", () => {
+describe("resolveCloudAssistantId", () => {
   const originalFetch = globalThis.fetch;
   const originalAssistantApiKeyEnv = process.env.ASSISTANT_API_KEY;
-  const originalPlatformUrlEnv = process.env.CADET_PLATFORM_URL;
+  const originalCloudUrlEnv = process.env.CADET_CLOUD_URL;
   const fetchCalls: Array<{ url: string; init?: RequestInit }> = [];
   let fetchImpl: (
     input: RequestInfo | URL,
@@ -132,11 +131,11 @@ describe("resolvePlatformAssistantId", () => {
       return fetchImpl(input, init);
     }) as unknown as typeof fetch;
     delete process.env.ASSISTANT_API_KEY;
-    setPlatformBaseUrl(undefined);
-    setPlatformAssistantId(undefined);
-    setPlatformOrganizationId(undefined);
-    setPlatformUserId(undefined);
-    _resetPlatformIdentityEnsureForTests();
+    delete process.env.CADET_CLOUD_URL;
+    setCloudAssistantId(undefined);
+    setCloudOrganizationId(undefined);
+    setCloudUserId(undefined);
+    _resetCloudIdentityEnsureForTests();
   });
 
   afterEach(() => {
@@ -146,33 +145,32 @@ describe("resolvePlatformAssistantId", () => {
     } else {
       process.env.ASSISTANT_API_KEY = originalAssistantApiKeyEnv;
     }
-    if (originalPlatformUrlEnv === undefined) {
-      delete process.env.CADET_PLATFORM_URL;
+    if (originalCloudUrlEnv === undefined) {
+      delete process.env.CADET_CLOUD_URL;
     } else {
-      process.env.CADET_PLATFORM_URL = originalPlatformUrlEnv;
+      process.env.CADET_CLOUD_URL = originalCloudUrlEnv;
     }
-    setPlatformBaseUrl(undefined);
-    setPlatformAssistantId(undefined);
-    setPlatformOrganizationId(undefined);
-    setPlatformUserId(undefined);
-    _resetPlatformIdentityEnsureForTests();
+    setCloudAssistantId(undefined);
+    setCloudOrganizationId(undefined);
+    setCloudUserId(undefined);
+    _resetCloudIdentityEnsureForTests();
   });
 
   test("returns the in-memory override without calling validate", async () => {
-    setPlatformAssistantId(ASSISTANT_ID);
+    setCloudAssistantId(ASSISTANT_ID);
     process.env.ASSISTANT_API_KEY = "assistant-key";
-    await expect(resolvePlatformAssistantId()).resolves.toBe(ASSISTANT_ID);
+    await expect(resolveCloudAssistantId()).resolves.toBe(ASSISTANT_ID);
     expect(fetchCalls).toHaveLength(0);
   });
 
   test("returns empty when the in-memory override is unset and there is no API key", async () => {
-    await expect(resolvePlatformAssistantId()).resolves.toBe("");
+    await expect(resolveCloudAssistantId()).resolves.toBe("");
     expect(fetchCalls).toHaveLength(0);
   });
 
   test("loads ids from validate when the in-memory override is empty", async () => {
     process.env.ASSISTANT_API_KEY = "assistant-key";
-    setPlatformBaseUrl(BASE_URL);
+    process.env.CADET_CLOUD_URL = BASE_URL;
     fetchImpl = async () =>
       new Response(
         JSON.stringify({
@@ -183,29 +181,29 @@ describe("resolvePlatformAssistantId", () => {
         { status: 200 },
       );
 
-    await expect(resolvePlatformAssistantId()).resolves.toBe(ASSISTANT_ID);
+    await expect(resolveCloudAssistantId()).resolves.toBe(ASSISTANT_ID);
     expect(fetchCalls).toHaveLength(1);
     expect(fetchCalls[0]?.url).toBe(
-      `${getPlatformBaseUrl().replace(/\/+$/, "")}${PLATFORM_IDENTITY_VALIDATE_PATH}`,
+      `${getCloudBaseUrl().replace(/\/+$/, "")}${CLOUD_IDENTITY_VALIDATE_PATH}`,
     );
   });
 
   test("does not retry validate during the cooldown after a failure", async () => {
     process.env.ASSISTANT_API_KEY = "assistant-key";
-    setPlatformBaseUrl(BASE_URL);
+    process.env.CADET_CLOUD_URL = BASE_URL;
     fetchImpl = async () => new Response("down", { status: 503 });
 
-    await expect(resolvePlatformAssistantId()).resolves.toBe("");
-    await expect(resolvePlatformAssistantId()).resolves.toBe("");
+    await expect(resolveCloudAssistantId()).resolves.toBe("");
+    await expect(resolveCloudAssistantId()).resolves.toBe("");
     expect(fetchCalls).toHaveLength(1);
   });
 
   test("retries validate inside the cooldown once a different API key is stored", async () => {
     process.env.ASSISTANT_API_KEY = "rejected-key";
-    setPlatformBaseUrl(BASE_URL);
+    process.env.CADET_CLOUD_URL = BASE_URL;
     fetchImpl = async () => new Response("no", { status: 401 });
 
-    await expect(resolvePlatformAssistantId()).resolves.toBe("");
+    await expect(resolveCloudAssistantId()).resolves.toBe("");
     expect(fetchCalls).toHaveLength(1);
 
     process.env.ASSISTANT_API_KEY = "replacement-key";
@@ -219,7 +217,7 @@ describe("resolvePlatformAssistantId", () => {
         { status: 200 },
       );
 
-    await expect(resolvePlatformAssistantId()).resolves.toBe(ASSISTANT_ID);
+    await expect(resolveCloudAssistantId()).resolves.toBe(ASSISTANT_ID);
     expect(fetchCalls).toHaveLength(2);
     const headers = new Headers(fetchCalls[1]?.init?.headers);
     expect(headers.get("Authorization")).toBe("Api-Key replacement-key");
@@ -229,13 +227,13 @@ describe("resolvePlatformAssistantId", () => {
     process.env.ASSISTANT_API_KEY = "assistant-key";
     // The environment URL outranks the in-memory override (and the test
     // preload sets one), so the base URL is changed through the environment.
-    process.env.CADET_PLATFORM_URL = "https://old.example.com";
+    process.env.CADET_CLOUD_URL = "https://old.example.com";
     fetchImpl = async () => new Response("no", { status: 401 });
 
-    await expect(resolvePlatformAssistantId()).resolves.toBe("");
+    await expect(resolveCloudAssistantId()).resolves.toBe("");
     expect(fetchCalls).toHaveLength(1);
 
-    process.env.CADET_PLATFORM_URL = BASE_URL;
+    process.env.CADET_CLOUD_URL = BASE_URL;
     fetchImpl = async () =>
       new Response(
         JSON.stringify({
@@ -246,20 +244,20 @@ describe("resolvePlatformAssistantId", () => {
         { status: 200 },
       );
 
-    await expect(resolvePlatformAssistantId()).resolves.toBe(ASSISTANT_ID);
+    await expect(resolveCloudAssistantId()).resolves.toBe(ASSISTANT_ID);
     expect(fetchCalls).toHaveLength(2);
     expect(fetchCalls[1]?.url).toBe(
-      `${BASE_URL}${PLATFORM_IDENTITY_VALIDATE_PATH}`,
+      `${BASE_URL}${CLOUD_IDENTITY_VALIDATE_PATH}`,
     );
   });
 
   test("retries validate after a failed attempt once the cooldown is cleared", async () => {
     process.env.ASSISTANT_API_KEY = "assistant-key";
-    setPlatformBaseUrl(BASE_URL);
+    process.env.CADET_CLOUD_URL = BASE_URL;
     fetchImpl = async () => new Response("down", { status: 503 });
 
-    await expect(resolvePlatformAssistantId()).resolves.toBe("");
-    _resetPlatformIdentityEnsureForTests();
+    await expect(resolveCloudAssistantId()).resolves.toBe("");
+    _resetCloudIdentityEnsureForTests();
     fetchImpl = async () =>
       new Response(
         JSON.stringify({
@@ -270,13 +268,13 @@ describe("resolvePlatformAssistantId", () => {
         { status: 200 },
       );
 
-    await expect(resolvePlatformAssistantId()).resolves.toBe(ASSISTANT_ID);
+    await expect(resolveCloudAssistantId()).resolves.toBe(ASSISTANT_ID);
     expect(fetchCalls).toHaveLength(2);
   });
 
   test("concurrent resolves share one in-flight validate", async () => {
     process.env.ASSISTANT_API_KEY = "assistant-key";
-    setPlatformBaseUrl(BASE_URL);
+    process.env.CADET_CLOUD_URL = BASE_URL;
     let release!: (value: Response) => void;
     let notifyFetchStarted!: () => void;
     const fetchStarted = new Promise<void>((resolve) => {
@@ -289,8 +287,8 @@ describe("resolvePlatformAssistantId", () => {
       });
     };
 
-    const first = resolvePlatformAssistantId();
-    const second = resolvePlatformAssistantId();
+    const first = resolveCloudAssistantId();
+    const second = resolveCloudAssistantId();
     await fetchStarted;
     expect(fetchCalls).toHaveLength(1);
     release(

package/src/config/__tests__/{platform-rehydration.test.ts → cloud-rehydration.test.ts}

@@ -18,29 +18,26 @@ mock.module("../../security/secure-keys.js", () => ({
 }));
 
 const {
-  getPlatformAssistantId,
-  getPlatformBaseUrl,
-  getPlatformOrganizationId,
-  getPlatformUserId,
-  setPlatformAssistantId,
-  setPlatformBaseUrl,
-  setPlatformOrganizationId,
-  setPlatformUserId,
+  getCloudAssistantId,
+  getCloudOrganizationId,
+  getCloudUserId,
+  setCloudAssistantId,
+  setCloudOrganizationId,
+  setCloudUserId,
 } = await import("../env.js");
-const { _resetPlatformIdentityEnsureForTests } =
-  await import("../platform-identity.js");
-const { rehydratePlatformCredentials } =
-  await import("../platform-rehydration.js");
+const { _resetCloudIdentityEnsureForTests } =
+  await import("../cloud-identity.js");
+const { rehydrateCloudCredentials } = await import("../cloud-rehydration.js");
 
 const PROD_URL = "https://cloud.mycadet.ai";
 const ASSISTANT_ID = "11111111-2222-4333-8444-555555555555";
 const ORG_ID = "22222222-3333-4444-8555-666666666666";
 const USER_ID = "33333333-4444-4555-8666-777777777777";
 
-describe("rehydratePlatformCredentials", () => {
-  const originalPlatformUrlEnv = process.env.CADET_PLATFORM_URL;
-  const originalOrgEnv = process.env.PLATFORM_ORGANIZATION_ID;
-  const originalUserEnv = process.env.PLATFORM_USER_ID;
+describe("rehydrateCloudCredentials", () => {
+  const originalCloudUrlEnv = process.env.CADET_CLOUD_URL;
+  const originalOrgEnv = process.env.CLOUD_ORGANIZATION_ID;
+  const originalUserEnv = process.env.CLOUD_USER_ID;
   const originalAssistantApiKeyEnv = process.env.ASSISTANT_API_KEY;
   const originalFetch = globalThis.fetch;
   const fetchCalls: Array<{ url: string; init?: RequestInit }> = [];
@@ -65,87 +62,61 @@ describe("rehydratePlatformCredentials", () => {
     }) as unknown as typeof fetch;
     // Env vars take precedence over the rehydrated overrides for some fields;
     // clear them so the credential-store values are what we observe.
-    delete process.env.CADET_PLATFORM_URL;
-    delete process.env.PLATFORM_ORGANIZATION_ID;
-    delete process.env.PLATFORM_USER_ID;
+    delete process.env.CADET_CLOUD_URL;
+    delete process.env.CLOUD_ORGANIZATION_ID;
+    delete process.env.CLOUD_USER_ID;
     delete process.env.ASSISTANT_API_KEY;
     // Reset in-memory overrides between tests.
-    setPlatformBaseUrl(undefined);
-    setPlatformAssistantId(undefined);
-    setPlatformOrganizationId(undefined);
-    setPlatformUserId(undefined);
-    _resetPlatformIdentityEnsureForTests();
+    setCloudAssistantId(undefined);
+    setCloudOrganizationId(undefined);
+    setCloudUserId(undefined);
+    _resetCloudIdentityEnsureForTests();
   });
 
   afterEach(() => {
     globalThis.fetch = originalFetch;
-    if (originalPlatformUrlEnv === undefined) {
-      delete process.env.CADET_PLATFORM_URL;
+    if (originalCloudUrlEnv === undefined) {
+      delete process.env.CADET_CLOUD_URL;
     } else {
-      process.env.CADET_PLATFORM_URL = originalPlatformUrlEnv;
+      process.env.CADET_CLOUD_URL = originalCloudUrlEnv;
     }
     if (originalOrgEnv === undefined) {
       delete process.env.PLATFORM_ORGANIZATION_ID;
     } else {
-      process.env.PLATFORM_ORGANIZATION_ID = originalOrgEnv;
+      process.env.CLOUD_ORGANIZATION_ID = originalOrgEnv;
     }
     if (originalUserEnv === undefined) {
       delete process.env.PLATFORM_USER_ID;
     } else {
-      process.env.PLATFORM_USER_ID = originalUserEnv;
+      process.env.CLOUD_USER_ID = originalUserEnv;
     }
     if (originalAssistantApiKeyEnv === undefined) {
       delete process.env.ASSISTANT_API_KEY;
     } else {
       process.env.ASSISTANT_API_KEY = originalAssistantApiKeyEnv;
     }
-    setPlatformBaseUrl(undefined);
-    setPlatformAssistantId(undefined);
-    setPlatformOrganizationId(undefined);
-    setPlatformUserId(undefined);
-  });
-
-  test("rehydrates the platform base URL from the credential store", async () => {
-    mockSecureKeys[credentialKey("cadet", "platform_base_url")] = PROD_URL;
-    mockSecureKeys[credentialKey("cadet", "platform_assistant_id")] =
-      ASSISTANT_ID;
-    mockSecureKeys[credentialKey("cadet", "platform_organization_id")] = ORG_ID;
-    mockSecureKeys[credentialKey("cadet", "platform_user_id")] = USER_ID;
-
-    await rehydratePlatformCredentials();
-
-    expect(getPlatformBaseUrl()).toBe(PROD_URL);
-    expect(getPlatformAssistantId()).toBe("");
-    expect(getPlatformOrganizationId()).toBe("");
-    expect(getPlatformUserId()).toBe("");
-  });
-
-  test("trims stored values before applying them", async () => {
-    mockSecureKeys[credentialKey("cadet", "platform_base_url")] =
-      `  ${PROD_URL}  `;
-
-    await rehydratePlatformCredentials();
-
-    expect(getPlatformBaseUrl()).toBe(PROD_URL);
+    setCloudAssistantId(undefined);
+    setCloudOrganizationId(undefined);
+    setCloudUserId(undefined);
   });
 
   test("leaves overrides untouched when nothing is stored", async () => {
-    await rehydratePlatformCredentials();
+    await rehydrateCloudCredentials();
 
-    expect(getPlatformAssistantId()).toBe("");
-    expect(getPlatformOrganizationId()).toBe("");
-    expect(getPlatformUserId()).toBe("");
+    expect(getCloudAssistantId()).toBe("");
+    expect(getCloudOrganizationId()).toBe("");
+    expect(getCloudUserId()).toBe("");
   });
 
   test("a credential-store read failure does not throw", async () => {
-    throwForKey = credentialKey("cadet", "platform_base_url");
+    throwForKey = credentialKey("cadet", "assistant_api_key");
 
-    await expect(rehydratePlatformCredentials()).resolves.toBeUndefined();
-    expect(getPlatformAssistantId()).toBe("");
+    await expect(rehydrateCloudCredentials()).resolves.toBeUndefined();
+    expect(getCloudAssistantId()).toBe("");
   });
 
-  test("trades the assistant API key for ids via platform validate", async () => {
-    mockSecureKeys[credentialKey("cadet", "platform_base_url")] = PROD_URL;
+  test("trades the assistant API key for ids via cloud validate", async () => {
+    process.env.CADET_CLOUD_URL = PROD_URL;
     mockSecureKeys[credentialKey("cadet", "assistant_api_key")] =
       "assistant-key";
     fetchImpl = async () =>
@@ -158,7 +129,7 @@ describe("rehydratePlatformCredentials", () => {
         { status: 200 },
       );
 
-    await rehydratePlatformCredentials();
+    await rehydrateCloudCredentials();
 
     expect(fetchCalls).toHaveLength(1);
     expect(fetchCalls[0]?.url).toBe(
@@ -166,13 +137,12 @@ describe("rehydratePlatformCredentials", () => {
     );
     const headers = new Headers(fetchCalls[0]?.init?.headers);
     expect(headers.get("Authorization")).toBe("Api-Key assistant-key");
-    expect(getPlatformAssistantId()).toBe(ASSISTANT_ID);
-    expect(getPlatformOrganizationId()).toBe(ORG_ID);
-    expect(getPlatformUserId()).toBe(USER_ID);
+    expect(getCloudAssistantId()).toBe(ASSISTANT_ID);
+    expect(getCloudOrganizationId()).toBe(ORG_ID);
+    expect(getCloudUserId()).toBe(USER_ID);
   });
 
   test("validate ids are used when the vault also has a copy", async () => {
-    mockSecureKeys[credentialKey("cadet", "platform_base_url")] = PROD_URL;
     mockSecureKeys[credentialKey("cadet", "assistant_api_key")] =
       "assistant-key";
     mockSecureKeys[credentialKey("cadet", "platform_assistant_id")] =
@@ -187,27 +157,24 @@ describe("rehydratePlatformCredentials", () => {
         { status: 200 },
       );
 
-    await rehydratePlatformCredentials();
+    await rehydrateCloudCredentials();
 
-    expect(getPlatformAssistantId()).toBe(ASSISTANT_ID);
+    expect(getCloudAssistantId()).toBe(ASSISTANT_ID);
   });
 
   test("does not populate ids from the vault when validate is unreachable", async () => {
-    mockSecureKeys[credentialKey("cadet", "platform_base_url")] = PROD_URL;
     mockSecureKeys[credentialKey("cadet", "assistant_api_key")] =
       "assistant-key";
     mockSecureKeys[credentialKey("cadet", "platform_assistant_id")] =
       ASSISTANT_ID;
-    mockSecureKeys[credentialKey("cadet", "platform_organization_id")] = ORG_ID;
-    mockSecureKeys[credentialKey("cadet", "platform_user_id")] = USER_ID;
     fetchImpl = async () => {
       throw new Error("network down");
     };
 
-    await rehydratePlatformCredentials();
+    await rehydrateCloudCredentials();
 
-    expect(getPlatformAssistantId()).toBe("");
-    expect(getPlatformOrganizationId()).toBe("");
-    expect(getPlatformUserId()).toBe("");
+    expect(getCloudAssistantId()).toBe("");
+    expect(getCloudOrganizationId()).toBe("");
+    expect(getCloudUserId()).toBe("");
   });
 });

package/src/config/__tests__/default-profile-catalog.test.ts

@@ -52,7 +52,7 @@ describe("getEffectiveProfiles", () => {
     }
   });
 
-  test("every cadet-column body translates to a managed dispatch target", () => {
+  test("every cadet-column body translates to a cloud dispatch target", () => {
     for (const key of [...DEFAULT_PROFILE_KEYS, OS_BETA_PROFILE_KEY]) {
       const body = CODE_DEFAULT_PROFILE_ENTRIES[key];
       const identity = resolveRoutingIdentity(body.provider, body.model);
@@ -61,7 +61,7 @@ describe("getEffectiveProfiles", () => {
     }
   });
 
-  test("the managed Jev profile routes jev-latest through TypeSafe and is managed-only", () => {
+  test("the cloud Jev profile routes jev-latest through TypeSafe and is managed-only", () => {
     const jev = CODE_DEFAULT_PROFILE_ENTRIES["jev-managed"];
     expect(jev.model).toBe("jev-latest");
     expect(jev.provider_connection).toBeUndefined();
@@ -80,7 +80,7 @@ describe("getEffectiveProfiles", () => {
     ).toBeUndefined();
   });
 
-  test("the Auto profile is the managed Balanced body relabeled, managed-only, and flag-gated", () => {
+  test("the Auto profile is the cloud Balanced body relabeled, managed-only, and flag-gated", () => {
     const auto = CODE_DEFAULT_PROFILE_ENTRIES.auto;
     const balanced = CODE_DEFAULT_PROFILE_ENTRIES.balanced;
     expect(auto.label).toBe("Auto");
@@ -109,7 +109,7 @@ describe("getEffectiveProfiles", () => {
     ).toContain("auto");
   });
 
-  test("the conversation view drops the managed Jev profile but keeps it selectable for call sites", () => {
+  test("the conversation view drops the cloud Jev profile but keeps it selectable for call sites", () => {
     expect(
       Object.keys(getConversationProfilesForProvider(undefined)),
     ).not.toContain("jev-managed");
@@ -121,7 +121,7 @@ describe("getEffectiveProfiles", () => {
     ).toContain("balanced");
   });
 
-  test("the managed Balanced profile routes GLM 5.3 Flash through Fireworks", () => {
+  test("the cloud Balanced profile routes GLM 5.3 Flash through Fireworks", () => {
     const balanced = CODE_DEFAULT_PROFILE_ENTRIES.balanced;
     expect(balanced.model).toBe("accounts/fireworks/models/glm-5p3-flash");
     expect(resolveRoutingIdentity(balanced.provider, balanced.model)).toEqual({
@@ -130,7 +130,7 @@ describe("getEffectiveProfiles", () => {
     });
   });
 
-  test("the managed Quality profile routes GPT-5.6 Sol through OpenAI", () => {
+  test("the cloud Quality profile routes GPT-5.6 Sol through OpenAI", () => {
     const quality = CODE_DEFAULT_PROFILE_ENTRIES["quality-optimized"];
     expect(quality.model).toBe("gpt-5.6-sol");
     expect(resolveRoutingIdentity(quality.provider, quality.model)).toEqual({
@@ -150,7 +150,7 @@ describe("getEffectiveProfiles", () => {
     expect(getEffectiveProfile({}, OS_BETA_PROFILE_KEY)).toBeUndefined();
   });
 
-  test("a managed-source entry resolves to the code body with only label/status/topP from disk", () => {
+  test("a cloud-source entry resolves to the code body with only label/status/topP from disk", () => {
     const workspace: Record<string, ProfileEntry> = {
       balanced: {
         source: "managed",
@@ -355,7 +355,7 @@ describe("resolver integration", () => {
     ).not.toThrow();
   });
 
-  test("a user profile cannot shadow a managed backup profile", () => {
+  test("a user profile cannot shadow a cloud backup profile", () => {
     // Every backup is code-owned for the same reason `latency-optimized` is:
     // a backup earns its place by pinning a different upstream than the
     // primary it backs, and a user shadow can repoint it at the primary's
@@ -381,7 +381,7 @@ describe("resolver integration", () => {
       expect(effective?.model).not.toBe("claude-opus-4-6");
       expect(String(effective?.provider)).toBe("cadet");
       expect(effective?.provider_connection).toBeUndefined();
-      // Resolution through the managed column agrees with the listing.
+      // Resolution through the cloud column agrees with the listing.
       const resolved = resolveDefaultProfileForProvider(llm.profiles, key, {
         provider: "cadet",
       });
@@ -450,7 +450,7 @@ describe("schema validation", () => {
     // User-endpoint and keyless providers have no code-resolvable default
     // profile implementation. The blob is a partial fragment (stripping the
     // provider would drop the blob's other fields), so they stay on disk and
-    // the read clamps them to null — resolution treats that as the managed
+    // the read clamps them to null — resolution treats that as the cloud
     // column.
     for (const provider of ["openai-compatible", "ollama"]) {
       const blobProvider = LLMSchema.parse({ default: { provider } }).default
@@ -569,7 +569,7 @@ describe("resolveDefaultProfileForProvider", () => {
     expect(entry?.model).toBe(resolveModelIntent("anthropic", "balanced"));
   });
 
-  test("the cadet column keeps its underlying dispatch provider and managed connection", () => {
+  test("the cadet column keeps its underlying dispatch provider and cloud connection", () => {
     const entry = resolveDefaultProfileForProvider(
       undefined,
       "balanced",
@@ -631,7 +631,7 @@ describe("resolveDefaultProfileForProvider", () => {
     }
   });
 
-  test("a managed-source stub contributes only label/status/topP over the provider-resolved body", () => {
+  test("a cloud-source stub contributes only label/status/topP over the provider-resolved body", () => {
     const workspace: Record<string, ProfileEntry> = {
       balanced: {
         source: "managed",

package/src/config/__tests__/default-provider.test.ts

@@ -39,7 +39,7 @@ afterAll(() => {
   mock.restore();
 });
 
-import { CADET_MANAGED_CONNECTION_NAME } from "../../providers/cadet-model-routing.js";
+import { CADET_CLOUD_CONNECTION_NAME } from "../../providers/cadet-model-routing.js";
 import {
   DefaultProviderSelectionSchema,
   resolveDefaultConnectionName,
@@ -106,7 +106,7 @@ describe("LLMSchema.default (the base blob)", () => {
   // The blob is a partial fragment with no `.catch`: a provider with no
   // matrix column stays on disk (stripping it would drop the blob's other
   // fields), and the READ clamps it to null — resolution treats that as the
-  // managed column.
+  // cloud column.
   test("a blob whose provider has no matrix column survives parse and clamps", () => {
     const parsed = LLMSchema.parse({
       default: { provider: "openai-compatible", model: "gpt-x" },
@@ -161,9 +161,9 @@ describe("resolveDefaultConnectionName", () => {
     ).toBe("my-connection");
   });
 
-  test("cadet resolves to the managed connection name", () => {
+  test("cadet resolves to the cloud connection name", () => {
     expect(resolveDefaultConnectionName({ provider: "cadet" })).toBe(
-      CADET_MANAGED_CONNECTION_NAME,
+      CADET_CLOUD_CONNECTION_NAME,
     );
   });