@mycadet/assistant 0.12.7 → 0.12.8

package/src/__tests__/plugin-api-webhook-url.test.ts

@@ -11,15 +11,14 @@
 import { afterEach, describe, expect, spyOn, test } from "bun:test";
 
 const loader = await import("../config/loader.js");
-const registration =
-  await import("../inbound/platform-callback-registration.js");
+const registration = await import("../inbound/cloud-callback-registration.js");
 const { resolveWebhookUrl } = await import("../plugin-api/webhook-url.js");
 const { runInPluginContext } =
   await import("../plugins/plugin-execution-context.js");
 
 describe("resolveWebhookUrl", () => {
   afterEach(() => {
-    delete process.env.IS_PLATFORM;
+    delete process.env.IS_CLOUD;
   });
   test("composes the plugin's namespaced path and delegates the tier choice", async () => {
     const spy = spyOn(registration, "resolveCallbackUrl").mockResolvedValue(
@@ -79,7 +78,7 @@ describe("resolveWebhookUrl", () => {
   });
 
   test("gives routes that share a slug distinct registration types", async () => {
-    // The platform keys a callback route by type, so a collision has the
+    // The cloud keys a callback route by type, so a collision has the
     // second registration replace the first. `events-v1` and `events_v1`
     // slugify identically.
     const spy = spyOn(registration, "resolveCallbackUrl").mockResolvedValue(
@@ -153,7 +152,7 @@ describe("resolveWebhookUrl", () => {
     // The Tunnel forwards the request path verbatim and the gateway
     // admits it only when it matches a claimed path byte for byte. A trailing
     // slash on this URL would be rejected before the gateway ever saw it.
-    process.env.IS_PLATFORM = "true";
+    process.env.IS_CLOUD = "true";
     const configSpy = spyOn(loader, "getConfig").mockReturnValue({
       ingress: { publicBaseUrl: "https://tunnel.mycadet.ai/assistant-abc" },
     } as ReturnType<typeof loader.getConfig>);

package/src/__tests__/plugin-import-boundary-guard.test.ts

@@ -49,6 +49,7 @@ const DEFAULTS_ABS = join(process.cwd(), DEFAULTS_REL);
  */
 const BASELINE: Record<string, readonly string[]> = {
   channel: ["../../types.js", "../injector-order.js"],
+  "cloud-hosted": ["node:fs/promises", "node:path"],
   compaction: [
     "../../../config/loader.js",
     "../../../config/schemas/compaction.js",
@@ -105,11 +106,6 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../../config/assistant-feature-flags.js",
     "../../../../config/default-profile-catalog.js",
     "../../../../config/loader.js",
-    // Sibling of the already-sanctioned memory-v3-gate: `memoryTier()` is
-    // defined as fully derived from that module's predicates, and the stats
-    // route reports both (`graph_supported` is exactly `tier === "v3"`).
-    // Re-deriving the tier inside the plugin would reintroduce exactly the
-    // drift the shared module exists to prevent. No plugin-api equivalent.
     "../../../../config/memory-tier.js",
     "../../../../config/memory-v3-gate.js",
     "../../../../config/schema.js",
@@ -117,11 +113,6 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../../config/skill-state.js",
     "../../../../config/skills.js",
     "../../../../config/types.js",
-    // Same host module the retrospective job couples to (the `../../../`
-    // entry below): the sweep job and v2 router warm the guardian-delivery
-    // cache before their sync `resolveUserName` reads so worker-process
-    // prompts address the guardian instead of the default profile. No
-    // plugin-api equivalent.
     "../../../../contacts/guardian-delivery-reader.js",
     "../../../../context/token-estimator.js",
     "../../../../daemon/conversation-error.js",
@@ -131,8 +122,6 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../../daemon/embedding-reconcile.js",
     "../../../../daemon/trust-context.js",
     "../../../../daemon/turn-latency-sub-spans.js",
-    // mcp-setup capability cards list configured server names from the
-    // workspace mcp.json document. No plugin-api equivalent.
     "../../../../mcp/workspace-mcp-config.js",
     "../../../../notifications/background-failure-signal.js",
     "../../../../persistence/checkpoints.js",
@@ -154,7 +143,7 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../../prompts/persona-resolver.js",
     "../../../../prompts/system-prompt.js",
     "../../../../prompts/template-detection.js",
-    "../../../../providers/platform-proxy/context.js",
+    "../../../../providers/cloud-proxy/context.js",
     "../../../../runtime/assistant-event-hub.js",
     "../../../../runtime/auth/route-policy.js",
     "../../../../runtime/background-job-runner.js",
@@ -164,15 +153,15 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../../security/secret-scanner.js",
     "../../../../skills/catalog-cache.js",
     "../../../../telemetry/watchdog-events-store.js",
-    "../../../../tools/skills/delete-managed.js",
+    "../../../../tools/skills/delete-cloud.js",
     "../../../../util/json.js",
     "../../../../util/logger.js",
     "../../../../util/platform.js",
     "../../../api/remember-tool.js",
     "../../../channels/types.js",
+    "../../../config/cloud-rehydration.js",
     "../../../config/loader.js",
     "../../../config/memory-v3-gate.js",
-    "../../../config/platform-rehydration.js",
     "../../../config/schema.js",
     "../../../config/schemas/memory.js",
     "../../../config/types.js",
@@ -181,9 +170,6 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../context/strip-injections.js",
     "../../../context/token-estimator.js",
     "../../../conversations/job-handlers/summarization.js",
-    // The standalone memory worker hosts real agent conversations, so its
-    // entry point starts the same eviction sweep the daemon starts at
-    // startup. No plugin-api equivalent.
     "../../../daemon/conversation-evictor.js",
     "../../../daemon/date-context.js",
     "../../../daemon/disk-pressure-background-gate.js",
@@ -196,8 +182,6 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../daemon/trust-context.js",
     "../../../home/job-handlers/conversation-starters.js",
     "../../../media/job-handlers/media-processing.js",
-    // The skill-update receipt job announces a burst through the
-    // notification pipeline's single entry point. No plugin-api equivalent.
     "../../../notifications/emit-signal.js",
     "../../../permissions/types.js",
     "../../../persistence/auto-analysis-constants.js",
@@ -219,15 +203,7 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../persistence/job-handlers/message-lexical.js",
     "../../../persistence/job-utils.js",
     "../../../persistence/jobs-store.js",
-    // The retrospective cursor is a `(createdAt, id)` bound that must keep
-    // working after its message row is deleted. The resolver lives beside
-    // the persistence after-reads it also drives, so the plugin's
-    // accounting imports it rather than re-deriving the bound. No
-    // plugin-api equivalent.
     "../../../persistence/message-cursor.js",
-    // Named any-state `createdAt` lookup the cursor bookkeeping uses for
-    // forks and the timestamp backfill; the messages-read boundary guard
-    // requires the read to live in persistence. No plugin-api equivalent.
     "../../../persistence/message-reads.js",
     "../../../persistence/raw-query.js",
     "../../../persistence/schema/index.js",
@@ -258,10 +234,6 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../util/worker-memory.js",
     "../../../util/worker-process.js",
     "../../types.js",
-    // The memory jobs worker runs as its own OS process and hosts real agent
-    // conversations, so it registers the host's default-plugin hook and
-    // injector surface at startup (hooks only, no init hooks). Host-owned
-    // composition with no plugin-api equivalent.
     "../../worker-plugin-surface.js",
     "../injection-presence.js",
     "../injector-order.js",
@@ -277,18 +249,15 @@ const BASELINE: Record<string, readonly string[]> = {
     "yaml",
     "zod",
   ],
-  "platform-hosted": ["node:fs/promises", "node:path"],
-  // Host-internal surface snapshot and task_progress parser. UI surfaces
-  // stay host-owned, so there is no plugin-api equivalent.
-  "task-progress": [
-    "../../../../daemon/conversation-surface-snapshots.js",
-    "../../../../runtime/task-progress.js",
-  ],
   session: [
     "../../../config/loader.js",
     "../../types.js",
     "../injector-order.js",
   ],
+  "task-progress": [
+    "../../../../daemon/conversation-surface-snapshots.js",
+    "../../../../runtime/task-progress.js",
+  ],
   "title-generate": [
     "../../../../config/loader.js",
     "../../../../persistence/conversation-crud.js",

package/src/__tests__/plugin-import-boundary-reverse-guard.test.ts

@@ -114,11 +114,11 @@ const BASELINE: Record<string, readonly string[]> = {
     "src/runtime/routes/retrospective-routes.ts",
     "src/runtime/routes/secret-routes.ts",
     "src/schedule/scheduler.ts",
-    "src/skills/managed-store.ts",
+    "src/skills/cloud-store.ts",
     "src/skills/uninstall.ts",
     "src/tools/filesystem/write.ts",
     "src/tools/skills/find-similar-skills.ts",
-    "src/tools/skills/scaffold-managed.ts",
+    "src/tools/skills/scaffold-cloud.ts",
     "src/tools/tool-manifest.ts",
     "src/workflows/leaf-runner.ts",
   ],

package/src/__tests__/{provider-platform-proxy-integration.test.ts → provider-cloud-proxy-integration.test.ts}

@@ -1,7 +1,7 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { Services } from "../config/schemas/services.js";
-import { PLATFORM_PROVIDER_META } from "../providers/platform-proxy/constants.js";
+import { PLATFORM_PROVIDER_META } from "../providers/cloud-proxy/constants.js";
 import { credentialKey } from "../security/credential-key.js";
 import { useMemorySecureKeyMap } from "./helpers/secure-keys.js";
 
@@ -103,16 +103,16 @@ const defaultWebSearchService: Services["web-search"] = {
 };
 
 mock.module("../config/env.js", () => ({
-  getPlatformBaseUrl: () => mockPlatformBaseUrl,
-  getPlatformAssistantId: () => mockPlatformAssistantId,
+  getCloudBaseUrl: () => mockCloudBaseUrl,
+  getCloudAssistantId: () => mockCloudAssistantId,
 }));
 
 // The REAL secure-keys module pinned to a live memory backend; managed
 // credentials are seeded under their real credentialKey lookups.
 const secureKeys = useMemorySecureKeyMap();
 
-mock.module("../platform/feature-gate.js", () => ({
-  arePlatformFeaturesEnabled: () => true,
+mock.module("../cloud/feature-gate.js", () => ({
+  areCloudFeaturesEnabled: () => true,
 }));
 
 import { LLMSchema } from "../config/schemas/llm.js";
@@ -176,13 +176,12 @@ const MANAGED_FALLBACK_PROVIDERS: string[] = [
   "typesafe",
 ];
 
-let mockPlatformBaseUrl = "";
-let mockPlatformAssistantId = "";
+let mockCloudBaseUrl = "";
+let mockCloudAssistantId = "";
 
-function enableManagedProxy() {
-  mockPlatformBaseUrl = PLATFORM_BASE;
-  mockPlatformAssistantId = PLATFORM_ASSISTANT_ID;
-  secureKeys.set(credentialKey("cadet", "platform_base_url"), PLATFORM_BASE);
+function enableCloudProxy() {
+  mockCloudBaseUrl = PLATFORM_BASE;
+  mockCloudAssistantId = PLATFORM_ASSISTANT_ID;
   secureKeys.set(
     credentialKey("cadet", "platform_assistant_id"),
     PLATFORM_ASSISTANT_ID,
@@ -190,10 +189,9 @@ function enableManagedProxy() {
   secureKeys.set(credentialKey("cadet", "assistant_api_key"), MANAGED_API_KEY);
 }
 
-function disableManagedProxy() {
-  mockPlatformBaseUrl = "";
-  mockPlatformAssistantId = "";
-  secureKeys.delete(credentialKey("cadet", "platform_base_url"));
+function disableCloudProxy() {
+  mockCloudBaseUrl = "";
+  mockCloudAssistantId = "";
   secureKeys.delete(credentialKey("cadet", "platform_assistant_id"));
   secureKeys.delete(credentialKey("cadet", "assistant_api_key"));
 }
@@ -253,7 +251,7 @@ const sampleTools: ToolDefinition[] = [
 // ---------------------------------------------------------------------------
 
 beforeEach(() => {
-  disableManagedProxy();
+  disableCloudProxy();
   clearUserKeys();
   lastGeminiConstructorOpts = null;
   lastGeminiGenerateContentStreamParams = null;
@@ -265,12 +263,12 @@ beforeEach(() => {
   setConfig("services", {});
 });
 
-describe("managed proxy integration — credential precedence", () => {
+describe("cloud proxy integration — credential precedence", () => {
   describe("user keys present → providers use direct connections (not proxy)", () => {
     test.each(DIRECT_OR_MANAGED_PROVIDER_KEYS)(
       "%s routes via user-key when user key is provided regardless of managed context",
       async (provider: string) => {
-        enableManagedProxy();
+        enableCloudProxy();
         setUserKeysFor(provider);
         await initializeProviders(makeProvidersConfig(provider, "test-model"));
         expect(listProviders()).toContain(provider);
@@ -279,7 +277,7 @@ describe("managed proxy integration — credential precedence", () => {
     );
 
     test("all five configured providers route via user-key when user keys exist", async () => {
-      enableManagedProxy();
+      enableCloudProxy();
       setUserKeysFor(...DIRECT_OR_MANAGED_PROVIDER_KEYS);
       await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
       const registered = listProviders();
@@ -290,7 +288,7 @@ describe("managed proxy integration — credential precedence", () => {
     });
 
     test("user keys still route via user-key when managed context is disabled", async () => {
-      disableManagedProxy();
+      disableCloudProxy();
       setUserKeysFor(...DIRECT_OR_MANAGED_PROVIDER_KEYS);
       await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
       const registered = listProviders();
@@ -301,35 +299,35 @@ describe("managed proxy integration — credential precedence", () => {
     });
   });
 
-  describe("user keys absent + managed context available → providers use managed proxy", () => {
+  describe("user keys absent + managed context available → providers use cloud proxy", () => {
     test.each(MANAGED_FALLBACK_PROVIDERS)(
-      "%s routes via managed-proxy when no user key",
+      "%s routes via cloud-proxy when no user key",
       async (provider: string) => {
-        enableManagedProxy();
+        enableCloudProxy();
         clearUserKeys();
         await initializeProviders(
           makeProvidersConfig("anthropic", "test-model"),
         );
         expect(listProviders()).toContain(provider);
-        expect(getProviderRoutingSource(provider)).toBe("managed-proxy");
+        expect(getProviderRoutingSource(provider)).toBe("cloud-proxy");
       },
     );
 
     test("managed bootstrap registers every managed-routable catalog provider", async () => {
-      enableManagedProxy();
+      enableCloudProxy();
       clearUserKeys();
       await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
       expect([...listProviders()].sort()).toEqual(
         [...MANAGED_FALLBACK_PROVIDERS].sort(),
       );
       for (const provider of MANAGED_FALLBACK_PROVIDERS) {
-        expect(getProviderRoutingSource(provider)).toBe("managed-proxy");
+        expect(getProviderRoutingSource(provider)).toBe("cloud-proxy");
       }
       expect(getProviderRoutingSource("openrouter")).toBeUndefined();
     });
 
     test("managed typesafe sends System One through the typesafe proxy path with the assistant key", async () => {
-      enableManagedProxy();
+      enableCloudProxy();
       clearUserKeys();
       await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
 
@@ -367,7 +365,7 @@ describe("managed proxy integration — credential precedence", () => {
     });
 
     test("managed anthropic uses anthropic proxy path", async () => {
-      enableManagedProxy();
+      enableCloudProxy();
       clearUserKeys();
       await initializeProviders(
         makeProvidersConfig("anthropic", "claude-opus-4-6"),
@@ -383,7 +381,7 @@ describe("managed proxy integration — credential precedence", () => {
     });
 
     test("managed openai uses openai proxy path", async () => {
-      enableManagedProxy();
+      enableCloudProxy();
       clearUserKeys();
       await initializeProviders(makeProvidersConfig("openai", "gpt-4o"));
 
@@ -397,7 +395,7 @@ describe("managed proxy integration — credential precedence", () => {
     });
 
     test("managed gemini uses gemini proxy path", async () => {
-      enableManagedProxy();
+      enableCloudProxy();
       clearUserKeys();
       await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
 
@@ -410,7 +408,7 @@ describe("managed proxy integration — credential precedence", () => {
     });
 
     test("managed gemini receives attribution headers outside request JSON", async () => {
-      enableManagedProxy();
+      enableCloudProxy();
       clearUserKeys();
       setConfig("llm", {
         profiles: {
@@ -467,7 +465,7 @@ describe("managed proxy integration — credential precedence", () => {
     });
 
     test("managed gemini omits attribution headers without callSite", async () => {
-      enableManagedProxy();
+      enableCloudProxy();
       clearUserKeys();
       await initializeProviders(
         makeProvidersConfig("gemini", "gemini-3.1-pro"),
@@ -492,7 +490,7 @@ describe("managed proxy integration — credential precedence", () => {
     test.each(DIRECT_OR_MANAGED_PROVIDER_KEYS)(
       "%s is NOT registered when no user key and no managed context",
       async (provider: string) => {
-        disableManagedProxy();
+        disableCloudProxy();
         clearUserKeys();
         await initializeProviders(
           makeProvidersConfig("anthropic", "test-model"),
@@ -503,53 +501,53 @@ describe("managed proxy integration — credential precedence", () => {
     );
 
     test("registry is empty when no keys and no managed context (non-ollama primary)", async () => {
-      disableManagedProxy();
+      disableCloudProxy();
       clearUserKeys();
       await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
       expect(listProviders()).toEqual([]);
     });
   });
 
-  describe("mixed: some user keys + managed fallback fills gaps", () => {
-    test("user key for anthropic routes direct and managed fallback fills openai, gemini, and fireworks", async () => {
-      enableManagedProxy();
+  describe("mixed: some user keys + cloud fallback fills gaps", () => {
+    test("user key for anthropic routes direct and cloud fallback fills openai, gemini, and fireworks", async () => {
+      enableCloudProxy();
       setUserKeysFor("anthropic");
       await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
       const registered = listProviders();
       expect(registered).toContain("anthropic");
       expect(getProviderRoutingSource("anthropic")).toBe("user-key");
       expect(registered).toContain("openai");
-      expect(getProviderRoutingSource("openai")).toBe("managed-proxy");
+      expect(getProviderRoutingSource("openai")).toBe("cloud-proxy");
       expect(registered).toContain("gemini");
-      expect(getProviderRoutingSource("gemini")).toBe("managed-proxy");
+      expect(getProviderRoutingSource("gemini")).toBe("cloud-proxy");
       expect(registered).toContain("fireworks");
-      expect(getProviderRoutingSource("fireworks")).toBe("managed-proxy");
+      expect(getProviderRoutingSource("fireworks")).toBe("cloud-proxy");
       expect(registered).not.toContain("openrouter");
       expect(getProviderRoutingSource("openrouter")).toBeUndefined();
     });
 
-    test("user key for openai routes direct while anthropic, gemini, and fireworks still bootstrap via managed proxy", async () => {
-      enableManagedProxy();
+    test("user key for openai routes direct while anthropic, gemini, and fireworks still bootstrap via cloud proxy", async () => {
+      enableCloudProxy();
       setUserKeysFor("openai");
       await initializeProviders(makeProvidersConfig("openai", "test-model"));
       const registered = listProviders();
       expect(registered).toContain("openai");
       expect(getProviderRoutingSource("openai")).toBe("user-key");
       expect(registered).toContain("anthropic");
-      expect(getProviderRoutingSource("anthropic")).toBe("managed-proxy");
+      expect(getProviderRoutingSource("anthropic")).toBe("cloud-proxy");
       expect(registered).toContain("gemini");
-      expect(getProviderRoutingSource("gemini")).toBe("managed-proxy");
+      expect(getProviderRoutingSource("gemini")).toBe("cloud-proxy");
       expect(registered).toContain("fireworks");
-      expect(getProviderRoutingSource("fireworks")).toBe("managed-proxy");
+      expect(getProviderRoutingSource("fireworks")).toBe("cloud-proxy");
       expect(registered).not.toContain("openrouter");
       expect(getProviderRoutingSource("openrouter")).toBeUndefined();
     });
   });
 });
 
-describe("managed proxy integration — managed web search routing", () => {
-  test("managed Fireworks/Kimi tool call completes through the platform Brave proxy", async () => {
-    enableManagedProxy();
+describe("cloud proxy integration — managed web search routing", () => {
+  test("managed Fireworks/Kimi tool call completes through the cloud Brave proxy", async () => {
+    enableCloudProxy();
     clearUserKeys();
     setConfig("services", { "web-search": MANAGED_NATIVE_WEB_SEARCH });
 
@@ -565,9 +563,9 @@ describe("managed proxy integration — managed web search routing", () => {
             web: {
               results: [
                 {
-                  title: "Platform Result",
+                  title: "Cloud Result",
                   url: "https://example.com/platform-result",
-                  description: "Returned by the managed Brave proxy.",
+                  description: "Returned by the cloud Brave proxy.",
                   age: "1 day ago",
                 },
               ],
@@ -619,12 +617,12 @@ describe("managed proxy integration — managed web search routing", () => {
       );
 
       expect(result.isError).toBe(false);
-      expect(result.content).toContain("Platform Result");
+      expect(result.content).toContain("Cloud Result");
       expect(result.activityMetadata?.webSearch?.provider).toBe("brave");
       expect(result.activityMetadata?.webSearch?.resultCount).toBe(1);
 
       expect(fetchUrls).toEqual([
-        `${PLATFORM_BASE}/v1/assistants/${PLATFORM_ASSISTANT_ID}/managed-search-proxy/brave/`,
+        `${PLATFORM_BASE}/v1/assistants/${PLATFORM_ASSISTANT_ID}/cloud-search-proxy/brave/`,
       ]);
     } finally {
       globalThis.fetch = originalFetch;
@@ -632,23 +630,23 @@ describe("managed proxy integration — managed web search routing", () => {
   });
 });
 
-describe("managed proxy integration — ollama exclusion", () => {
-  test("ollama is never registered via managed proxy fallback", async () => {
-    enableManagedProxy();
+describe("cloud proxy integration — ollama exclusion", () => {
+  test("ollama is never registered via cloud proxy fallback", async () => {
+    enableCloudProxy();
     clearUserKeys();
     await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
     expect(listProviders()).not.toContain("ollama");
   });
 
   test("ollama registers only when explicitly configured as provider", async () => {
-    enableManagedProxy();
+    enableCloudProxy();
     clearUserKeys();
     await initializeProviders(makeProvidersConfig("ollama", "test-model"));
     expect(listProviders()).toContain("ollama");
   });
 
   test("ollama registers with explicit API key", async () => {
-    enableManagedProxy();
+    enableCloudProxy();
     const ollamaKey = credentialKey("ollama", "api_key");
     secureKeys.set(ollamaKey, "ollama-key");
     userKeyNames.push(ollamaKey);
@@ -665,13 +663,13 @@ describe("managed proxy integration — ollama exclusion", () => {
 });
 
 describe("config mode flip → provider reinit", () => {
-  test("re-running initializeProviders after managed→your-own flip switches gemini from managed-proxy to user-key", async () => {
-    // Phase 1: managed mode without user key → gemini registered as managed-proxy.
+  test("re-running initializeProviders after managed→your-own flip switches gemini from cloud-proxy to user-key", async () => {
+    // Phase 1: managed mode without user key → gemini registered as cloud-proxy.
     // This is the pre-patch state before PATCH /v1/config is called.
-    enableManagedProxy();
+    enableCloudProxy();
     clearUserKeys();
     await initializeProviders(makeProvidersConfig("gemini", "gemini-2.5-pro"));
-    expect(getProviderRoutingSource("gemini")).toBe("managed-proxy");
+    expect(getProviderRoutingSource("gemini")).toBe("cloud-proxy");
 
     // Phase 2: user has now saved a key (POST /v1/secrets), then PATCHed config
     // to mode=your-own. handlePatchConfig calls initializeProviders(getConfig())
@@ -681,22 +679,22 @@ describe("config mode flip → provider reinit", () => {
     expect(getProviderRoutingSource("gemini")).toBe("user-key");
   });
 
-  test("without reinit after config patch, gemini source remains stale managed-proxy", async () => {
+  test("without reinit after config patch, gemini source remains stale cloud-proxy", async () => {
     // Demonstrates the bug: if initializeProviders is NOT called after saving
-    // config, the routing source stays managed-proxy even after mode flip.
-    enableManagedProxy();
+    // config, the routing source stays cloud-proxy even after mode flip.
+    enableCloudProxy();
     clearUserKeys();
     await initializeProviders(makeProvidersConfig("gemini", "gemini-2.5-pro"));
-    expect(getProviderRoutingSource("gemini")).toBe("managed-proxy");
+    expect(getProviderRoutingSource("gemini")).toBe("cloud-proxy");
 
     // Flip mode but do NOT re-initialize providers (simulates skipping reinit).
     setUserKeysFor("gemini");
-    // Source stays managed-proxy because initializeProviders was not called.
-    expect(getProviderRoutingSource("gemini")).toBe("managed-proxy");
+    // Source stays cloud-proxy because initializeProviders was not called.
+    expect(getProviderRoutingSource("gemini")).toBe("cloud-proxy");
   });
 });
 
-describe("managed proxy integration — constants integrity", () => {
+describe("cloud proxy integration — constants integrity", () => {
   test("anthropic, openai, gemini, fireworks, together, and cadet have metadata with managed=true and a proxyPath", () => {
     for (const provider of [
       "anthropic",
@@ -744,15 +742,15 @@ describe("managed proxy integration — constants integrity", () => {
     );
   });
 
-  test("cadet routes through the platform runtime-proxy path", () => {
-    // The proxy path is the platform's wire contract — renamed in
-    // coordination with the platform deploy, not here.
+  test("cadet routes through the cloud runtime-proxy path", () => {
+    // The proxy path is the cloud's wire contract — renamed in
+    // coordination with the cloud deploy, not here.
     expect(PLATFORM_PROVIDER_META.cadet.proxyPath).toBe(
       "/v1/runtime-proxy/cadet",
     );
   });
 
-  test("openrouter is not managed proxy capable", () => {
+  test("openrouter is not cloud proxy capable", () => {
     expect(PLATFORM_PROVIDER_META.openrouter.managed).toBe(false);
     expect(PLATFORM_PROVIDER_META.openrouter.proxyPath).toBeUndefined();
   });

package/src/__tests__/provider-commit-message-generator.test.ts

@@ -342,7 +342,7 @@ describe("ProviderCommitMessageGenerator", () => {
       provider: mockProvider,
       configuredProviderName: "cadet",
     };
-    const commitMsg = "fix: managed-route commit";
+    const commitMsg = "fix: cloud-route commit";
     mockSendMessage.mockResolvedValueOnce(makeSuccessResponse(commitMsg));
     const gen = getCommitMessageGenerator();
     const result = await gen.generateCommitMessage(baseContext, {

package/src/__tests__/provider-connections-backfill.test.ts

@@ -2,7 +2,7 @@
  * Boot-time provider_connection backfill: an existing user connection for
  * the entry's provider must win over the mode-derived default.
  *
- * On managed (platform-hosted) installs the mode default is the billed
+ * On managed (cloud-hosted) installs the mode default is the billed
  * `cadet` connection — stamping it onto a connection-less BYOK-intent
  * profile permanently routes the user's own-key setup through managed
  * billing. On your-own installs the mode default creates a parallel
@@ -27,7 +27,7 @@ import {
 
 await initializeDb();
 
-const originalIsPlatform = process.env.IS_PLATFORM;
+const originalIsPlatform = process.env.IS_CLOUD;
 
 function seedConfig(profiles: Record<string, unknown>): void {
   writeFileSync(
@@ -49,14 +49,14 @@ beforeEach(() => {
 
 afterEach(() => {
   if (originalIsPlatform === undefined) {
-    delete process.env.IS_PLATFORM;
+    delete process.env.IS_CLOUD;
   } else {
-    process.env.IS_PLATFORM = originalIsPlatform;
+    process.env.IS_CLOUD = originalIsPlatform;
   }
 });
 
 test("managed mode prefers an existing user connection over the cadet default", () => {
-  process.env.IS_PLATFORM = "true";
+  process.env.IS_CLOUD = "true";
   const created = createConnection(getDb(), {
     name: "anthropic-personal",
     provider: "anthropic",
@@ -71,7 +71,7 @@ test("managed mode prefers an existing user connection over the cadet default",
 });
 
 test("managed mode still stamps cadet when no user connection exists", () => {
-  process.env.IS_PLATFORM = "true";
+  process.env.IS_CLOUD = "true";
   seedConfig({ byok: { provider: "anthropic", model: "claude-fable-5" } });
 
   runProviderConnectionsBackfill(getDb());
@@ -80,7 +80,7 @@ test("managed mode still stamps cadet when no user connection exists", () => {
 });
 
 test("managed-owned entries keep the cadet stamp even when a user connection exists", () => {
-  process.env.IS_PLATFORM = "true";
+  process.env.IS_CLOUD = "true";
   const created = createConnection(getDb(), {
     name: "anthropic-personal",
     provider: "anthropic",
@@ -118,7 +118,7 @@ test("managed-owned entries keep the cadet stamp even when a user connection exi
 });
 
 test("routing-identity providers are never stamped with a connection", () => {
-  process.env.IS_PLATFORM = "true";
+  process.env.IS_CLOUD = "true";
   seedConfig({
     managedRoute: { provider: "cadet", model: "claude-fable-5" },
     subscription: { provider: "chatgpt", model: "gpt-5.5" },
@@ -131,7 +131,7 @@ test("routing-identity providers are never stamped with a connection", () => {
 });
 
 test("your-own mode reuses a custom-named connection instead of creating -personal", () => {
-  delete process.env.IS_PLATFORM;
+  delete process.env.IS_CLOUD;
   const created = createConnection(getDb(), {
     name: "my-anthropic",
     provider: "anthropic",