@mycadet/assistant 0.12.7 → 0.12.9

package/src/__tests__/llm-resolver-override-or-default.test.ts

@@ -250,7 +250,7 @@ describe("shipped call-site tuning", () => {
     expect(resolved.model).not.toBe("jev-latest");
   });
 
-  test("a BYOK Jev call-site override replaces the managed default", () => {
+  test("a BYOK Jev call-site override replaces the cloud default", () => {
     const llm = LLMSchema.parse({
       ...anthropicDp,
       profiles: {
@@ -438,7 +438,7 @@ describe("composition", () => {
     expect(resolved.provider_connection).toBeUndefined();
   });
 
-  test("a provider-pinning tweak over the cadet default keeps the managed routing", () => {
+  test("a provider-pinning tweak over the cadet default keeps the cloud routing", () => {
     const llm = LLMSchema.parse({
       callSites: {
         conversationSummarization: {
@@ -452,7 +452,7 @@ describe("composition", () => {
     });
     const resolved = resolveCallSiteConfig("conversationSummarization", llm);
     // The tweak wins the fields it sets; the identity winner contributes its
-    // routing through the provider-agnostic managed connection.
+    // routing through the provider-agnostic cloud connection.
     expect(resolved.provider).toBe("anthropic");
     expect(resolved.model).toBe("claude-opus-4-6");
     expect(resolved.provider_connection).toBe("cadet");

package/src/__tests__/llm-resolver.test.ts

@@ -736,7 +736,7 @@ describe("resolveCallSiteConfig", () => {
     expect(resolved.model).toBe(resolveModelIntent("openai", "cost-optimized"));
   });
 
-  test("BYOK full-workspace: every call site resolves through the default provider, never the managed connection", () => {
+  test("BYOK full-workspace: every call site resolves through the default provider, never the cloud connection", () => {
     const byokConfig = LLMSchema.parse({
       profiles: {
         balanced: { source: "managed", status: "disabled" },

package/src/__tests__/llm-schema-fallback-profile.test.ts

@@ -59,7 +59,7 @@ describe("LLMSchema fallbackProfile", () => {
     expect(result.success).toBe(false);
   });
 
-  test("rejects a managed default pointing anywhere except its code-owned backup", () => {
+  test("rejects a cloud default pointing anywhere except its code-owned backup", () => {
     const profileName = DEFAULT_PROFILE_KEYS[0];
     const result = LLMSchema.safeParse({
       profiles: {
@@ -98,7 +98,7 @@ describe("LLMSchema fallbackProfile", () => {
     }
   });
 
-  test("a code-owned fallback pointer is rejected on a non-managed column", () => {
+  test("a code-owned fallback pointer is rejected on a non-cloud column", () => {
     const profileName = DEFAULT_PROFILE_KEYS[0];
     for (const provider of ["anthropic", "chatgpt"] as const) {
       const result = LLMSchema.safeParse({
@@ -115,7 +115,7 @@ describe("LLMSchema fallbackProfile", () => {
         const issue = result.error.issues.find((i) =>
           i.path.join(".").endsWith("fallbackProfile"),
         );
-        expect(issue?.message).toContain("managed backup profile");
+        expect(issue?.message).toContain("cloud backup profile");
         expect(issue?.path).toEqual([
           "profiles",
           profileName,
@@ -130,12 +130,18 @@ describe("LLMSchema fallbackProfile", () => {
       unrepresentable: "any",
       io: "input",
     });
+    // ProfileEntry carries a named meta id (#172), so zod v4 hoists it into
+    // top-level $defs and the profiles record references it by $ref — the
+    // fallbackProfile readOnly marker the docs surface lives in the $defs copy.
     expect(json).toMatchObject({
       properties: {
         profiles: {
-          additionalProperties: {
-            properties: { fallbackProfile: { readOnly: true } },
-          },
+          additionalProperties: { $ref: "#/$defs/ProfileEntry" },
+        },
+      },
+      $defs: {
+        ProfileEntry: {
+          properties: { fallbackProfile: { readOnly: true } },
         },
       },
     });
@@ -147,7 +153,7 @@ describe("LLMSchema backup profile references vs llm.default", () => {
   const managed = { provider: "cadet" } as const;
   const nonManaged = [{ provider: "anthropic" }, { provider: "chatgpt" }];
 
-  test("activeProfile naming a backup parses on the managed column", () => {
+  test("activeProfile naming a backup parses on the cloud column", () => {
     const result = LLMSchema.safeParse({
       default: managed,
       activeProfile: backupKey,
@@ -155,7 +161,7 @@ describe("LLMSchema backup profile references vs llm.default", () => {
     expect(result.success).toBe(true);
   });
 
-  test("activeProfile naming a backup is rejected on a non-managed column", () => {
+  test("activeProfile naming a backup is rejected on a non-cloud column", () => {
     for (const blob of nonManaged) {
       const result = LLMSchema.safeParse({
         default: blob,
@@ -166,7 +172,7 @@ describe("LLMSchema backup profile references vs llm.default", () => {
         const issue = result.error.issues.find(
           (i) => i.path.join(".") === "activeProfile",
         );
-        expect(issue?.message).toContain("managed backup profile");
+        expect(issue?.message).toContain("cloud backup profile");
       }
     }
   });
@@ -211,7 +217,7 @@ describe("LLMSchema backup profile references vs llm.default", () => {
         const issue = result.error.issues.find(
           (i) => i.path.join(".") === "callSites.recall.profile",
         );
-        expect(issue?.message).toContain("managed backup profile");
+        expect(issue?.message).toContain("cloud backup profile");
       }
     }
   });
@@ -235,11 +241,11 @@ describe("LLMSchema backup profile references vs llm.default", () => {
     }
   });
 
-  test("an absent blob or a non-matrix provider reads as the managed column", () => {
+  test("an absent blob or a non-matrix provider reads as the cloud column", () => {
     // An install predating the blob is managed by definition, so an absent
     // `default` keeps its backups referenceable. A provider value with no
     // matrix column (keyless ollama, user-endpoint openai-compatible) is
-    // clamped to the managed column at read time rather than failing the
+    // clamped to the cloud column at read time rather than failing the
     // blob. A non-string provider is NOT caught — the blob is a plain
     // fragment, so it fails the parse and the loader's leaf recovery strips
     // the bad leaf (covered by the loader tests).
@@ -269,13 +275,13 @@ describe("LLMSchema backup profile references vs llm.default", () => {
   });
 
   // A managed install can persist a thin `{ source: "managed" }` stub for a
-  // backup key: `normalizeManagedProfileWrites` reduces a `config get` ->
+  // backup key: `normalizeCloudProfileWrites` reduces a `config get` ->
   // `config set` echo of the effective profile list to exactly that. The stub
   // holds no body of its own, so it must not carry a reference past the
-  // provider gate once the install moves off the managed column.
+  // provider gate once the install moves off the cloud column.
   const stub = { source: "managed" } as const;
 
-  test("a managed stub does not keep a backup reference alive off the managed column", () => {
+  test("a cloud stub does not keep a backup reference alive off the cloud column", () => {
     for (const blob of nonManaged) {
       const result = LLMSchema.safeParse({
         default: blob,
@@ -287,12 +293,12 @@ describe("LLMSchema backup profile references vs llm.default", () => {
         const issue = result.error.issues.find(
           (i) => i.path.join(".") === "activeProfile",
         );
-        expect(issue?.message).toContain("managed backup profile");
+        expect(issue?.message).toContain("cloud backup profile");
       }
     }
   });
 
-  test("a managed stub does not keep a call-site pin or mix arm alive either", () => {
+  test("a cloud stub does not keep a call-site pin or mix arm alive either", () => {
     for (const blob of nonManaged) {
       const callSitePin = LLMSchema.safeParse({
         default: blob,
@@ -318,7 +324,7 @@ describe("LLMSchema backup profile references vs llm.default", () => {
     }
   });
 
-  test("a managed stub does not keep a fallbackProfile pointer alive either", () => {
+  test("a cloud stub does not keep a fallbackProfile pointer alive either", () => {
     for (const blob of nonManaged) {
       const result = LLMSchema.safeParse({
         default: blob,
@@ -337,7 +343,7 @@ describe("LLMSchema backup profile references vs llm.default", () => {
     }
   });
 
-  test("a managed stub keeps its references valid on the managed column", () => {
+  test("a cloud stub keeps its references valid on the cloud column", () => {
     // The stub stands for a body that does resolve here, so nothing about it
     // makes the reference worse than the unmaterialized case.
     const result = LLMSchema.safeParse({

package/src/__tests__/llm-usage-store.test.ts

@@ -2152,7 +2152,7 @@ describe("recordUsageEvent — assistantVersion stamping", () => {
     // inserting one through recordUsageEvent and then nulling the
     // column out. This mirrors what production rows look like before
     // the migration backfills `null`s; the reporter must accept them
-    // and let the platform fall back to the envelope's version.
+    // and let the cloud fall back to the envelope's version.
     insertEventAt(1000);
     const db = getDb();
     db.run(`UPDATE llm_usage_events SET assistant_version = NULL`);

package/src/__tests__/managed-skill-lifecycle.test.ts

@@ -8,7 +8,7 @@ let TEST_DIR = "";
 const seedUpsertSlugs: string[] = [];
 
 // Keep bundled skills out of the catalog so the lifecycle assertions only
-// see the managed skills these tests create (default `allowBundled: null`
+// see the cloud skills these tests create (default `allowBundled: null`
 // would load every bundled skill).
 setConfig("skills", { allowBundled: [] });
 
@@ -42,12 +42,12 @@ import {
   getSkillCapability,
   seedV2SkillEntries,
 } from "../plugins/defaults/memory/substrate/skill-store.js";
-import { executeDeleteManagedSkill } from "../tools/skills/delete-managed.js";
+import { executeDeleteCloudSkill } from "../tools/skills/delete-cloud.js";
 import { skillLoadTool } from "../tools/skills/load.js";
-import { executeScaffoldManagedSkill } from "../tools/skills/scaffold-managed.js";
+import { executeScaffoldCloudSkill } from "../tools/skills/scaffold-cloud.js";
 import type { ToolContext } from "../tools/types.js";
 
-/** scaffold_managed_skill requires activation hints; a fixed set for tests. */
+/** scaffold_cloud_skill requires activation hints; a fixed set for tests. */
 const HINTS = ["user asks to run the lifecycle test procedure"];
 
 function makeContext(): ToolContext {
@@ -122,8 +122,8 @@ Run the custom lifecycle verification procedure.
   }, 15_000);
 
   test("full lifecycle: create skill, verify in catalog and prompt, then delete", async () => {
-    // Step 1: Scaffold a managed skill
-    const scaffoldResult = await executeScaffoldManagedSkill(
+    // Step 1: Scaffold a cloud skill
+    const scaffoldResult = await executeScaffoldCloudSkill(
       {
         skill_id: "lifecycle-test",
         name: "Lifecycle Test",
@@ -158,7 +158,7 @@ Run the custom lifecycle verification procedure.
     expect(existsSync(join(TEST_DIR, "skills", "SKILLS.md"))).toBe(false);
 
     // Step 4: Delete the skill
-    const deleteResult = await executeDeleteManagedSkill(
+    const deleteResult = await executeDeleteCloudSkill(
       {
         skill_id: "lifecycle-test",
       },
@@ -183,7 +183,7 @@ Run the custom lifecycle verification procedure.
     const ctx = makeContext();
 
     // Create initial skill
-    await executeScaffoldManagedSkill(
+    await executeScaffoldCloudSkill(
       {
         skill_id: "overwrite-test",
         name: "V1",
@@ -195,7 +195,7 @@ Run the custom lifecycle verification procedure.
     );
 
     // Overwrite with updated content
-    const result = await executeScaffoldManagedSkill(
+    const result = await executeScaffoldCloudSkill(
       {
         skill_id: "overwrite-test",
         name: "V2",
@@ -226,7 +226,7 @@ Run the custom lifecycle verification procedure.
   });
 
   test("delete non-existent skill returns error", async () => {
-    const result = await executeDeleteManagedSkill(
+    const result = await executeDeleteCloudSkill(
       {
         skill_id: "does-not-exist",
       },
@@ -240,7 +240,7 @@ Run the custom lifecycle verification procedure.
     const ctx = makeContext();
 
     // Step 1: Scaffold a skill directly
-    const scaffoldResult = await executeScaffoldManagedSkill(
+    const scaffoldResult = await executeScaffoldCloudSkill(
       {
         skill_id: "chain-test",
         name: "Chain Test",
@@ -270,7 +270,7 @@ Run the custom lifecycle verification procedure.
     expect(loadContent).toContain("echo chain-test-ok");
 
     // Step 3: Clean up
-    const deleteResult = await executeDeleteManagedSkill(
+    const deleteResult = await executeDeleteCloudSkill(
       { skill_id: "chain-test" },
       ctx,
     );

package/src/__tests__/mcp-abort-signal.test.ts

@@ -10,8 +10,7 @@ useMemorySecureKeyMap();
 mock.module("../config/env-registry.js", () => ({
   getDebugStdoutLogs: () => false,
   getIsContainerized: () => false,
-  getIsPlatform: () => false,
-  isPlatformRemote: () => false,
+  getIsCloud: () => false,
   getCpuLimit: () => undefined,
   getMinikubeStorageSize: () => undefined,
   getProfilerRunId: () => undefined,

package/src/__tests__/mcp-client-auth.test.ts

@@ -10,8 +10,7 @@ useMemorySecureKeyMap();
 mock.module("../config/env-registry.js", () => ({
   getDebugStdoutLogs: () => false,
   getIsContainerized: () => false,
-  getIsPlatform: () => false,
-  isPlatformRemote: () => false,
+  getIsCloud: () => false,
   getCpuLimit: () => undefined,
   getMinikubeStorageSize: () => undefined,
   getProfilerRunId: () => undefined,

package/src/__tests__/mcp-config-secret-boundary.test.ts

@@ -88,7 +88,6 @@ mock.module("../persistence/embeddings/embedding-backend.js", () => ({
 
 const { ROUTES } =
   await import("../runtime/routes/conversation-query-routes.js");
-const { BadRequestError } = await import("../runtime/routes/errors.js");
 
 function findRoute(operationId: string) {
   const route = ROUTES.find((r) => r.operationId === operationId);
@@ -220,25 +219,30 @@ describe("MCP config secret boundary", () => {
     });
   });
 
-  test("config_patch rejects MCP transport headers so generic writes cannot reintroduce plaintext credentials", async () => {
-    await expect(
-      configPatchRoute.handler({
-        body: {
-          mcp: {
-            servers: {
-              remote: {
-                transport: {
-                  type: "streamable-http",
-                  url: "https://mcp.example.com",
-                  headers: { Authorization: "Bearer mcp-secret" },
-                },
+  test("config_patch strips MCP transport headers so generic writes cannot persist plaintext credentials", async () => {
+    const result = await configPatchRoute.handler({
+      body: {
+        mcp: {
+          servers: {
+            remote: {
+              transport: {
+                type: "streamable-http",
+                url: "https://mcp.example.com",
+                headers: { Authorization: "Bearer mcp-secret" },
               },
             },
           },
         },
-      }),
-    ).rejects.toThrow(BadRequestError);
-    expect(committedRaw()).toBeNull();
+      },
+    });
+
+    // `mcp` is not an AssistantConfigSchema key: the write's schema parse
+    // strips it, so the secret never reaches disk — and the response's
+    // projected workspace view carries no such server either.
+    expect(committedRaw()?.mcp).toBeUndefined();
+    expect(
+      (result as { mcp: { servers: Record<string, unknown> } }).mcp.servers,
+    ).toEqual({});
   });
 
   test("config_patch strips mcp so a full-config round trip cannot write it back", async () => {
@@ -263,34 +267,34 @@ describe("MCP config secret boundary", () => {
     ).toEqual({});
   });
 
-  test("config_set rejects MCP server writes", async () => {
-    await expect(
-      configSetRoute.handler({
-        body: {
-          path: "mcp.servers",
-          value: {
-            remote: {
-              transport: {
-                type: "streamable-http",
-                url: "https://mcp.example.com",
-              },
+  test("config_set drops MCP server writes", async () => {
+    const result = await configSetRoute.handler({
+      body: {
+        path: "mcp.servers",
+        value: {
+          remote: {
+            transport: {
+              type: "streamable-http",
+              url: "https://mcp.example.com",
             },
           },
         },
-      }),
-    ).rejects.toThrow(BadRequestError);
-    expect(committedRaw()).toBeNull();
+      },
+    });
+
+    expect(result).toEqual({ ok: true });
+    expect(committedRaw()?.mcp).toBeUndefined();
   });
 
-  test("config_set rejects direct MCP transport header paths", async () => {
-    await expect(
-      configSetRoute.handler({
-        body: {
-          path: "mcp.servers.remote.transport.headers.Authorization",
-          value: "Bearer mcp-secret",
-        },
-      }),
-    ).rejects.toThrow(BadRequestError);
-    expect(committedRaw()).toBeNull();
+  test("config_set drops direct MCP transport header paths", async () => {
+    const result = await configSetRoute.handler({
+      body: {
+        path: "mcp.servers.remote.transport.headers.Authorization",
+        value: "Bearer mcp-secret",
+      },
+    });
+
+    expect(result).toEqual({ ok: true });
+    expect(committedRaw()?.mcp).toBeUndefined();
   });
 });

package/src/__tests__/mcp-tool-annotations-risk.test.ts

@@ -10,8 +10,7 @@ useMemorySecureKeyMap();
 mock.module("../config/env-registry.js", () => ({
   getDebugStdoutLogs: () => false,
   getIsContainerized: () => false,
-  getIsPlatform: () => false,
-  isPlatformRemote: () => false,
+  getIsCloud: () => false,
   getCpuLimit: () => undefined,
   getMinikubeStorageSize: () => undefined,
   getProfilerRunId: () => undefined,

package/src/__tests__/media-generate-image.test.ts

@@ -82,16 +82,16 @@ mock.module("../media/image-service.js", () => ({
   },
 }));
 
-let mockManagedBaseUrl: string | undefined;
-let mockManagedProxyContext = {
+let mockCloudBaseUrl: string | undefined;
+let mockCloudProxyContext = {
   enabled: false,
-  platformBaseUrl: "",
+  cloudBaseUrl: "",
   assistantApiKey: "",
 };
 
-mock.module("../providers/platform-proxy/context.js", () => ({
-  buildManagedBaseUrl: async () => mockManagedBaseUrl,
-  resolveManagedProxyContext: async () => mockManagedProxyContext,
+mock.module("../providers/cloud-proxy/context.js", () => ({
+  buildCloudBaseUrl: async () => mockCloudBaseUrl,
+  resolveCloudProxyContext: async () => mockCloudProxyContext,
 }));
 
 // Import after mocking
@@ -143,10 +143,10 @@ beforeEach(() => {
   lastGenerateCredentials = null;
   lastGenerateRequest = null;
   mockGenerateDelayMs = 0;
-  mockManagedBaseUrl = undefined;
-  mockManagedProxyContext = {
+  mockCloudBaseUrl = undefined;
+  mockCloudProxyContext = {
     enabled: false,
-    platformBaseUrl: "",
+    cloudBaseUrl: "",
     assistantApiKey: "",
   };
   fakeContext = makeContext();
@@ -161,7 +161,7 @@ describe("image-studio skill script wrapper", () => {
     expect(getTool("media_generate_image")).toBeUndefined();
   });
 
-  test("returns error when no API key and no managed proxy", async () => {
+  test("returns error when no API key and no cloud proxy", async () => {
     setKey("gemini", undefined);
 
     const result = await run({ prompt: "a cat" }, fakeContext);
@@ -170,12 +170,12 @@ describe("image-studio skill script wrapper", () => {
     expect(result.content).toContain("No Gemini API key");
   });
 
-  test("provider cadet uses managed proxy credentials", async () => {
+  test("provider cadet uses cloud proxy credentials", async () => {
     seedImageGenService({ provider: "cadet" });
-    mockManagedBaseUrl = "https://platform.example.com/v1/runtime-proxy/gemini";
-    mockManagedProxyContext = {
+    mockCloudBaseUrl = "https://platform.example.com/v1/runtime-proxy/gemini";
+    mockCloudProxyContext = {
       enabled: true,
-      platformBaseUrl: "https://platform.example.com",
+      cloudBaseUrl: "https://platform.example.com",
       assistantApiKey: "managed-key-123",
     };
 
@@ -185,7 +185,7 @@ describe("image-studio skill script wrapper", () => {
     expect(result.content).toContain("Generated 1 image");
     expect(lastGenerateProvider).toBe("gemini");
     expect(lastGenerateCredentials).toEqual({
-      type: "managed-proxy",
+      type: "cloud-proxy",
       assistantApiKey: "managed-key-123",
       baseUrl: "https://platform.example.com/v1/runtime-proxy/gemini",
     });
@@ -193,9 +193,9 @@ describe("image-studio skill script wrapper", () => {
 
   test("provider cadet routes managed to the gemini proxy for gemini models", async () => {
     seedImageGenService({ provider: "cadet" });
-    mockManagedProxyContext = {
+    mockCloudProxyContext = {
       enabled: true,
-      platformBaseUrl: "https://platform.example.com",
+      cloudBaseUrl: "https://platform.example.com",
       assistantApiKey: "managed-key-123",
     };
 
@@ -204,7 +204,7 @@ describe("image-studio skill script wrapper", () => {
     expect(result.isError).toBe(false);
     expect(lastGenerateProvider).toBe("gemini");
     expect(lastGenerateCredentials).toEqual({
-      type: "managed-proxy",
+      type: "cloud-proxy",
       assistantApiKey: "managed-key-123",
       baseUrl: "https://platform.example.com/v1/runtime-proxy/gemini",
     });
@@ -212,9 +212,9 @@ describe("image-studio skill script wrapper", () => {
 
   test("provider cadet routes a gpt model to the openai proxy", async () => {
     seedImageGenService({ provider: "cadet", model: "gpt-image-2" });
-    mockManagedProxyContext = {
+    mockCloudProxyContext = {
       enabled: true,
-      platformBaseUrl: "https://platform.example.com",
+      cloudBaseUrl: "https://platform.example.com",
       assistantApiKey: "managed-key-123",
     };
 
@@ -223,7 +223,7 @@ describe("image-studio skill script wrapper", () => {
     expect(result.isError).toBe(false);
     expect(lastGenerateProvider).toBe("openai");
     expect(lastGenerateCredentials).toEqual({
-      type: "managed-proxy",
+      type: "cloud-proxy",
       assistantApiKey: "managed-key-123",
       baseUrl: "https://platform.example.com/v1/runtime-proxy/openai",
     });
@@ -238,28 +238,28 @@ describe("image-studio skill script wrapper", () => {
     const result = await run({ prompt: "a hippo" }, fakeContext);
 
     expect(result.isError).toBe(true);
-    expect(result.content).toContain("Managed proxy is not available");
+    expect(result.content).toContain("Cloud proxy is not available");
     expect(lastGenerateProvider).toBeNull();
   });
 
-  test("provider cadet returns error when managed proxy is unavailable", async () => {
+  test("provider cadet returns error when cloud proxy is unavailable", async () => {
     seedImageGenService({ provider: "cadet" });
     setKey("gemini", "direct-key"); // should be ignored in managed mode
-    mockManagedBaseUrl = undefined;
+    mockCloudBaseUrl = undefined;
 
     const result = await run({ prompt: "a cat" }, fakeContext);
 
     expect(result.isError).toBe(true);
-    expect(result.content).toContain("Managed proxy is not available");
+    expect(result.content).toContain("Cloud proxy is not available");
   });
 
   test("your-own mode uses direct API key", async () => {
     seedImageGenService({ provider: "gemini" });
     setKey("gemini", "direct-key");
-    mockManagedBaseUrl = "https://platform.example.com/v1/runtime-proxy/gemini";
-    mockManagedProxyContext = {
+    mockCloudBaseUrl = "https://platform.example.com/v1/runtime-proxy/gemini";
+    mockCloudProxyContext = {
       enabled: true,
-      platformBaseUrl: "https://platform.example.com",
+      cloudBaseUrl: "https://platform.example.com",
       assistantApiKey: "managed-key-123",
     };
 
@@ -483,12 +483,12 @@ describe("image-studio skill script wrapper", () => {
 
   test("provider cadet credential error includes guidance not to change service config", async () => {
     seedImageGenService({ provider: "cadet" });
-    mockManagedBaseUrl = undefined;
+    mockCloudBaseUrl = undefined;
 
     const result = await run({ prompt: "a cat" }, fakeContext);
 
     expect(result.isError).toBe(true);
-    expect(result.content).toContain("Managed proxy is not available");
+    expect(result.content).toContain("Cloud proxy is not available");
     expect(result.content).toContain("Report this error to the user as-is");
     expect(result.content).toContain(
       "Do not change service configuration (managed/your-own mode or default provider/model settings)",

package/src/__tests__/memory-config-file-parity.test.ts

@@ -18,7 +18,7 @@ import { getMemoryConfig } from "../plugins/defaults/memory/config.js";
 import { getWorkspaceConfigPath } from "../util/platform.js";
 
 const configPath = getWorkspaceConfigPath();
-const savedIsPlatform = process.env.IS_PLATFORM;
+const savedIsPlatform = process.env.IS_CLOUD;
 
 function writeConfig(value: unknown): void {
   writeFileSync(configPath, JSON.stringify(value, null, 2));
@@ -26,7 +26,7 @@ function writeConfig(value: unknown): void {
 
 function resetState(): void {
   rmSync(configPath, { force: true });
-  delete process.env.IS_PLATFORM;
+  delete process.env.IS_CLOUD;
 }
 
 /** Assert the plugin resolution deep-equals the host loader's slice. */
@@ -41,7 +41,7 @@ describe("memory config file parity", () => {
   afterEach(() => {
     resetState();
     if (savedIsPlatform !== undefined) {
-      process.env.IS_PLATFORM = savedIsPlatform;
+      process.env.IS_CLOUD = savedIsPlatform;
     }
   });
 
@@ -88,14 +88,14 @@ describe("memory config file parity", () => {
   });
 
   test("platform deployment fill applies when the leaf is absent on disk", () => {
-    process.env.IS_PLATFORM = "true";
+    process.env.IS_CLOUD = "true";
     writeConfig({ memory: {} });
     const memory = expectParity();
     expect(memory.embeddings.provider).toBe("gemini");
   });
 
-  test("an explicit on-disk provider beats the platform fill", () => {
-    process.env.IS_PLATFORM = "true";
+  test("an explicit on-disk provider beats the cloud fill", () => {
+    process.env.IS_CLOUD = "true";
     writeConfig({ memory: { embeddings: { provider: "openai" } } });
     const memory = expectParity();
     expect(memory.embeddings.provider).toBe("openai");

package/src/__tests__/migration-export-to-gcs.test.ts

@@ -284,8 +284,8 @@ describe("handleMigrationExportToGcs — happy path", () => {
     // manifest claims a truthful `secrets_redacted: true` regardless of
     // credential-store state, and the bundle passes validation with
     // `origin.mode: "managed"`.
-    const originalIsPlatform = process.env.IS_PLATFORM;
-    process.env.IS_PLATFORM = "true";
+    const originalIsPlatform = process.env.IS_CLOUD;
+    process.env.IS_CLOUD = "true";
 
     let capturedBody: Buffer | undefined;
     const fixture = await startFixtureServer(async (req, res) => {
@@ -328,9 +328,9 @@ describe("handleMigrationExportToGcs — happy path", () => {
       expect(validation.manifest?.secrets_redacted).toBe(true);
     } finally {
       if (originalIsPlatform === undefined) {
-        delete process.env.IS_PLATFORM;
+        delete process.env.IS_CLOUD;
       } else {
-        process.env.IS_PLATFORM = originalIsPlatform;
+        process.env.IS_CLOUD = originalIsPlatform;
       }
       await fixture.close();
     }