@mycadet/assistant 0.12.7 → 0.12.8

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__/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);