@mycadet/assistant 0.12.7 → 0.12.9

package/src/config/__tests__/deployment-context-defaults.test.ts

@@ -67,7 +67,7 @@ function readConfig(): Record<string, unknown> {
   return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
 }
 
-/** Stash and restore IS_PLATFORM across each test. */
+/** Stash and restore IS_CLOUD across each test. */
 let originalIsPlatform: string | undefined;
 
 // ---------------------------------------------------------------------------
@@ -91,27 +91,27 @@ describe("deployment-context embedding-provider default (via loadConfig)", () =>
     ensureTestDir();
     invalidateConfigCache();
 
-    originalIsPlatform = process.env.IS_PLATFORM;
-    delete process.env.IS_PLATFORM;
+    originalIsPlatform = process.env.IS_CLOUD;
+    delete process.env.IS_CLOUD;
   });
 
   afterEach(() => {
     invalidateConfigCache();
 
     if (originalIsPlatform !== undefined) {
-      process.env.IS_PLATFORM = originalIsPlatform;
+      process.env.IS_CLOUD = originalIsPlatform;
     } else {
-      delete process.env.IS_PLATFORM;
+      delete process.env.IS_CLOUD;
     }
   });
 
-  test("IS_PLATFORM=true fills provider=gemini in memory without persisting it", () => {
+  test("IS_CLOUD=true fills provider=gemini in memory without persisting it", () => {
     writeConfig({});
-    process.env.IS_PLATFORM = "true";
+    process.env.IS_CLOUD = "true";
 
     const config = loadConfig();
 
-    // In-memory effective config reflects the platform intent.
+    // In-memory effective config reflects the cloud intent.
     expect(config.memory.embeddings.provider).toBe("gemini");
     // geminiModel carries its own schema default — not forced here.
     expect(config.memory.embeddings.geminiModel).toBe("gemini-embedding-2");
@@ -130,20 +130,20 @@ describe("deployment-context embedding-provider default (via loadConfig)", () =>
     expect(qdrantRaw.vectorSize).toBeUndefined();
   });
 
-  test("first launch (no config.json) persists managed service modes but not the platform embedding provider", () => {
+  test("first launch (no config.json) persists cloud service modes but not the cloud embedding provider", () => {
     // No config.json on disk: this is the first-launch SEED path that writes a
     // default config so the file exists for users to edit.
     if (existsSync(CONFIG_PATH)) {
       rmSync(CONFIG_PATH, { force: true });
     }
-    process.env.IS_PLATFORM = "true";
+    process.env.IS_CLOUD = "true";
 
     const config = loadConfig();
 
-    // In-memory effective config still reflects the platform intent.
+    // In-memory effective config still reflects the cloud intent.
     expect(config.memory.embeddings.provider).toBe("gemini");
 
-    // The seeded config.json persists the managed service modes (for
+    // The seeded config.json persists the cloud service modes (for
     // discoverability) but OMITS the embedding provider entirely — not even the
     // schema default "auto". Persisting any value would be read back on the next
     // load as an explicit user choice and permanently suppress re-applying the
@@ -168,7 +168,7 @@ describe("deployment-context embedding-provider default (via loadConfig)", () =>
     expect(webSearchRaw.mode).not.toBe("managed");
 
     // image-generation's managed axis is its provider: the seeded value is
-    // the platform fill "cadet", never an injected managed mode.
+    // the cloud fill "cadet", never an injected managed mode.
     const imageGenRaw = (servicesRaw["image-generation"] ?? {}) as Record<
       string,
       unknown
@@ -177,42 +177,42 @@ describe("deployment-context embedding-provider default (via loadConfig)", () =>
     expect(imageGenRaw.mode).not.toBe("managed");
 
     // Regression guard: on the NEXT load (config.json now exists with the
-    // provider leaf absent), the platform default re-applies in memory rather
+    // provider leaf absent), the cloud default re-applies in memory rather
     // than being lost to a persisted "auto" read back as an explicit choice.
     invalidateConfigCache();
     expect(loadConfig().memory.embeddings.provider).toBe("gemini");
   });
 
-  test("IS_PLATFORM='1' also fills provider=gemini in memory", () => {
+  test("IS_CLOUD='1' also fills provider=gemini in memory", () => {
     writeConfig({});
-    process.env.IS_PLATFORM = "1";
+    process.env.IS_CLOUD = "1";
 
     const config = loadConfig();
 
     expect(config.memory.embeddings.provider).toBe("gemini");
   });
 
-  test("explicit provider on disk wins over the platform default", () => {
+  test("explicit provider on disk wins over the cloud default", () => {
     writeConfig({
       memory: { embeddings: { provider: "local" } },
     });
-    process.env.IS_PLATFORM = "true";
+    process.env.IS_CLOUD = "true";
 
     const config = loadConfig();
 
     expect(config.memory.embeddings.provider).toBe("local");
     expect(config.memory.qdrant.vectorSize).toBe(384);
 
-    // On-disk value is preserved exactly; the platform default does not bleed in.
+    // On-disk value is preserved exactly; the cloud default does not bleed in.
     const raw = readConfig();
     const memoryRaw = raw.memory as Record<string, unknown>;
     const embeddingsRaw = memoryRaw.embeddings as Record<string, unknown>;
     expect(embeddingsRaw.provider).toBe("local");
   });
 
-  test("provider stays auto when IS_PLATFORM is unset", () => {
+  test("provider stays auto when IS_CLOUD is unset", () => {
     writeConfig({});
-    delete process.env.IS_PLATFORM;
+    delete process.env.IS_CLOUD;
 
     const config = loadConfig();
 
@@ -224,7 +224,7 @@ describe("deployment-context embedding-provider default (via loadConfig)", () =>
     if (existsSync(CONFIG_PATH)) {
       rmSync(CONFIG_PATH, { force: true });
     }
-    delete process.env.IS_PLATFORM;
+    delete process.env.IS_CLOUD;
 
     const config = loadConfig();
 
@@ -251,7 +251,7 @@ describe("deployment-context embedding-provider default (via loadConfig)", () =>
     if (existsSync(CONFIG_PATH)) {
       rmSync(CONFIG_PATH, { force: true });
     }
-    delete process.env.IS_PLATFORM;
+    delete process.env.IS_CLOUD;
 
     loadConfig();
     enableMemoryV3LiveForNewWorkspacesMigration.run(WORKSPACE_DIR, {

package/src/config/__tests__/{jev-managed-profile.test.ts → jev-cloud-profile.test.ts}

@@ -5,7 +5,7 @@ import { LLMSchema } from "../schemas/llm.js";
 const PIN = { callSites: { voiceEscalationJudge: { profile: "jev-managed" } } };
 
 describe("jev-managed as a call-site pin target", () => {
-  test("resolves under the managed default provider", () => {
+  test("resolves under the cloud default provider", () => {
     expect(LLMSchema.safeParse(PIN).success).toBe(true);
     expect(
       LLMSchema.safeParse({
@@ -53,7 +53,7 @@ describe("jev-managed as a call-site pin target", () => {
     );
   });
 
-  test("is rejected as the active or advisor profile even on the managed column", () => {
+  test("is rejected as the active or advisor profile even on the cloud column", () => {
     for (const field of ["activeProfile", "advisorProfile"] as const) {
       const result = LLMSchema.safeParse({ [field]: "jev-managed" });
       expect(result.success).toBe(false);
@@ -75,8 +75,6 @@ describe("jev-managed as a call-site pin target", () => {
       },
     });
     expect(result.success).toBe(false);
-    expect(JSON.stringify(result.error?.issues)).toContain(
-      "managed Jev profile",
-    );
+    expect(JSON.stringify(result.error?.issues)).toContain("cloud Jev profile");
   });
 });

package/src/config/__tests__/loader-callsite-strip-fallback.test.ts

@@ -65,12 +65,12 @@ describe("config recovery prunes call-site overrides emptied by a strip", () =>
     if (existsSync(CONFIG_PATH)) {
       rmSync(CONFIG_PATH, { force: true });
     }
-    delete process.env.IS_PLATFORM;
+    delete process.env.IS_CLOUD;
     invalidateConfigCache();
   });
 
   afterEach(() => {
-    delete process.env.IS_PLATFORM;
+    delete process.env.IS_CLOUD;
     if (existsSync(CONFIG_PATH)) {
       rmSync(CONFIG_PATH, { force: true });
     }

package/src/config/__tests__/loader-last-known-good.test.ts

@@ -73,13 +73,13 @@ describe("config recovery ladder for cleanup-resistant invalid config", () => {
     if (existsSync(CONFIG_PATH)) {
       rmSync(CONFIG_PATH, { force: true });
     }
-    delete process.env.IS_PLATFORM;
+    delete process.env.IS_CLOUD;
     invalidateConfigCache();
     _resetLastKnownGoodConfigForTests();
   });
 
   afterEach(() => {
-    delete process.env.IS_PLATFORM;
+    delete process.env.IS_CLOUD;
     if (existsSync(CONFIG_PATH)) {
       rmSync(CONFIG_PATH, { force: true });
     }
@@ -187,16 +187,16 @@ describe("config recovery ladder for cleanup-resistant invalid config", () => {
     expect(config.tools.exclude).toEqual([]);
   });
 
-  test("recovery on a platform daemon returns the context-filled effective config", () => {
-    process.env.IS_PLATFORM = "true";
+  test("recovery on a cloud daemon returns the context-filled effective config", () => {
+    process.env.IS_CLOUD = "true";
 
     // First load with no config.json seeds the file and fills the
-    // deployment-context managed OAuth service modes in memory; the
+    // deployment-context cloud OAuth service modes in memory; the
     // last-known-good snapshot is refreshed AFTER that fill.
     const seeded = loadConfig();
     expect(seeded.services["outlook-oauth"].mode).toBe("managed");
 
-    // Recovery keeps the last-known-good EFFECTIVE config, so the managed mode
+    // Recovery keeps the last-known-good EFFECTIVE config, so the cloud mode
     // survives rather than reverting to the schema default ("your-own").
     const recovered = _recoverFromInvalidConfigForTests(
       {},

package/src/config/__tests__/loader-sparse-array-cleanup.test.ts

@@ -43,12 +43,12 @@ describe("config recovery compacts arrays after stripping invalid elements", ()
     if (existsSync(CONFIG_PATH)) {
       rmSync(CONFIG_PATH, { force: true });
     }
-    delete process.env.IS_PLATFORM;
+    delete process.env.IS_CLOUD;
     invalidateConfigCache();
   });
 
   afterEach(() => {
-    delete process.env.IS_PLATFORM;
+    delete process.env.IS_CLOUD;
     if (existsSync(CONFIG_PATH)) {
       rmSync(CONFIG_PATH, { force: true });
     }

package/src/config/__tests__/profile-materialization.test.ts

@@ -14,7 +14,7 @@ mock.module("../../providers/inference/connections.js", () => ({
     connectionRows.get(name) ?? null,
 }));
 
-import { CADET_MANAGED_CONNECTION_NAME } from "../../providers/cadet-model-routing.js";
+import { CADET_CLOUD_CONNECTION_NAME } from "../../providers/cadet-model-routing.js";
 import { completeCustomProfile } from "../profile-materialization.js";
 import { LLMConfigBase, ProfileEntry } from "../schemas/llm.js";
 
@@ -164,10 +164,10 @@ describe("completeCustomProfile", () => {
     expect(completed.provider_connection).toBeUndefined();
   });
 
-  test("a managed default's binding becomes the routing identity, never a stamped field", () => {
+  test("a cloud default's binding becomes the routing identity, never a stamped field", () => {
     const managedDefault = LLMConfigBase.parse({
       ...fullDefault,
-      provider_connection: CADET_MANAGED_CONNECTION_NAME,
+      provider_connection: CADET_CLOUD_CONNECTION_NAME,
     });
     const implied = completeCustomProfile(managedDefault, { model: "gpt-5.5" });
     expect(implied.provider).toBe("cadet");
@@ -223,16 +223,16 @@ describe("completeCustomProfile", () => {
     }
   });
 
-  test("a managed default binding is not inherited when the identity cannot serve the model", () => {
+  test("a cloud default binding is not inherited when the identity cannot serve the model", () => {
     const managedDefault = LLMConfigBase.parse({
       ...fullDefault,
-      provider_connection: CADET_MANAGED_CONNECTION_NAME,
+      provider_connection: CADET_CLOUD_CONNECTION_NAME,
     });
     const completed = completeCustomProfile(managedDefault, {
       model: "totally-custom-model",
     });
     // Dispatch auto-resolves by vendor instead of pinning an unservable
-    // managed route.
+    // cloud route.
     expect(completed.provider).toBe("anthropic");
     expect(completed.provider_connection).toBeUndefined();
   });
@@ -248,7 +248,7 @@ describe("completeCustomProfile", () => {
     expect(completeCustomProfile(fullDefault, mix)).toBe(mix);
   });
 
-  test("passes managed profiles through untouched", () => {
+  test("passes cloud profiles through untouched", () => {
     const managed: ProfileEntry = { source: "managed", topP: 0.9 };
     expect(completeCustomProfile(fullDefault, managed)).toBe(managed);
   });

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

@@ -37,7 +37,7 @@ afterAll(() => {
   mock.restore();
 });
 
-import { CADET_MANAGED_PROVIDER } from "../../providers/cadet-model-routing.js";
+import { CADET_CLOUD_PROVIDER } from "../../providers/cadet-model-routing.js";
 import { invalidateConfigCache } from "../loader.js";
 import { LLMSchema } from "../schemas/llm.js";
 import {
@@ -75,17 +75,17 @@ describe("seedInferenceProfiles / llm.default", () => {
     if (existsSync(CONFIG_PATH)) {
       rmSync(CONFIG_PATH, { force: true });
     }
-    delete process.env.IS_PLATFORM;
+    delete process.env.IS_CLOUD;
     invalidateConfigCache();
   });
 
   afterEach(() => {
-    delete process.env.IS_PLATFORM;
+    delete process.env.IS_CLOUD;
     invalidateConfigCache();
   });
 
   test("platform hatch writes cadet", () => {
-    process.env.IS_PLATFORM = "true";
+    process.env.IS_CLOUD = "true";
     const llm = seed({ llm: {} }, { isHatch: true });
     expect(llm.default).toEqual({ provider: "cadet" });
   });
@@ -93,7 +93,7 @@ describe("seedInferenceProfiles / llm.default", () => {
   test("platform hatch trusts an existing usable blob provider", () => {
     // Every real platform hatch either writes cadet (no overlay provider) or
     // carries the hatch's own choice; a usable blob is never overwritten.
-    process.env.IS_PLATFORM = "true";
+    process.env.IS_CLOUD = "true";
     const llm = seed(
       { llm: { default: { provider: "anthropic" } } },
       { isHatch: true },
@@ -154,8 +154,8 @@ describe("seedInferenceProfiles / llm.default", () => {
     expect(llm.default).toEqual({ provider: "anthropic" });
   });
 
-  test("BYOK hatch that selected a managed connection writes cadet", () => {
-    // The managed-connection detection reads the active profile (a managed
+  test("BYOK hatch that selected a cloud connection writes cadet", () => {
+    // The cloud-connection detection reads the active profile (a cloud
     // template name), not the blob — with no blob provider the seed writes
     // the resolved decision.
     const llm = seed(
@@ -165,8 +165,8 @@ describe("seedInferenceProfiles / llm.default", () => {
     expect(llm.default).toEqual({ provider: "cadet" });
   });
 
-  test("a pre-existing selection survives a platform hatch untouched", () => {
-    process.env.IS_PLATFORM = "true";
+  test("a pre-existing selection survives a cloud hatch untouched", () => {
+    process.env.IS_CLOUD = "true";
     const llm = seed(
       { llm: { default: { provider: "anthropic" } } },
       { isHatch: true },
@@ -182,7 +182,7 @@ describe("seedInferenceProfiles / llm.default", () => {
     expect(llm.default).toEqual({ provider: "anthropic" });
   });
 
-  test("a pre-existing selection survives a managed-connection hatch untouched", () => {
+  test("a pre-existing selection survives a cloud-connection hatch untouched", () => {
     const llm = seed(
       {
         llm: {
@@ -210,14 +210,14 @@ describe("seedInferenceProfiles / llm.default", () => {
   });
 
   test("no connectionName is ever written", () => {
-    process.env.IS_PLATFORM = "true";
+    process.env.IS_CLOUD = "true";
     const platformLLM = seed(
       { llm: { default: { provider: "anthropic" } } },
       { isHatch: true },
     );
     expect(platformLLM.default?.provider_connection).toBeUndefined();
 
-    delete process.env.IS_PLATFORM;
+    delete process.env.IS_CLOUD;
     const byokLLM = seed(
       { llm: { default: { provider: "openai" } } },
       { isHatch: true },
@@ -228,7 +228,7 @@ describe("seedInferenceProfiles / llm.default", () => {
     expect(fallbackLLM.default?.provider_connection).toBeUndefined();
   });
 
-  test("hatch with the managed provider creates no personal connection", async () => {
+  test("hatch with the cloud provider creates no personal connection", async () => {
     const { initializeDb } = await import("../../persistence/db-init.js");
     const { getDb } = await import("../../persistence/db-connection.js");
     const { providerConnections } =
@@ -237,16 +237,16 @@ describe("seedInferenceProfiles / llm.default", () => {
       await import("../../providers/inference/connections.js");
     await initializeDb();
     try {
-      // A Cadet Cloud hatch: the modern overlay blob names the managed
-      // provider. The managed column routes through the canonical
+      // A Cadet Cloud hatch: the modern overlay blob names the cloud
+      // provider. The cloud column routes through the canonical
       // platform-backed row — a `cadet-personal` connection backed by a
       // user API key must not be created.
       seed(
-        { llm: { default: { provider: CADET_MANAGED_PROVIDER } } },
+        { llm: { default: { provider: CADET_CLOUD_PROVIDER } } },
         { isHatch: true, db: getDb() },
       );
       expect(
-        getConnection(getDb(), `${CADET_MANAGED_PROVIDER}-personal`),
+        getConnection(getDb(), `${CADET_CLOUD_PROVIDER}-personal`),
       ).toBeNull();
       expect(getDb().select().from(providerConnections).all()).toEqual([]);
     } finally {

package/src/config/__tests__/substrate-twin-shadowing.test.ts

@@ -1,3 +1,5 @@
+import { utimesSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { describe, expect, test } from "bun:test";
 
 import { MemorySubstrateConfigSchema } from "../schemas/memory-substrate.js";
@@ -9,6 +11,18 @@ import {
   SUBSTRATE_TWIN_BY_V2_KEY,
 } from "../substrate-twin-shadowing.js";
 
+/**
+ * Write `raw` to the workspace config.json as the state the loader serves.
+ * A distinct mtime per write keeps the loader's file-signature cache from
+ * reading two consecutive seeds as identical.
+ */
+function seedRawConfig(raw: Record<string, unknown>): void {
+  const path = join(process.env.CADET_WORKSPACE_DIR!, "config.json");
+  writeFileSync(path, JSON.stringify(raw));
+  const stamp = new Date(Date.now() + Math.random());
+  utimesSync(path, stamp, stamp);
+}
+
 describe("substrate twin table", () => {
   test("pairs exactly the memory.substrate schema's keys", () => {
     // Drift guard: a substrate key with no entry here is a tunable whose
@@ -44,15 +58,15 @@ describe("substrate twin table", () => {
 
 describe("findSubstrateShadowing", () => {
   test("reports the winning substrate twin for a shadowed memory.v2 key", () => {
-    const raw = {
+    seedRawConfig({
       memory: {
         v2: { consolidation_interval_hours: 4 },
         substrate: { consolidation_interval_hours: 876000 },
       },
-    };
+    });
 
     expect(
-      findSubstrateShadowing(raw, "memory.v2.consolidation_interval_hours"),
+      findSubstrateShadowing("memory.v2.consolidation_interval_hours"),
     ).toEqual({
       substratePath: "memory.substrate.consolidation_interval_hours",
       substrateValue: 876000,
@@ -61,29 +75,31 @@ describe("findSubstrateShadowing", () => {
   });
 
   test("maps the renamed spread keys to their substrate names", () => {
-    const raw = { memory: { v2: {}, substrate: { spread_k: 0.4 } } };
+    seedRawConfig({ memory: { v2: {}, substrate: { spread_k: 0.4 } } });
 
-    expect(findSubstrateShadowing(raw, "memory.v2.k")).toEqual({
+    expect(findSubstrateShadowing("memory.v2.k")).toEqual({
       substratePath: "memory.substrate.spread_k",
       substrateValue: 0.4,
       alsoReadByV2Engine: true,
     });
     // hops has no twin set, so nothing shadows it.
-    expect(findSubstrateShadowing(raw, "memory.v2.hops")).toBeUndefined();
+    expect(findSubstrateShadowing("memory.v2.hops")).toBeUndefined();
   });
 
   test("treats an explicit null twin as set, matching resolveSubstrateTuning", () => {
     // `orV2` falls back only on `undefined`, so a null substrate value wins —
-    // and it is exactly the value the consolidation freeze writes.
-    const raw = {
+    // and it is exactly the value the consolidation freeze writes. The field
+    // is nullable in the schema, so the null survives the loader's parse and
+    // stays present in the running config.
+    seedRawConfig({
       memory: {
         v2: { consolidation_max_buffer_lines: 100 },
         substrate: { consolidation_max_buffer_lines: null },
       },
-    };
+    });
 
     expect(
-      findSubstrateShadowing(raw, "memory.v2.consolidation_max_buffer_lines"),
+      findSubstrateShadowing("memory.v2.consolidation_max_buffer_lines"),
     ).toEqual({
       substratePath: "memory.substrate.consolidation_max_buffer_lines",
       substrateValue: null,
@@ -92,29 +108,23 @@ describe("findSubstrateShadowing", () => {
   });
 
   test("returns nothing for unshadowed paths", () => {
-    const raw = {
+    // No memory.substrate subtree at all.
+    seedRawConfig({ memory: { v2: { bm25_b: 0.6 } } });
+    expect(findSubstrateShadowing("memory.v2.bm25_b")).toBeUndefined();
+
+    seedRawConfig({
       memory: {
         v2: { bm25_b: 0.6, enabled: true },
         substrate: { bm25_b: 0.3 },
       },
-    };
-
-    // No memory.substrate subtree at all.
-    expect(
-      findSubstrateShadowing(
-        { memory: { v2: { bm25_b: 0.6 } } },
-        "memory.v2.bm25_b",
-      ),
-    ).toBeUndefined();
+    });
     // A v2 key with no substrate twin.
-    expect(findSubstrateShadowing(raw, "memory.v2.enabled")).toBeUndefined();
+    expect(findSubstrateShadowing("memory.v2.enabled")).toBeUndefined();
     // The substrate key itself is what wins — writing it is never shadowed.
-    expect(
-      findSubstrateShadowing(raw, "memory.substrate.bm25_b"),
-    ).toBeUndefined();
+    expect(findSubstrateShadowing("memory.substrate.bm25_b")).toBeUndefined();
     // Paths outside the memory namespace, and the wrong depth.
-    expect(findSubstrateShadowing(raw, "memory.v2")).toBeUndefined();
-    expect(findSubstrateShadowing(raw, "llm.v2.bm25_b")).toBeUndefined();
+    expect(findSubstrateShadowing("memory.v2")).toBeUndefined();
+    expect(findSubstrateShadowing("llm.v2.bm25_b")).toBeUndefined();
   });
 });
 

package/src/config/__tests__/sync-gated-profiles.test.ts

@@ -73,19 +73,19 @@ describe("reconcileFlagGatedProfiles", () => {
     if (existsSync(CONFIG_PATH)) {
       rmSync(CONFIG_PATH, { force: true });
     }
-    delete process.env.IS_PLATFORM;
+    delete process.env.IS_CLOUD;
     setOverridesForTesting({});
     invalidateConfigCache();
   });
 
   afterEach(() => {
-    delete process.env.IS_PLATFORM;
+    delete process.env.IS_CLOUD;
     setOverridesForTesting({});
     invalidateConfigCache();
   });
 
-  test("flag on materializes the managed os-beta profile after balanced", () => {
-    process.env.IS_PLATFORM = "true";
+  test("flag on materializes the cloud os-beta profile after balanced", () => {
+    process.env.IS_CLOUD = "true";
     seedBalancedConfig();
     setOverridesForTesting({ "os-beta": true });
 
@@ -127,7 +127,7 @@ describe("reconcileFlagGatedProfiles", () => {
   });
 
   test("flag on is idempotent across repeated runs", () => {
-    process.env.IS_PLATFORM = "true";
+    process.env.IS_CLOUD = "true";
     seedBalancedConfig();
     setOverridesForTesting({ "os-beta": true });
 
@@ -136,8 +136,8 @@ describe("reconcileFlagGatedProfiles", () => {
     expect(reconcileFlagGatedProfiles()).toBe(false);
   });
 
-  test("flag on preserves user overrides on the managed profile", () => {
-    process.env.IS_PLATFORM = "true";
+  test("flag on preserves user overrides on the cloud profile", () => {
+    process.env.IS_CLOUD = "true";
     seedBalancedConfig();
     setOverridesForTesting({ "os-beta": true });
     reconcileFlagGatedProfiles();
@@ -165,8 +165,8 @@ describe("reconcileFlagGatedProfiles", () => {
     expect(effective.effort).toBe("low");
   });
 
-  test("flag off removes a managed os-beta and applies fallbacks", () => {
-    process.env.IS_PLATFORM = "true";
+  test("flag off removes a cloud os-beta and applies fallbacks", () => {
+    process.env.IS_CLOUD = "true";
     seedBalancedConfig();
     setOverridesForTesting({ "os-beta": true });
     reconcileFlagGatedProfiles();
@@ -188,7 +188,7 @@ describe("reconcileFlagGatedProfiles", () => {
   });
 
   test("flag off with no os-beta present is a no-op", () => {
-    process.env.IS_PLATFORM = "true";
+    process.env.IS_CLOUD = "true";
     seedBalancedConfig();
     setOverridesForTesting({ "os-beta": false });
 
@@ -196,7 +196,7 @@ describe("reconcileFlagGatedProfiles", () => {
   });
 
   test("flag off scrubs os-beta from user mix arms, keeping >= 2-arm mixes", () => {
-    process.env.IS_PLATFORM = "true";
+    process.env.IS_CLOUD = "true";
     seedBalancedConfig();
     setOverridesForTesting({ "os-beta": true });
     reconcileFlagGatedProfiles();
@@ -233,7 +233,7 @@ describe("reconcileFlagGatedProfiles", () => {
   });
 
   test("flag off removes a two-arm mix that loses os-beta and repoints refs", () => {
-    process.env.IS_PLATFORM = "true";
+    process.env.IS_CLOUD = "true";
     seedBalancedConfig();
     setOverridesForTesting({ "os-beta": true });
     reconcileFlagGatedProfiles();
@@ -279,7 +279,7 @@ describe("reconcileFlagGatedProfiles", () => {
   });
 
   test("flag off shortens a three-arm mix to two surviving arms", () => {
-    process.env.IS_PLATFORM = "true";
+    process.env.IS_CLOUD = "true";
     seedBalancedConfig();
     setOverridesForTesting({ "os-beta": true });
     reconcileFlagGatedProfiles();
@@ -312,7 +312,7 @@ describe("reconcileFlagGatedProfiles", () => {
   });
 
   test("flag off clears a call-site profile reference to os-beta", () => {
-    process.env.IS_PLATFORM = "true";
+    process.env.IS_CLOUD = "true";
     seedBalancedConfig();
     setOverridesForTesting({ "os-beta": true });
     reconcileFlagGatedProfiles();
@@ -341,7 +341,7 @@ describe("reconcileFlagGatedProfiles", () => {
   });
 
   test("a user-owned os-beta profile is never touched", () => {
-    process.env.IS_PLATFORM = "true";
+    process.env.IS_CLOUD = "true";
     writeConfig({
       llm: {
         default: { provider: "anthropic" },
@@ -369,8 +369,8 @@ describe("reconcileFlagGatedProfiles", () => {
     expect(readFileSync(CONFIG_PATH, "utf-8")).toBe(before);
   });
 
-  test("auto-profile flag on materializes the managed auto profile at the head of the order", () => {
-    process.env.IS_PLATFORM = "true";
+  test("auto-profile flag on materializes the cloud auto profile at the head of the order", () => {
+    process.env.IS_CLOUD = "true";
     seedBalancedConfig();
     setOverridesForTesting({ "auto-profile": true });
 
@@ -398,8 +398,8 @@ describe("reconcileFlagGatedProfiles", () => {
     expect(getEffectiveProfile(raw.llm.profiles, "auto")).toBeDefined();
   });
 
-  test("auto-profile flag off removes the managed auto profile and repoints its references", () => {
-    process.env.IS_PLATFORM = "true";
+  test("auto-profile flag off removes the cloud auto profile and repoints its references", () => {
+    process.env.IS_CLOUD = "true";
     seedBalancedConfig();
     setOverridesForTesting({ "auto-profile": true });
     reconcileFlagGatedProfiles();
@@ -425,7 +425,7 @@ describe("reconcileFlagGatedProfiles", () => {
   });
 
   test("os-beta and auto-profile reconcile independently in one pass", () => {
-    process.env.IS_PLATFORM = "true";
+    process.env.IS_CLOUD = "true";
     seedBalancedConfig();
     setOverridesForTesting({ "os-beta": true, "auto-profile": true });
     expect(reconcileFlagGatedProfiles()).toBe(true);