@mycadet/assistant 0.12.7 → 0.12.8

package/src/__tests__/delete-managed-skill-tool.test.ts

@@ -15,7 +15,7 @@ mock.module("../daemon/skill-memory-refresh.js", () => ({
   refreshSkillCapabilityMemories: mockRefreshSkillCapabilityMemories,
 }));
 
-import { executeDeleteManagedSkill } from "../tools/skills/delete-managed.js";
+import { executeDeleteCloudSkill } from "../tools/skills/delete-cloud.js";
 import type { ToolContext } from "../tools/types.js";
 
 function makeContext(): ToolContext {
@@ -44,7 +44,7 @@ afterEach(() => {
   rmSync(join(TEST_DIR, "skills"), { recursive: true, force: true });
 });
 
-describe("delete_managed_skill tool", () => {
+describe("delete_cloud_skill tool", () => {
   test("keeps legacy index control as a deprecated no-op schema field", () => {
     const tools = JSON.parse(
       readFileSync(
@@ -56,7 +56,7 @@ describe("delete_managed_skill tool", () => {
       ),
     );
     const deleteTool = tools.tools.find(
-      (tool: { name: string }) => tool.name === "delete_managed_skill",
+      (tool: { name: string }) => tool.name === "delete_cloud_skill",
     );
 
     expect(deleteTool).toBeDefined();
@@ -74,7 +74,7 @@ describe("delete_managed_skill tool", () => {
     const staleIndex = "- doomed\n- survivor\n";
     writeFileSync(indexPath, staleIndex);
 
-    const result = await executeDeleteManagedSkill(
+    const result = await executeDeleteCloudSkill(
       {
         skill_id: "doomed",
       },
@@ -97,7 +97,7 @@ describe("delete_managed_skill tool", () => {
   test("accepts legacy remove_from_index input without returning index metadata", async () => {
     createSkill("legacy-delete");
 
-    const result = await executeDeleteManagedSkill(
+    const result = await executeDeleteCloudSkill(
       {
         skill_id: "legacy-delete",
         remove_from_index: true,
@@ -114,7 +114,7 @@ describe("delete_managed_skill tool", () => {
   });
 
   test("returns error for non-existent skill", async () => {
-    const result = await executeDeleteManagedSkill(
+    const result = await executeDeleteCloudSkill(
       {
         skill_id: "ghost",
       },
@@ -127,13 +127,13 @@ describe("delete_managed_skill tool", () => {
   });
 
   test("rejects missing skill_id", async () => {
-    const result = await executeDeleteManagedSkill({}, makeContext());
+    const result = await executeDeleteCloudSkill({}, makeContext());
     expect(result.isError).toBe(true);
     expect(result.content).toContain("skill_id is required");
   });
 
   test("rejects invalid skill_id", async () => {
-    const result = await executeDeleteManagedSkill(
+    const result = await executeDeleteCloudSkill(
       {
         skill_id: "../escape",
       },

package/src/__tests__/discord-callback-round-trip.test.ts

@@ -90,7 +90,7 @@ describe("a Discord reply reaches the Discord transport", () => {
   test("Discord declines streaming rather than faking it", () => {
     // No primitive exists, so the transport omits the method and the caller
     // sends the finished reply. An implementation here would be a repeated
-    // edit, which is the approach the platforms discourage.
+    // edit, which is the approach the clouds discourage.
     expect(getTransportForCallback(DISCORD_CALLBACK)?.streamReply).toBe(
       undefined,
     );

package/src/__tests__/disk-usage.test.ts

@@ -88,7 +88,7 @@ const { __resetDiskUsageCacheForTests, getDiskUsageInfo, parseK8sMemoryBytes } =
 const ENV_VARS = [
   "CADET_MINIKUBE_STORAGE_SIZE",
   "IS_CONTAINERIZED",
-  "IS_PLATFORM",
+  "IS_CLOUD",
 ] as const;
 
 afterAll(() => {
@@ -211,9 +211,9 @@ describe("disk usage sampler", () => {
     );
   });
 
-  test("does not use du for platform-managed containerized instances", async () => {
+  test("does not use du for cloud-managed containerized instances", async () => {
     process.env.IS_CONTAINERIZED = "1";
-    process.env.IS_PLATFORM = "1";
+    process.env.IS_CLOUD = "1";
     const before = statfsSnapshot(PRELOAD_WS);
     const usage = await getDiskUsageInfo();
     const after = statfsSnapshot(PRELOAD_WS);

package/src/__tests__/email-invite-adapter.test.ts

@@ -2,9 +2,9 @@
  * Tests for the email invite adapter.
  *
  * Verifies that the email adapter resolves the assistant's address from the
- * shared registered-inbox reader (the platform is the only writer of managed
+ * shared registered-inbox reader (the cloud is the only writer of managed
  * inbox registrations) and falls back to `undefined` when no address is
- * registered or the platform cannot be asked.
+ * registered or the cloud cannot be asked.
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -49,14 +49,14 @@ describe("emailInviteAdapter", () => {
     expect(handle).toBeUndefined();
   });
 
-  test("returns undefined when the platform is not connected", async () => {
+  test("returns undefined when the cloud is not connected", async () => {
     mockInboxState = { status: "no_platform" };
 
     const handle = await resolveAdapterHandle(emailInviteAdapter);
     expect(handle).toBeUndefined();
   });
 
-  test("returns undefined when the platform cannot be asked", async () => {
+  test("returns undefined when the cloud cannot be asked", async () => {
     mockInboxState = { status: "unavailable", detail: "HTTP 503" };
 
     const handle = await resolveAdapterHandle(emailInviteAdapter);
@@ -71,7 +71,7 @@ describe("emailInviteAdapter", () => {
   });
 
   test("a local email.address config value cannot supply the handle", async () => {
-    // Registration lives on the platform; a stray config value (a key
+    // Registration lives on the cloud; a stray config value (a key
     // nothing writes) must not surface as the assistant's address.
     setConfig("email", { address: "stale@example.com" });
     mockInboxState = { status: "none" };

package/src/__tests__/{embedding-managed-proxy-selection.test.ts → embedding-cloud-proxy-selection.test.ts}

@@ -1,12 +1,13 @@
 /**
- * Tests for managed proxy Gemini embedding backend selection.
+ * Tests for cloud proxy Gemini embedding backend selection.
  *
  * Verifies that selectEmbeddingBackend correctly routes through the
- * managed proxy when managed proxy prerequisites are satisfied.
+ * cloud proxy when cloud proxy prerequisites are satisfied.
  */
 
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { setAllFlagsOnForTesting } from "../__tests__/feature-flag-test-helpers.js";
 import { credentialKey } from "../security/credential-key.js";
 import { useMemorySecureKeyMap } from "./helpers/secure-keys.js";
 
@@ -17,20 +18,17 @@ const secureKeys = useMemorySecureKeyMap();
 // Mocks — must be before importing the module under test
 // ---------------------------------------------------------------------------
 
-// Mutable state for managed proxy context
-let mockPlatformBaseUrl = "";
+// Mutable state for cloud proxy context
+let mockCloudBaseUrl = "";
 // Managed + provider keys live in the real backend's store now.
 const ASSISTANT_API_KEY = credentialKey("cadet", "assistant_api_key");
 
 mock.module("../config/env.js", () => ({
-  getPlatformBaseUrl: () => mockPlatformBaseUrl,
+  getCloudBaseUrl: () => mockCloudBaseUrl,
   getOllamaBaseUrlEnv: () => "",
 }));
 
 // Feature flag mock — always returns true (flag is GA'ed)
-mock.module("../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: () => true,
-}));
 
 import type { AssistantConfig } from "../config/types.js";
 import {
@@ -46,13 +44,13 @@ import { GeminiEmbeddingBackend } from "../persistence/embeddings/embedding-gemi
 const PLATFORM_BASE = "https://platform.example.com";
 const MANAGED_API_KEY = "ast-managed-key-123";
 
-function enableManagedProxy() {
-  mockPlatformBaseUrl = PLATFORM_BASE;
+function enableCloudProxy() {
+  mockCloudBaseUrl = PLATFORM_BASE;
   secureKeys.set(ASSISTANT_API_KEY, MANAGED_API_KEY);
 }
 
-function disableManagedProxy() {
-  mockPlatformBaseUrl = "";
+function disableCloudProxy() {
+  mockCloudBaseUrl = "";
   secureKeys.delete(ASSISTANT_API_KEY);
 }
 
@@ -88,8 +86,11 @@ function makeConfig(
 // ---------------------------------------------------------------------------
 
 beforeEach(() => {
-  disableManagedProxy();
-  secureKeys.clear(); // wipe provider keys; disableManagedProxy already cleared the assistant key
+  // Real flag resolution replaces the former blanket module mock.
+  setAllFlagsOnForTesting();
+
+  disableCloudProxy();
+  secureKeys.clear(); // wipe provider keys; disableCloudProxy already cleared the assistant key
   clearEmbeddingBackendCache();
 });
 
@@ -97,9 +98,9 @@ afterEach(() => {
   clearEmbeddingBackendCache();
 });
 
-describe("managed proxy Gemini embedding selection", () => {
-  test("selects managed proxy Gemini when proxy context available", async () => {
-    enableManagedProxy();
+describe("cloud proxy Gemini embedding selection", () => {
+  test("selects cloud proxy Gemini when proxy context available", async () => {
+    enableCloudProxy();
     const config = makeConfig();
 
     const { backend, reason } = await selectEmbeddingBackend(config);
@@ -110,8 +111,8 @@ describe("managed proxy Gemini embedding selection", () => {
     expect(reason).toBeNull();
   });
 
-  test("managed proxy backend uses default 3072 dimensions when geminiDimensions not set", async () => {
-    enableManagedProxy();
+  test("cloud proxy backend uses default 3072 dimensions when geminiDimensions not set", async () => {
+    enableCloudProxy();
     const config = makeConfig();
 
     const { backend } = await selectEmbeddingBackend(config);
@@ -123,8 +124,8 @@ describe("managed proxy Gemini embedding selection", () => {
     expect(dimensions).toBe(3072);
   });
 
-  test("managed proxy backend uses explicit geminiDimensions when set", async () => {
-    enableManagedProxy();
+  test("cloud proxy backend uses explicit geminiDimensions when set", async () => {
+    enableCloudProxy();
     const config = makeConfig({ geminiDimensions: 768 });
 
     const { backend } = await selectEmbeddingBackend(config);
@@ -135,20 +136,20 @@ describe("managed proxy Gemini embedding selection", () => {
     expect(dimensions).toBe(768);
   });
 
-  test("managed proxy backend uses managedBaseUrl (not direct Google API)", async () => {
-    enableManagedProxy();
+  test("cloud proxy backend uses cloudBaseUrl (not direct Google API)", async () => {
+    enableCloudProxy();
     const config = makeConfig();
 
     const { backend } = await selectEmbeddingBackend(config);
 
     expect(backend).toBeInstanceOf(GeminiEmbeddingBackend);
-    const managedBaseUrl = (backend as unknown as { managedBaseUrl: string })
-      .managedBaseUrl;
-    expect(managedBaseUrl).toBe(`${PLATFORM_BASE}/v1/runtime-proxy/gemini`);
+    const cloudBaseUrl = (backend as unknown as { cloudBaseUrl: string })
+      .cloudBaseUrl;
+    expect(cloudBaseUrl).toBe(`${PLATFORM_BASE}/v1/runtime-proxy/gemini`);
   });
 
-  test("falls back to local when managed proxy context unavailable", async () => {
-    disableManagedProxy();
+  test("falls back to local when cloud proxy context unavailable", async () => {
+    disableCloudProxy();
     const config = makeConfig();
 
     const { backend } = await selectEmbeddingBackend(config);
@@ -158,20 +159,20 @@ describe("managed proxy Gemini embedding selection", () => {
     expect(backend!.provider).toBe("local");
   });
 
-  test("selects managed proxy when provider is explicitly gemini", async () => {
-    enableManagedProxy();
+  test("selects cloud proxy when provider is explicitly gemini", async () => {
+    enableCloudProxy();
     const config = makeConfig({ provider: "gemini" });
 
     const { backend } = await selectEmbeddingBackend(config);
 
     expect(backend).toBeInstanceOf(GeminiEmbeddingBackend);
-    const managedBaseUrl = (backend as unknown as { managedBaseUrl: string })
-      .managedBaseUrl;
-    expect(managedBaseUrl).toContain("/v1/runtime-proxy/gemini");
+    const cloudBaseUrl = (backend as unknown as { cloudBaseUrl: string })
+      .cloudBaseUrl;
+    expect(cloudBaseUrl).toContain("/v1/runtime-proxy/gemini");
   });
 
-  test("does not use managed proxy when provider is explicitly local", async () => {
-    enableManagedProxy();
+  test("does not use cloud proxy when provider is explicitly local", async () => {
+    enableCloudProxy();
     const config = makeConfig({ provider: "local" });
 
     const { backend } = await selectEmbeddingBackend(config);
@@ -180,8 +181,8 @@ describe("managed proxy Gemini embedding selection", () => {
     expect(backend!.provider).toBe("local");
   });
 
-  test("does not use managed proxy when provider is explicitly openai", async () => {
-    enableManagedProxy();
+  test("does not use cloud proxy when provider is explicitly openai", async () => {
+    enableCloudProxy();
     secureKeys.set(credentialKey("openai", "api_key"), "user-openai-key");
     const config = makeConfig({ provider: "openai" });
 
@@ -191,8 +192,8 @@ describe("managed proxy Gemini embedding selection", () => {
     expect(backend!.provider).toBe("openai");
   });
 
-  test("direct Gemini key still works without managed proxy", async () => {
-    disableManagedProxy();
+  test("direct Gemini key still works without cloud proxy", async () => {
+    disableCloudProxy();
     secureKeys.set(credentialKey("gemini", "api_key"), "user-gemini-key");
     const config = makeConfig({ provider: "gemini" });
 
@@ -200,9 +201,9 @@ describe("managed proxy Gemini embedding selection", () => {
 
     expect(backend).toBeInstanceOf(GeminiEmbeddingBackend);
     expect(backend!.provider).toBe("gemini");
-    // Should NOT use managed proxy
-    const managedBaseUrl = (backend as unknown as { managedBaseUrl?: string })
-      .managedBaseUrl;
-    expect(managedBaseUrl).toBeUndefined();
+    // Should NOT use cloud proxy
+    const cloudBaseUrl = (backend as unknown as { cloudBaseUrl?: string })
+      .cloudBaseUrl;
+    expect(cloudBaseUrl).toBeUndefined();
   });
 });

package/src/__tests__/emit-signal-routing-intent.test.ts

@@ -28,7 +28,7 @@ const runDeterministicChecksMock = mock();
 const createEventMock = mock();
 const setEventDedupeKeyMock = mock();
 const dispatchDecisionMock = mock();
-const isPlatformClientConfiguredMock = mock();
+const isCloudClientConfiguredMock = mock();
 const writeHomeFeedItemForSignalMock = mock(
   async (..._args: unknown[]) => null,
 );
@@ -113,15 +113,15 @@ mock.module("../notifications/runtime-dispatch.js", () => ({
   dispatchDecision: (...args: unknown[]) => dispatchDecisionMock(...args),
 }));
 
-mock.module("../platform/client.js", () => ({
+mock.module("../cloud/client.js", () => ({
   // The adapter import graph needs the class symbol; nothing in these tests
   // dispatches through it.
-  CadetPlatformClient: class {
+  CadetCloudClient: class {
     static async create(): Promise<null> {
       return null;
     }
   },
-  isPlatformClientConfigured: () => isPlatformClientConfiguredMock(),
+  isCloudClientConfigured: () => isCloudClientConfiguredMock(),
 }));
 
 import {
@@ -141,7 +141,7 @@ beforeEach(() => {
   createEventMock.mockReset();
   setEventDedupeKeyMock.mockReset();
   dispatchDecisionMock.mockReset();
-  isPlatformClientConfiguredMock.mockReset();
+  isCloudClientConfiguredMock.mockReset();
 
   createEventMock.mockReturnValue({ id: "evt-1" });
   runDeterministicChecksMock.mockResolvedValue({ passed: true });
@@ -150,7 +150,7 @@ beforeEach(() => {
     reason: "ok",
     deliveryResults: [],
   });
-  isPlatformClientConfiguredMock.mockResolvedValue(true);
+  isCloudClientConfiguredMock.mockResolvedValue(true);
   enforceRoutingIntentMock.mockImplementation((decision: unknown) => decision);
 });
 
@@ -827,8 +827,8 @@ describe("high/critical urgency channel force", () => {
     expect(dispatched.selectedChannels).toEqual(["telegram"]);
   });
 
-  test("forces only cadet when the platform client is not configured", async () => {
-    isPlatformClientConfiguredMock.mockResolvedValue(false);
+  test("forces only cadet when the cloud client is not configured", async () => {
+    isCloudClientConfiguredMock.mockResolvedValue(false);
     evaluateSignalMock.mockResolvedValue(makeDecision({}));
 
     await emitWithUrgency("high");
@@ -1106,9 +1106,7 @@ describe("emitNotificationSignal From me push defaults", () => {
     "cadet_allowlist",
   ])("respects %s policy without adding platform", async (scenario) => {
     assistantInitiatedCandidate = scenario !== "noncandidate";
-    isPlatformClientConfiguredMock.mockResolvedValue(
-      scenario !== "unconfigured",
-    );
+    isCloudClientConfiguredMock.mockResolvedValue(scenario !== "unconfigured");
     evaluateSignalMock.mockResolvedValue({
       ...decision(scenario === "external_only" ? ["telegram"] : ["cadet"]),
       shouldNotify: scenario !== "suppressed",
@@ -1139,23 +1137,23 @@ describe("emitNotificationSignal From me push defaults", () => {
       contextPayload: { quiet: true },
     });
     expect(result.selectedChannels).toEqual(["cadet", "platform", "telegram"]);
-    expect(isPlatformClientConfiguredMock).not.toHaveBeenCalled();
+    expect(isCloudClientConfiguredMock).not.toHaveBeenCalled();
     expect(dispatchDecisionMock.mock.calls[0]?.[3]).toMatchObject({
       assistantInitiatedThread: { platformAdded: false },
     });
   });
 
   test("probes an unbound platform once across urgency and From me policy", async () => {
-    isPlatformClientConfiguredMock.mockResolvedValue(false);
+    isCloudClientConfiguredMock.mockResolvedValue(false);
     const result = await emitNotificationSignal({
       ...params,
       attentionHints: { ...params.attentionHints, urgency: "high" },
     });
     expect(result.selectedChannels).toEqual(["cadet"]);
-    expect(isPlatformClientConfiguredMock).toHaveBeenCalledTimes(1);
+    expect(isCloudClientConfiguredMock).toHaveBeenCalledTimes(1);
   });
 
-  test("preserves preferred external selections while adding the platform default", async () => {
+  test("preserves preferred external selections while adding the cloud default", async () => {
     evaluateSignalMock.mockResolvedValue(decision(["cadet", "telegram"]));
     const result = await emitNotificationSignal(params);
     expect(result.selectedChannels).toEqual(["cadet", "telegram", "platform"]);

package/src/__tests__/events-dev-bypass-actor.test.ts

@@ -2,7 +2,7 @@
  * Regression tests for the SSE registration dev-bypass actor principal
  * translation.
  *
- * In `DISABLE_HTTP_AUTH=true` (platform-managed) deployments the synthetic
+ * In `DISABLE_HTTP_AUTH=true` (cloud-managed) deployments the synthetic
  * dev-bypass `AuthContext` injects `actorPrincipalId="dev-bypass"` for every
  * request. Trust resolution still resolves to the real local guardian's
  * principalId via `resolveLocalPrincipalTrustContext`. Without translation,
@@ -14,7 +14,7 @@
  *
  * The events-routes handler translates `"dev-bypass"` to the real guardian's
  * principalId at registration time so both sides agree. This keeps targeted
- * host proxy execution working on Docker / platform-managed deployments.
+ * host proxy execution working on Docker / cloud-managed deployments.
  */
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 

package/src/__tests__/fallback-breaker.test.ts

@@ -609,7 +609,7 @@ describe("RetryProvider under an open breaker", () => {
     expect(shouldSkipPrimary(PRIMARY_ROUTE)).toBe(true);
   });
 
-  test("a probe refreshes an expired managed credential before judging the route down", async () => {
+  test("a probe refreshes an expired cloud credential before judging the route down", async () => {
     // The credential expired during the outage. Without the refresh the probe
     // reads its own 401 as the outage continuing, re-trips, and the route can
     // never come back.
@@ -624,7 +624,7 @@ describe("RetryProvider under an open breaker", () => {
     const route = makeRoute(backup.provider);
     let refreshCalls = 0;
     const wrapped = new RetryProvider(primary.provider, {
-      credentialSource: "cadet-managed",
+      credentialSource: "cadet-cloud",
       refreshCredentialProvider: async () => {
         refreshCalls += 1;
         return refreshed.provider;
@@ -868,7 +868,7 @@ describe("RetryProvider under an open breaker", () => {
   });
 
   test("an upstream outage diverts every model on it", async () => {
-    // A managed credential rejection indicts the upstream, not one model, so
+    // A cloud credential rejection indicts the upstream, not one model, so
     // the healthy model is skipped too.
     const primary = primaryProvider(
       () =>
@@ -879,7 +879,7 @@ describe("RetryProvider under an open breaker", () => {
     const backup = backupProvider();
     const route = makeRoute(backup.provider);
     const wrapped = new RetryProvider(primary.provider, {
-      credentialSource: "cadet-managed",
+      credentialSource: "cadet-cloud",
       refreshCredentialProvider: async () => null,
       resolveFallbackRoute: route.resolveFallbackRoute,
     });
@@ -1204,7 +1204,7 @@ describe("recovery probe verdicts", () => {
 describe("retry exhaustion accounting", () => {
   /**
    * The primary of a probe that uses both of its repairs before failing for
-   * real. The first send is rejected as an expired managed credential, the
+   * real. The first send is rejected as an expired cloud credential, the
    * refreshed adapter answers the resend with malformed tool arguments, and the
    * corrective resend after that comes back as a stream corruption. Three sends
    * are spent by the time the request reaches the ordinary loop, leaving it
@@ -1245,7 +1245,7 @@ describe("retry exhaustion accounting", () => {
     const backup = backupProvider();
     const route = makeRoute(backup.provider);
     const wrapped = new RetryProvider(primary.provider, {
-      credentialSource: "cadet-managed",
+      credentialSource: "cadet-cloud",
       refreshCredentialProvider: async () => refreshed.provider,
       resolveFallbackRoute: route.resolveFallbackRoute,
     });
@@ -1271,7 +1271,7 @@ describe("retry exhaustion accounting", () => {
       corruptedStream(),
     );
     const wrapped = new RetryProvider(primary.provider, {
-      credentialSource: "cadet-managed",
+      credentialSource: "cadet-cloud",
       refreshCredentialProvider: async () => refreshed.provider,
       resolveFallbackRoute: async () => null,
     });

package/src/__tests__/feature-flag-test-helpers.ts

@@ -41,3 +41,109 @@ export function setOverridesForTesting(
   s.overrides = { ...overrides };
   s.fromGateway = true;
 }
+
+/**
+ * Registry keys whose `defaultEnabled` is `true`. Tests that previously mocked
+ * `isAssistantFeatureFlagEnabled` to a blanket `() => false` must override
+ * these explicitly — the real module resolves them to `true` otherwise.
+ */
+export const DEFAULT_ENABLED_FLAG_KEYS: readonly string[] = [
+  "in-chat-onboarding-tour",
+  "vision-mode",
+  "assistant-initiated-threads",
+  "experiment-activation-flow-2026-06-03",
+  "channel-trust-floors",
+  "schedule-result-notify",
+  "assistant-reply-push",
+  "web-presence-suppression",
+  "plugin-schedules",
+  "experiment-activation-checklist-2026-09-10",
+];
+
+/**
+ * Equivalent of a blanket `isAssistantFeatureFlagEnabled: () => false` mock:
+ * every default-enabled key is overridden to `false`, so all flags resolve
+ * off through the real resolution path.
+ */
+export function setAllFlagsOffForTesting(): void {
+  setOverridesForTesting(
+    Object.fromEntries(DEFAULT_ENABLED_FLAG_KEYS.map((k) => [k, false])),
+  );
+}
+
+/** Every key declared in the feature-flag registry. */
+export const ALL_REGISTRY_FLAG_KEYS: readonly string[] = [
+  "interrupt-on-send",
+  "in-chat-onboarding-tour",
+  "vision-mode",
+  "assistant-initiated-threads",
+  "experiment-activation-flow-2026-06-03",
+  "a2a-channel",
+  "settings-developer-nav",
+  "cadet-hosted-inference",
+  "developer-menu-items",
+  "multi-platform-assistant",
+  "quick-input",
+  "teach",
+  "quiet-turn-activity",
+  "inline-assistant-intermediates",
+  "fast-mode",
+  "apple-container",
+  "fork-from-message",
+  "internal-thread-actions",
+  "camera-gate-debug-hud",
+  "compaction-playground",
+  "app-control",
+  "velvet-theme",
+  "chat-pull-to-refresh-enabled",
+  "preview-channel",
+  "rollback-enabled",
+  "self-hosted-assistant",
+  "paired-devices-ui",
+  "settings-sleep-policy",
+  "velvet",
+  "memory-router-playground",
+  "self-intro-greeting",
+  "channel-trust-floors",
+  "mcp-add-server",
+  "mcp-catalog-qa-integrations",
+  "os-beta",
+  "auto-profile",
+  "new-thread-suggestions",
+  "account-mfa",
+  "chat-credential-reveal",
+  "marketing-pricing-takeover",
+  "schedule-result-notify",
+  "assistant-reply-push",
+  "activity-presence-suppression",
+  "web-presence-suppression",
+  "plugin-schedules",
+  "android-avatar-app-icon",
+  "push-avatar-sender",
+  "local-notification-avatar",
+  "channel-conversation-sidecar",
+  "monday-oauth",
+  "figma-oauth",
+  "quickbooks-oauth",
+  "shopify-oauth",
+  "chatgpt-device-code-login",
+  "model-first-profile-create",
+  "tunnel-webhooks",
+  "experiment-activation-checklist-2026-09-10",
+  "send-user-message",
+  "session-groups",
+  "assistant-desktop",
+  "sidebar-done",
+  "cadet-trusted-contacts",
+];
+
+/**
+ * Equivalent of a blanket `isAssistantFeatureFlagEnabled: () => true` mock for
+ * every declared registry key (undeclared keys still fail closed, matching the
+ * real resolution).
+ */
+export function setAllFlagsOnForTesting(): void {
+  setOverridesForTesting(
+    Object.fromEntries(ALL_REGISTRY_FLAG_KEYS.map((k) => [k, true])),
+  );
+}

package/src/__tests__/gateway-flag-listener.test.ts

@@ -54,7 +54,7 @@ mock.module("../runtime/sync/sync-publisher.js", () => ({
 // ---------------------------------------------------------------------------
 // Track reconcileFlagGatedProfiles calls and let each test control whether it
 // reports a config change, so we can assert the listener broadcasts only when
-// the managed profile set actually changes.
+// the cloud profile set actually changes.
 // ---------------------------------------------------------------------------
 let reconcileCallCount = 0;
 let reconcileReturns = false;

package/src/__tests__/gemini-image-service.test.ts

@@ -295,9 +295,9 @@ describe("mapGeminiError", () => {
     expect(msg).not.toContain("Please try again");
   });
 
-  test("maps a managed-proxy 402 failure (plain Error) to out-of-credits message", () => {
+  test("maps a cloud-proxy 402 failure (plain Error) to out-of-credits message", () => {
     const msg = mapGeminiError(
-      new Error("Managed proxy request failed (402): insufficient credits"),
+      new Error("Cloud proxy request failed (402): insufficient credits"),
     );
     expect(msg).toContain("out of credits");
   });