@mycadet/assistant 0.12.7 → 0.12.8

package/src/__tests__/config-loader-cloud-defaults.test.ts

@@ -0,0 +1,373 @@
+/**
+ * When IS_CLOUD=true and no config.json exists yet, loadConfig() must
+ * write all managed-capable service modes as "managed" instead of the
+ * per-service schema default. When IS_CLOUD is absent/false, or when
+ * config.json already exists, the Zod schema defaults and existing values
+ * are preserved unchanged — note that `google-oauth` and `notion-oauth`
+ * default to "managed" at the schema level (per JARVIS-966), while every
+ * other managed-capable service defaults to "your-own".
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mocks — declared before imports that depend on platform/logger
+// ---------------------------------------------------------------------------
+
+const WORKSPACE_DIR = process.env.CADET_WORKSPACE_DIR!;
+const CONFIG_PATH = join(WORKSPACE_DIR, "config.json");
+
+afterAll(() => {
+  mock.restore();
+});
+
+import { invalidateConfigCache, loadConfig } from "../config/loader.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function ensureTestDir(): void {
+  const dirs = [
+    WORKSPACE_DIR,
+    join(WORKSPACE_DIR, "data"),
+    join(WORKSPACE_DIR, "data", "memory"),
+    join(WORKSPACE_DIR, "data", "memory", "knowledge"),
+    join(WORKSPACE_DIR, "data", "logs"),
+  ];
+  for (const dir of dirs) {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+}
+
+function resetWorkspace(): void {
+  if (existsSync(WORKSPACE_DIR)) {
+    for (const name of readdirSync(WORKSPACE_DIR)) {
+      rmSync(join(WORKSPACE_DIR, name), { recursive: true, force: true });
+    }
+  }
+  ensureTestDir();
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+}
+
+// When IS_CLOUD=true, every managed-capable service defaults to "managed".
+// Without IS_CLOUD, services split by Zod schema default: google/notion-oauth
+// resolve to "managed" (per JARVIS-966), the rest resolve to "your-own".
+// web-search is deliberately absent: `provider` is its only axis, so the
+// platform context injects no mode for it. image-generation is also absent:
+// its managed axis is the provider ("cadet" proxies through the cloud),
+// so the cloud context fills `provider: "cadet"` rather than a mode.
+const MANAGED_SERVICES = [
+  "google-oauth",
+  "outlook-oauth",
+  "linear-oauth",
+  "github-oauth",
+  "notion-oauth",
+] as const;
+
+/**
+ * Services whose Zod schema default is `"managed"` rather than `"your-own"`.
+ * For these, the fresh-write and in-memory paths produce `"managed"` even
+ * when IS_CLOUD is false/unset — the schema default applies regardless of
+ * deployment context. See `assistant/src/config/schemas/services.ts` and
+ * JARVIS-966: managed mode is the optimization target for new users on
+ * managed-capable infra, since the BYO flow requires a Google Cloud /
+ * Notion integration setup that most users never complete.
+ */
+const SCHEMA_MANAGED_DEFAULT_SERVICES = [
+  "google-oauth",
+  "notion-oauth",
+] as const;
+
+// web-search is absent from both lists: it carries no mode at all.
+// image-generation and web-search are absent from both lists: they carry
+// no mode at all.
+const SCHEMA_YOUR_OWN_DEFAULT_SERVICES = [
+  "outlook-oauth",
+  "linear-oauth",
+  "github-oauth",
+] as const;
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("cloud-managed config defaults", () => {
+  const originalIsPlatform = process.env.IS_CLOUD;
+
+  beforeEach(() => {
+    resetWorkspace();
+    invalidateConfigCache();
+  });
+
+  afterEach(() => {
+    invalidateConfigCache();
+    // Restore env to its original value
+    if (originalIsPlatform === undefined) {
+      delete process.env.IS_CLOUD;
+    } else {
+      process.env.IS_CLOUD = originalIsPlatform;
+    }
+  });
+
+  test("IS_CLOUD=true, no config file → all 6 cloud service modes written as 'managed', image-generation provider written as 'cadet'", () => {
+    process.env.IS_CLOUD = "true";
+
+    loadConfig();
+
+    expect(existsSync(CONFIG_PATH)).toBe(true);
+    const written = readConfig() as { services?: Record<string, unknown> };
+    expect(written.services).toBeDefined();
+    const services = written.services!;
+    for (const svc of MANAGED_SERVICES) {
+      expect((services[svc] as { mode?: string })?.mode).toBe("managed");
+    }
+    expect((services["web-search"] as { provider?: string })?.provider).toBe(
+      "inference-provider-native",
+    );
+    // image-generation's managed axis is its provider: the cloud context
+    // fills "cadet" and never injects a cloud mode (the persisted mode is
+    // the schema default).
+    const imageGen = services["image-generation"] as {
+      provider?: string;
+      mode?: string;
+    };
+    expect(imageGen?.provider).toBe("cadet");
+    expect(imageGen?.mode).not.toBe("managed");
+  });
+
+  test("IS_CLOUD=false, no config file → service modes follow schema defaults (your-own except google/notion-oauth which are managed)", () => {
+    process.env.IS_CLOUD = "false";
+
+    loadConfig();
+
+    expect(existsSync(CONFIG_PATH)).toBe(true);
+    const written = readConfig() as { services?: Record<string, unknown> };
+    expect(written.services).toBeDefined();
+    const services = written.services!;
+    for (const svc of SCHEMA_YOUR_OWN_DEFAULT_SERVICES) {
+      expect((services[svc] as { mode?: string })?.mode).toBe("your-own");
+    }
+    for (const svc of SCHEMA_MANAGED_DEFAULT_SERVICES) {
+      expect((services[svc] as { mode?: string })?.mode).toBe("managed");
+    }
+  });
+
+  test("IS_CLOUD unset, no config file → service modes follow schema defaults (your-own except google/notion-oauth which are managed)", () => {
+    delete process.env.IS_CLOUD;
+
+    loadConfig();
+
+    expect(existsSync(CONFIG_PATH)).toBe(true);
+    const written = readConfig() as { services?: Record<string, unknown> };
+    expect(written.services).toBeDefined();
+    const services = written.services!;
+    for (const svc of SCHEMA_YOUR_OWN_DEFAULT_SERVICES) {
+      expect((services[svc] as { mode?: string })?.mode).toBe("your-own");
+    }
+    for (const svc of SCHEMA_MANAGED_DEFAULT_SERVICES) {
+      expect((services[svc] as { mode?: string })?.mode).toBe("managed");
+    }
+  });
+
+  test("IS_CLOUD=true, config file already exists → existing service mode values are preserved", () => {
+    process.env.IS_CLOUD = "true";
+
+    // Write an existing config with image-generation mode explicitly set to "your-own"
+    writeFileSync(
+      CONFIG_PATH,
+      JSON.stringify(
+        {
+          services: {
+            "image-generation": { mode: "your-own" },
+          },
+        },
+        null,
+        2,
+      ) + "\n",
+    );
+
+    const config = loadConfig();
+
+    const written = readConfig() as { services?: Record<string, unknown> };
+    expect(written.services).toBeDefined();
+    // The raw value must be preserved — backfill path, not fresh-write path.
+    // (Migration 134 rewrites this legacy shape at daemon startup; the loader
+    // itself must simply leave it alone.)
+    expect(
+      (written.services!["image-generation"] as { mode?: string })?.mode,
+    ).toBe("your-own");
+    // The parsed config strips the legacy key and carries the filled
+    // provider; no mode survives the schema.
+    expect(config.services["image-generation"]).not.toHaveProperty("mode");
+    expect(config.services["image-generation"].provider).toBe("cadet");
+  });
+
+  test("IS_CLOUD=true, config file with explicit notion-oauth mode='your-own' → preserved (schema default is 'managed')", () => {
+    process.env.IS_CLOUD = "true";
+
+    // notion-oauth's schema default is "managed" (per JARVIS-966), but an
+    // explicit user choice of "your-own" must win — the fill-defaults pass
+    // must never override an explicit value, even one that contradicts the
+    // schema default. Mirror of the image-generation "your-own preserved"
+    // test above, but for a service whose schema default is "managed".
+    writeFileSync(
+      CONFIG_PATH,
+      JSON.stringify(
+        {
+          services: {
+            "notion-oauth": { mode: "your-own" },
+          },
+        },
+        null,
+        2,
+      ) + "\n",
+    );
+
+    const config = loadConfig();
+
+    const written = readConfig() as { services?: Record<string, unknown> };
+    expect(written.services).toBeDefined();
+    expect((written.services!["notion-oauth"] as { mode?: string })?.mode).toBe(
+      "your-own",
+    );
+    expect(config.services["notion-oauth"].mode).toBe("your-own");
+  });
+
+  test("IS_CLOUD=true, config file exists without a services key → in-memory config has all managed modes", () => {
+    // Regression guard for the cloud-managed boot order: by the time
+    // `loadConfig()` runs, lifecycle steps such as `seedInferenceProfiles`
+    // have already written `config.json` (with `llm.profiles` etc.), so
+    // `configFileExisted` is true even on a brand-new cloud-managed
+    // assistant. Deployment-context defaults must still be applied to the
+    // in-memory config for any leaf keys that are absent from disk.
+    process.env.IS_CLOUD = "true";
+
+    writeFileSync(
+      CONFIG_PATH,
+      JSON.stringify(
+        {
+          llm: {
+            profiles: {
+              balanced: { provider: "anthropic", model: "claude-sonnet-4.5" },
+            },
+            activeProfile: "balanced",
+          },
+        },
+        null,
+        2,
+      ) + "\n",
+    );
+
+    const config = loadConfig();
+
+    // In-memory config has the deployment-context defaults applied for the
+    // missing service-mode fields.
+    for (const svc of MANAGED_SERVICES) {
+      expect(
+        (config.services as unknown as Record<string, { mode: string }>)[svc]!
+          .mode,
+      ).toBe("managed");
+    }
+    // ...and for image-generation's provider, whose fill is "cadet".
+    expect(config.services["image-generation"].provider).toBe("cadet");
+
+    // The on-disk file is NOT modified by the fill pass — disk reflects only
+    // what was already there. Existing-file branch never re-writes config.json.
+    const onDisk = readConfig() as Record<string, unknown>;
+    expect(onDisk["services"]).toBeUndefined();
+  });
+
+  test("IS_CLOUD=true, config file exists with an explicit image-generation provider → provider wins over the cadet fill", () => {
+    process.env.IS_CLOUD = "true";
+
+    // User has an explicit BYOK image-generation provider on disk. The fill
+    // pass targets exactly that leaf (`provider: "cadet"`), so the explicit
+    // value must win and no mode is injected — the effective mode is the
+    // schema default.
+    writeFileSync(
+      CONFIG_PATH,
+      JSON.stringify(
+        {
+          services: {
+            "image-generation": { provider: "openai" },
+          },
+        },
+        null,
+        2,
+      ) + "\n",
+    );
+
+    const config = loadConfig();
+
+    const imageGen = (
+      config.services as unknown as Record<
+        string,
+        { mode?: string; provider?: string }
+      >
+    )["image-generation"]!;
+    expect(imageGen.provider).toBe("openai");
+    expect(imageGen).not.toHaveProperty("mode");
+  });
+
+  test("IS_CLOUD=false, config file exists without services key → in-memory config keeps schema defaults (your-own except google/notion-oauth which are managed)", () => {
+    // Sanity guard: deployment-context defaults are a no-op when IS_CLOUD
+    // is not enabled, regardless of whether config.json existed. The Zod
+    // schema defaults still apply, so google-oauth and notion-oauth resolve
+    // to "managed" while the remaining services resolve to "your-own".
+    process.env.IS_CLOUD = "false";
+
+    writeFileSync(
+      CONFIG_PATH,
+      JSON.stringify(
+        {
+          llm: {
+            profiles: {
+              balanced: { provider: "anthropic", model: "claude-sonnet-4.5" },
+            },
+            activeProfile: "balanced",
+          },
+        },
+        null,
+        2,
+      ) + "\n",
+    );
+
+    const config = loadConfig();
+
+    for (const svc of SCHEMA_YOUR_OWN_DEFAULT_SERVICES) {
+      expect(
+        (config.services as unknown as Record<string, { mode: string }>)[svc]!
+          .mode,
+      ).toBe("your-own");
+    }
+    for (const svc of SCHEMA_MANAGED_DEFAULT_SERVICES) {
+      expect(
+        (config.services as unknown as Record<string, { mode: string }>)[svc]!
+          .mode,
+      ).toBe("managed");
+    }
+  });
+});

package/src/__tests__/config-loader-corrupt.test.ts

@@ -148,7 +148,7 @@ describe("loadConfig corrupt-file recovery", () => {
 
   // ---------------------------------------------------------------------------
   // Shape-mismatch quarantine — same JSON.parse caveat as `loadRawConfig`.
-  // Without an `isPlainObject` check, downstream code (e.g. the managed-Gemini
+  // Without an `isPlainObject` check, downstream code (e.g. the cloud-Gemini
   // `setNestedValue` block in `loadConfig`) would TypeError on `null` or
   // primitive `fileConfig`, and only the broad try/catch around the migration
   // saved startup. Treating the wrong-shape case as a parse error here moves

package/src/__tests__/config-loader-validation-reset-notice.test.ts

@@ -4,7 +4,7 @@
  * cloneDefaultConfig), it writes a JSON sentinel to
  * <workspace>/data/config-validation-reset-notice.json recording the reset.
  * The per-turn `config-validation-reset-notice` injector surfaces that event to
- * the agent so a setting that silently reverted (e.g. a managed Outlook/OAuth
+ * the agent so a setting that silently reverted (e.g. a cloud Outlook/OAuth
  * service mode) becomes explainable — matching LUM-2758.
  *
  * The revealing case: a wrong-type `llm.profiles` fails the first parse so

package/src/__tests__/config-schema.test.ts

@@ -1637,7 +1637,7 @@ describe("AssistantConfigSchema", () => {
   });
 
   // Legacy config objects on disk may carry a `mode` key. Parsing must strip
-  // it rather than reject the config — and must not treat it as a managed
+  // it rather than reject the config — and must not treat it as a cloud
   // selection, which is what migration 130 rewrites to `provider: "cadet"`.
   test("ignores a legacy tts mode key", () => {
     const result = AssistantConfigSchema.parse({
@@ -1799,7 +1799,7 @@ describe("AssistantConfigSchema", () => {
   });
 
   // Legacy config objects on disk may carry a `mode` key. Parsing must strip
-  // it rather than reject the config — and must not treat it as a managed
+  // it rather than reject the config — and must not treat it as a cloud
   // selection, which is what migration 130 rewrites to `provider: "cadet"`.
   test("ignores a legacy stt mode key", () => {
     const result = AssistantConfigSchema.parse({
@@ -2098,7 +2098,7 @@ describe("TTS provider catalog integration", () => {
       const resolved = resolveTtsConfig(config);
       expect(resolved.provider).toBe(providerId);
       if (providerId === "cadet") {
-        // The cadet config block is intentionally empty — the platform
+        // The cadet config block is intentionally empty — the cloud
         // pins the voice and model.
         expect(resolved.providerConfig).toEqual({});
       } else {

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

@@ -8,10 +8,10 @@ import { Command } from "commander";
 // The `config` CLI is now an IPC-tagged command (routed via cliIpcCall) so
 // these tests assert on the IPC calls the CLI emits, not on direct loader
 // writes. The only non-IPC interaction is `requirePlatformConnection`, which
-// reads the platform client - mocked below.
+// reads the cloud client - mocked below.
 // ---------------------------------------------------------------------------
 
-let mockPlatformClientCreate: () => Promise<Record<
+let mockCloudClientCreate: () => Promise<Record<
   string,
   unknown
 > | null> = async () => null;
@@ -32,9 +32,9 @@ let mockIpcResult: {
 // Mocks - platform/client (controls requirePlatformConnection)
 // ---------------------------------------------------------------------------
 
-mock.module("../platform/client.js", () => ({
-  CadetPlatformClient: {
-    create: () => mockPlatformClientCreate(),
+mock.module("../cloud/client.js", () => ({
+  CadetCloudClient: {
+    create: () => mockCloudClientCreate(),
   },
 }));
 
@@ -152,7 +152,7 @@ async function runCli(
 describe("config set - cloud connection guard for service mode paths", () => {
   beforeEach(() => {
     // Default: not connected to platform
-    mockPlatformClientCreate = async () => null;
+    mockCloudClientCreate = async () => null;
     mockIpcCalls.length = 0;
     mockIpcResult = { ok: true, result: { ok: true } };
   });

package/src/__tests__/config-watcher-cleanup-throttle.test.ts

@@ -144,14 +144,6 @@ function seedCleanup(
   });
 }
 
-mock.module("../config/assistant-feature-flags.js", () => ({
-  clearFeatureFlagOverridesCache: () => {},
-}));
-
-mock.module("../persistence/embeddings/embedding-backend.js", () => ({
-  clearEmbeddingBackendCache: () => {},
-}));
-
 mock.module("../providers/registry.js", () => ({
   initializeProviders: async () => {},
 }));

package/src/__tests__/config-watcher.test.ts

@@ -153,7 +153,7 @@ mock.module("../runtime/sync/resource-sync-events.js", () => ({
   },
 }));
 
-mock.module("../platform/sync-identity.js", () => ({
+mock.module("../cloud/sync-identity.js", () => ({
   syncIdentityNameToPlatform: () => {},
 }));
 

package/src/__tests__/contacts-write.test.ts

@@ -215,7 +215,7 @@ describe("identity-mirror faithful-replica semantics", () => {
       sourceChannel: "slack",
       externalUserId: "UDEE",
       externalChatId: "DDEE",
-      displayName: "Raw Platform Name",
+      displayName: "Raw Cloud Name",
       contactId: "co-dee",
     });
 

package/src/__tests__/conversation-agent-loop.test.ts

@@ -2797,7 +2797,7 @@ describe("session-agent-loop", () => {
     });
 
     test("attributes a fallback serve to the profile that actually served", async () => {
-      // The turn resolved to the primary managed profile, the request hit an
+      // The turn resolved to the primary cloud profile, the request hit an
       // outage-shaped failure, and `RetryProvider` escalated to a backup
       // profile on a different provider, stamping `actualProvider` and
       // `actualInferenceProfile` on the response it returns.
@@ -4054,7 +4054,7 @@ describe("session-agent-loop", () => {
       });
     });
 
-    test("does not persist managed credential refresh failures as assistant text", async () => {
+    test("does not persist cloud credential refresh failures as assistant text", async () => {
       mockConversationErrorClassification = {
         code: "MANAGED_KEY_INVALID",
         userMessage: "Couldn't refresh assistant credentials.",

package/src/__tests__/conversation-app-control-instantiation.test.ts

@@ -33,6 +33,17 @@
 import { createRequire } from "node:module";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import {
+  ALL_REGISTRY_FLAG_KEYS,
+  setOverridesForTesting,
+} from "../__tests__/feature-flag-test-helpers.js";
+
+// Real flag cache seeded to mirror the former module mock: every declared
+// flag on, with "app-control" pinned per test.
+const ALL_ON = Object.fromEntries(
+  ALL_REGISTRY_FLAG_KEYS.map((k) => [k, true]),
+) as Record<string, boolean>;
+
 // Freeze the real node:fs exports before `mock.module("node:fs", ...)` below
 // registers. A live `import * as` namespace would be remapped to the mock
 // itself once the factory runs, turning the pass-through fallback into
@@ -52,17 +63,6 @@ import type { Tool } from "../tools/types.js";
 // Module mocks for the skill-projection layer
 // ---------------------------------------------------------------------------
 
-let appControlFlagEnabled = false;
-mock.module("../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: (key: string) => {
-    if (key === "app-control") {
-      return appControlFlagEnabled;
-    }
-    return true;
-  },
-  loadDefaultsRegistry: () => ({}),
-}));
-
 mock.module("../config/skill-state.js", () => ({
   skillFlagKey: (skill: { featureFlag?: string }) =>
     skill.featureFlag ?? undefined,
@@ -336,11 +336,11 @@ function makeAppControlManifest(): SkillToolManifest {
 
 describe("HostAppControlProxy instantiation gate", () => {
   beforeEach(() => {
-    appControlFlagEnabled = false;
+    setOverridesForTesting({ ...ALL_ON, "app-control": false });
   });
 
   test("macOS client attaches HostAppControlProxy and preactivates app-control (flag off)", () => {
-    appControlFlagEnabled = false;
+    setOverridesForTesting({ ...ALL_ON, "app-control": false });
     const conv = makeFakeConversation();
 
     applyAppControlInstantiation(conv, "macos");
@@ -351,7 +351,7 @@ describe("HostAppControlProxy instantiation gate", () => {
   });
 
   test("macOS client attaches HostAppControlProxy and preactivates app-control (flag on)", () => {
-    appControlFlagEnabled = true;
+    setOverridesForTesting({ ...ALL_ON, "app-control": true });
     const conv = makeFakeConversation();
 
     applyAppControlInstantiation(conv, "macos");
@@ -361,7 +361,7 @@ describe("HostAppControlProxy instantiation gate", () => {
   });
 
   test("non-macOS client (slack) does not attach HostAppControlProxy nor preactivate app-control", () => {
-    appControlFlagEnabled = true;
+    setOverridesForTesting({ ...ALL_ON, "app-control": true });
     const conv = makeFakeConversation();
 
     applyAppControlInstantiation(conv, "slack");
@@ -371,7 +371,7 @@ describe("HostAppControlProxy instantiation gate", () => {
   });
 
   test("chrome-extension client does not attach HostAppControlProxy (host_app_control unsupported)", () => {
-    appControlFlagEnabled = true;
+    setOverridesForTesting({ ...ALL_ON, "app-control": true });
     const conv = makeFakeConversation();
     // Sanity check: chrome-extension supports host_browser, NOT host_app_control.
     expect(supportsHostProxy("chrome-extension", "host_app_control")).toBe(
@@ -399,7 +399,7 @@ describe("Skill projection — app-control feature-flag gating", () => {
   });
 
   test("flag off: app-control is filtered out of projected tools even when preactivated", () => {
-    appControlFlagEnabled = false;
+    setOverridesForTesting({ ...ALL_ON, "app-control": false });
 
     const sessionState = new Map<string, string>();
     const result = projectSkillTools([], {
@@ -412,7 +412,7 @@ describe("Skill projection — app-control feature-flag gating", () => {
   });
 
   test("flag on: app-control tools are projected when preactivated", () => {
-    appControlFlagEnabled = true;
+    setOverridesForTesting({ ...ALL_ON, "app-control": true });
 
     const sessionState = new Map<string, string>();
     const result = projectSkillTools([], {