@mycadet/assistant 0.12.7 → 0.12.8

package/src/__tests__/gemini-provider.test.ts

@@ -1978,14 +1978,14 @@ describe("GeminiProvider", () => {
   // -----------------------------------------------------------------------
   // Managed transport — constructor configuration
   // -----------------------------------------------------------------------
-  test("does not set httpOptions when managedBaseUrl is not provided", () => {
+  test("does not set httpOptions when cloudBaseUrl is not provided", () => {
     new GeminiProvider("test-key", "gemini-3-flash-preview");
     expect(lastConstructorOpts).toEqual({ apiKey: "test-key" });
   });
 
-  test("sets httpOptions.baseUrl when managedBaseUrl is provided", () => {
+  test("sets httpOptions.baseUrl when cloudBaseUrl is provided", () => {
     new GeminiProvider("managed-key", "gemini-3-flash-preview", {
-      managedBaseUrl: "https://platform.example.com/v1/runtime-proxy/gemini",
+      cloudBaseUrl: "https://platform.example.com/v1/runtime-proxy/gemini",
     });
     expect(lastConstructorOpts).toEqual({
       apiKey: "managed-key",
@@ -2000,7 +2000,7 @@ describe("GeminiProvider", () => {
       "managed-key",
       "gemini-3-flash-preview",
       {
-        managedBaseUrl: "https://platform.example.com/v1/runtime-proxy/gemini",
+        cloudBaseUrl: "https://platform.example.com/v1/runtime-proxy/gemini",
       },
     );
 
@@ -2025,7 +2025,7 @@ describe("GeminiProvider", () => {
       "managed-key",
       "gemini-3-flash-preview",
       {
-        managedBaseUrl: "https://platform.example.com/v1/runtime-proxy/gemini",
+        cloudBaseUrl: "https://platform.example.com/v1/runtime-proxy/gemini",
       },
     );
 

package/src/__tests__/get-skill-detail-audit.test.ts

@@ -1,5 +1,7 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { setAllFlagsOnForTesting } from "../__tests__/feature-flag-test-helpers.js";
+
 // ---------------------------------------------------------------------------
 // Mock state
 // ---------------------------------------------------------------------------
@@ -66,10 +68,6 @@ mock.module("../config/skill-state.js", () => ({
   skillFlagKey: () => null,
 }));
 
-mock.module("../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: () => true,
-}));
-
 mock.module("../skills/install-meta.js", () => ({
   readInstallMeta: mockReadInstallMeta,
 }));
@@ -154,10 +152,10 @@ mock.module("../skills/catalog-install.js", () => ({
   installSkillLocally: async () => {},
 }));
 
-mock.module("../skills/managed-store.js", () => ({
-  createManagedSkill: () => ({ created: true }),
-  deleteManagedSkill: () => ({ deleted: true }),
-  validateManagedSkillId: () => null,
+mock.module("../skills/cloud-store.js", () => ({
+  createCloudSkill: () => ({ created: true }),
+  deleteCloudSkill: () => ({ deleted: true }),
+  validateCloudSkillId: () => null,
 }));
 
 mock.module("../plugins/defaults/memory/graph/capability-seed.js", () => ({
@@ -190,6 +188,9 @@ import { getSkill } from "../daemon/handlers/skills.js";
 
 describe("getSkill — skillssh audit enrichment", () => {
   beforeEach(() => {
+    // Real flag resolution replaces the former blanket module mock.
+    setAllFlagsOnForTesting();
+
     mockResolveSkillStates.mockReset();
     mockReadInstallMeta.mockReset();
     mockFetchSkillAudits.mockReset();

package/src/__tests__/guardian-verification-voice-binding.test.ts

@@ -41,7 +41,7 @@ mock.module("../calls/voice-ingress-preflight.js", () => ({
   }),
 }));
 
-mock.module("../inbound/platform-callback-registration.js", () => ({
+mock.module("../inbound/cloud-callback-registration.js", () => ({
   resolveCallbackUrl: async (fn: () => string) => fn(),
 }));
 

package/src/__tests__/handlers-skills-memory-v2-reseed.test.ts

@@ -120,10 +120,10 @@ mock.module("../skills/catalog-search.js", () => ({
   filterByQuery: () => [],
 }));
 
-mock.module("../skills/managed-store.js", () => ({
-  createManagedSkill: () => ({ created: true }),
-  deleteManagedSkill: () => ({ deleted: true }),
-  validateManagedSkillId: () => null,
+mock.module("../skills/cloud-store.js", () => ({
+  createCloudSkill: () => ({ created: true }),
+  deleteCloudSkill: () => ({ deleted: true }),
+  validateCloudSkillId: () => null,
 }));
 
 mock.module("../plugins/defaults/memory/graph/capability-seed.js", () => ({
@@ -203,7 +203,7 @@ describe("v2 skill refresh delegation in skill handlers", () => {
   });
 
   test("uninstall delegates to refresh helper", async () => {
-    const result = await uninstallSkill("managed-skill");
+    const result = await uninstallSkill("cloud-skill");
 
     expect(result.success).toBe(true);
     expect(mockRefreshSkillCapabilityMemories).toHaveBeenCalledTimes(1);

package/src/__tests__/host-cu-routes-targeted.test.ts

@@ -25,7 +25,7 @@ import sharp from "sharp";
 mock.module("../config/env.js", () => ({
   isHttpAuthDisabled: () => true,
   hasUngatedHttpAuthDisabled: () => false,
-  getPlatformBaseUrl: () => "https://platform.example.com",
+  getCloudBaseUrl: () => "https://platform.example.com",
   getGatewayInternalBaseUrl: () => "http://localhost:8080",
   getIngressPublicBaseUrl: () => undefined,
   setIngressPublicBaseUrl: () => {},
@@ -35,14 +35,14 @@ mock.module("../config/env.js", () => ({
   getQdrantHttpPortEnv: () => undefined,
   getQdrantReadyzTimeoutMs: () => undefined,
   getOllamaBaseUrlEnv: () => undefined,
-  setPlatformBaseUrl: () => {},
+  setCloudBaseUrl: () => {},
   getAssistantDomain: () => "example.com",
-  setPlatformAssistantId: () => {},
-  getPlatformAssistantId: () => "test-assistant-id",
-  setPlatformOrganizationId: () => {},
-  getPlatformOrganizationId: () => "test-org-id",
-  setPlatformUserId: () => {},
-  getPlatformUserId: () => "test-user-id",
+  setCloudAssistantId: () => {},
+  getCloudAssistantId: () => "test-assistant-id",
+  setCloudOrganizationId: () => {},
+  getCloudOrganizationId: () => "test-org-id",
+  setCloudUserId: () => {},
+  getCloudUserId: () => "test-user-id",
   validateEnv: () => {},
 }));
 

package/src/__tests__/image-credentials.test.ts

@@ -11,13 +11,13 @@ const secureKeys = useMemorySecureKeyMap();
 // Module mocks — must appear before importing the module under test
 // ---------------------------------------------------------------------------
 
-let mockPlatformBaseUrl = "";
+let mockCloudBaseUrl = "";
 let mockAssistantApiKey = "";
 
-mock.module("../providers/platform-proxy/context.js", () => ({
-  resolveManagedProxyContext: async () => ({
-    enabled: !!mockPlatformBaseUrl && !!mockAssistantApiKey,
-    platformBaseUrl: mockPlatformBaseUrl,
+mock.module("../providers/cloud-proxy/context.js", () => ({
+  resolveCloudProxyContext: async () => ({
+    enabled: !!mockCloudBaseUrl && !!mockAssistantApiKey,
+    cloudBaseUrl: mockCloudBaseUrl,
     assistantApiKey: mockAssistantApiKey,
   }),
 }));
@@ -31,13 +31,13 @@ import {
 describe("resolveImageGenCredentials", () => {
   beforeEach(() => {
     secureKeys.clear(); // no provider keys configured
-    mockPlatformBaseUrl = "";
+    mockCloudBaseUrl = "";
     mockAssistantApiKey = "";
   });
 
   describe("managed mode", () => {
-    test("returns managed-proxy credentials when context is enabled", async () => {
-      mockPlatformBaseUrl = "https://platform.example.com";
+    test("returns cloud-proxy credentials when context is enabled", async () => {
+      mockCloudBaseUrl = "https://platform.example.com";
       mockAssistantApiKey = "sk-assistant-key";
 
       const result = await resolveImageGenCredentials({
@@ -47,14 +47,14 @@ describe("resolveImageGenCredentials", () => {
 
       expect(result.errorHint).toBeUndefined();
       expect(result.credentials).toEqual({
-        type: "managed-proxy",
+        type: "cloud-proxy",
         assistantApiKey: "sk-assistant-key",
         baseUrl: "https://platform.example.com/v1/runtime-proxy/gemini",
       });
     });
 
     test("returns errorHint mentioning 'log in to Cadet' when platform URL is missing", async () => {
-      mockPlatformBaseUrl = "";
+      mockCloudBaseUrl = "";
       mockAssistantApiKey = "sk-assistant-key";
 
       const result = await resolveImageGenCredentials({
@@ -68,7 +68,7 @@ describe("resolveImageGenCredentials", () => {
     });
 
     test("returns errorHint when assistant API key is empty (TOCTOU-safe)", async () => {
-      mockPlatformBaseUrl = "https://platform.example.com";
+      mockCloudBaseUrl = "https://platform.example.com";
       mockAssistantApiKey = "";
 
       const result = await resolveImageGenCredentials({
@@ -240,7 +240,7 @@ describe("resolveImageGenRouting", () => {
       credentialKey("gemini", "api_key"),
       "gemini-key-should-not-be-used",
     );
-    mockPlatformBaseUrl = "";
+    mockCloudBaseUrl = "";
 
     const routing = resolveImageGenRouting({
       provider: "cadet",
@@ -252,6 +252,6 @@ describe("resolveImageGenRouting", () => {
     });
 
     expect(result.credentials).toBeUndefined();
-    expect(result.errorHint).toContain("Managed proxy is not available");
+    expect(result.errorHint).toContain("Cloud proxy is not available");
   });
 });

package/src/__tests__/inbound-admitted-introduction-nudge.test.ts

@@ -5,13 +5,19 @@
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-process.env.DISABLE_HTTP_AUTH = "true";
+import {
+  DEFAULT_ENABLED_FLAG_KEYS,
+  setOverridesForTesting,
+} from "../__tests__/feature-flag-test-helpers.js";
 
-// Enable the channel-trust-floors flag so the admission-policy stage runs.
-mock.module("../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: (key: string) =>
-    key === "channel-trust-floors",
-}));
+// Real flag cache seeded to mirror the former module mock: every flag off
+// except channel-trust-floors, which gates the admission-policy stage.
+const FLAGS = {
+  ...Object.fromEntries(DEFAULT_ENABLED_FLAG_KEYS.map((k) => [k, false])),
+  "channel-trust-floors": true,
+} as Record<string, boolean>;
+
+process.env.DISABLE_HTTP_AUTH = "true";
 
 mock.module("../runtime/gateway-client.js", () => ({
   deliverChannelReply: async () => {},
@@ -179,6 +185,8 @@ function accessRequests() {
 
 describe("introduction nudge on first admit", () => {
   beforeEach(() => {
+    setOverridesForTesting(FLAGS);
+
     resetState();
     installNoopProcessor();
   });

package/src/__tests__/inbound-trust-verdict.test.ts

@@ -6,13 +6,19 @@
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-process.env.DISABLE_HTTP_AUTH = "true";
+import {
+  DEFAULT_ENABLED_FLAG_KEYS,
+  setOverridesForTesting,
+} from "../__tests__/feature-flag-test-helpers.js";
 
-// Enable the channel-trust-floors flag so the admission-policy stage runs.
-mock.module("../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: (key: string) =>
-    key === "channel-trust-floors",
-}));
+// Real flag cache seeded to mirror the former module mock: every flag off
+// except channel-trust-floors, which gates the admission-policy stage.
+const FLAGS = {
+  ...Object.fromEntries(DEFAULT_ENABLED_FLAG_KEYS.map((k) => [k, false])),
+  "channel-trust-floors": true,
+} as Record<string, boolean>;
+
+process.env.DISABLE_HTTP_AUTH = "true";
 
 mock.module("../runtime/gateway-client.js", () => ({
   deliverChannelReply: async () => {},
@@ -117,6 +123,8 @@ function memberVerdict(
 
 describe("inbound trust verdict → TrustContext", () => {
   beforeEach(() => {
+    setOverridesForTesting(FLAGS);
+
     resetTables();
     setAdapterProcessMessage(undefined);
   });

package/src/__tests__/inference-no-mode-boot-e2e.test.ts

@@ -33,8 +33,8 @@ const preMockModules: ReadonlyArray<[string, Record<string, unknown>]> = [
     { ...(await import("../security/secure-keys.js")) },
   ],
   [
-    "../providers/platform-proxy/context.js",
-    { ...(await import("../providers/platform-proxy/context.js")) },
+    "../providers/cloud-proxy/context.js",
+    { ...(await import("../providers/cloud-proxy/context.js")) },
   ],
   [
     "../providers/inference/connections.js",
@@ -60,15 +60,15 @@ afterAll(() => {
 // Vault mock — keyed by credential name.
 const mockVault = useMemorySecureKeys();
 
-// Managed proxy context — always unavailable in this test (no platform auth).
-mock.module("../providers/platform-proxy/context.js", () => ({
-  buildManagedBaseUrl: async () => null,
-  resolveManagedProxyContext: async () => {
-    throw new Error("managed proxy not available in test");
+// Cloud proxy context — always unavailable in this test (no platform auth).
+mock.module("../providers/cloud-proxy/context.js", () => ({
+  buildCloudBaseUrl: async () => null,
+  resolveCloudProxyContext: async () => {
+    throw new Error("cloud proxy not available in test");
   },
 }));
 
-// DB mock — getConnection returns null (no managed connections seeded yet).
+// DB mock — getConnection returns null (no cloud connections seeded yet).
 const mockGetConnection: Record<string, unknown> = {};
 mock.module("../providers/inference/connections.js", () => ({
   getConnection: (_db: unknown, name: string) =>
@@ -258,20 +258,20 @@ describe("inference-no-mode-boot-e2e: config without services.inference.mode", (
     expect(typeof provider.sendMessage).toBe("function");
   });
 
-  // ── Gate 4: platform-auth connection fails with ConnectionResolutionError ─
+  // ── Gate 4: cloud-auth connection fails with ConnectionResolutionError ─
 
   test("ConnectionResolutionError is exported with expected reason codes", () => {
     const err = new ConnectionResolutionError(
       "anthropic-managed",
       "not_found",
-      'provider_connection "anthropic-managed" not found — managed connections not yet seeded (PR-D)',
+      'provider_connection "anthropic-managed" not found — cloud connections not yet seeded (PR-D)',
     );
     expect(err).toBeInstanceOf(ConnectionResolutionError);
     expect(err.reason).toBe("not_found");
     expect(err.connectionName).toBe("anthropic-managed");
   });
 
-  test("tryResolveProviderForConnectionName throws not_found for an unseed managed connection", async () => {
+  test("tryResolveProviderForConnectionName throws not_found for an unseed cloud connection", async () => {
     // anthropic-managed is not in mockGetConnection (simulates PR-D not yet run).
     const { tryResolveProviderForConnectionName } =
       await import("../providers/connection-resolution.js");

package/src/__tests__/inference-profile-session-handler.test.ts

@@ -25,15 +25,15 @@ mock.module("../runtime/assistant-event.js", () => ({
 }));
 
 // The default profiles used below (`balanced`, `cost-optimized`) route through
-// the Cadet-managed connection, and the handler's availability guard judges
+// the Cadet Cloud connection, and the handler's availability guard judges
 // that route for real. Stand in for a signed-in platform session so the pin
 // path under test is the healthy one; `managedProxyEnabled` is flipped by the
 // guard test.
 let managedProxyEnabled = true;
-mock.module("../providers/platform-proxy/context.js", () => ({
-  resolveManagedProxyContext: async () => ({
+mock.module("../providers/cloud-proxy/context.js", () => ({
+  resolveCloudProxyContext: async () => ({
     enabled: managedProxyEnabled,
-    platformBaseUrl: "https://platform.example",
+    cloudBaseUrl: "https://platform.example",
     assistantApiKey: managedProxyEnabled ? "key" : "",
   }),
 }));
@@ -66,7 +66,7 @@ import { setConfig } from "./helpers/set-config.js";
 
 await initializeDb();
 
-// The Cadet-managed connection row the default profiles resolve to.
+// The Cadet Cloud connection row the default profiles resolve to.
 getDb()
   .insert(providerConnections)
   .values({
@@ -426,9 +426,9 @@ describe("setInferenceProfileSession", () => {
     }
   });
 
-  test("BYOK default provider — pins a managed preset without a Cadet sign-in", async () => {
+  test("BYOK default provider — pins a cloud preset without a Cadet sign-in", async () => {
     const conv = createConversation("sess-handler-byok-preset");
-    // Signed out of Cadet, but llm.default points the managed
+    // Signed out of Cadet, but llm.default points the cloud
     // presets at the user's own anthropic connection — the pin must judge
     // that body, not the Cadet column.
     managedProxyEnabled = false;

package/src/__tests__/inference-profile-session-ipc.test.ts

@@ -13,13 +13,13 @@ mock.module("../runtime/assistant-event.js", () => ({
   buildAssistantEvent: (event: unknown) => event,
 }));
 
-// "balanced"/"cost-optimized" route through the Cadet-managed connection, and
+// "balanced"/"cost-optimized" route through the Cadet Cloud connection, and
 // the open handler's availability guard judges that route for real. Stand in
 // for a signed-in platform session so these tests exercise the healthy path.
-mock.module("../providers/platform-proxy/context.js", () => ({
-  resolveManagedProxyContext: async () => ({
+mock.module("../providers/cloud-proxy/context.js", () => ({
+  resolveCloudProxyContext: async () => ({
     enabled: true,
-    platformBaseUrl: "https://platform.example",
+    cloudBaseUrl: "https://platform.example",
     assistantApiKey: "key",
   }),
 }));
@@ -38,7 +38,7 @@ import { resetDbForTesting } from "./db-test-helpers.js";
 
 await initializeDb();
 
-// The Cadet-managed connection row the default profiles resolve to.
+// The Cadet Cloud connection row the default profiles resolve to.
 getDb()
   .insert(providerConnections)
   .values({

package/src/__tests__/inference-profile-validation-jev.test.ts

@@ -3,7 +3,7 @@ import { beforeEach, describe, expect, test } from "bun:test";
 import { validateInferenceProfileKey } from "../config/inference-profile-validation.js";
 import { setConfig } from "./helpers/set-config.js";
 
-describe("validateInferenceProfileKey and the managed Jev profile", () => {
+describe("validateInferenceProfileKey and the cloud Jev profile", () => {
   beforeEach(() => {
     setConfig("llm", { profiles: {} });
   });

package/src/__tests__/init-feature-flag-overrides.test.ts

@@ -2,8 +2,8 @@
  * Tests for initFeatureFlagOverrides() — the async IPC call that
  * pre-populates the feature flag cache before CLI program construction.
  *
- * Uses the shared mock-gateway-ipc utility (installed in test-preload.ts)
- * which mocks node:net so no test connects to a real gateway socket.
+ * Uses the requests-mock gateway channel (transport installed in
+ * test-preload.ts) so no test connects to a real gateway socket.
  */
 import { afterEach, beforeEach, describe, expect, it } from "bun:test";
 
@@ -13,21 +13,23 @@ import {
   isAssistantFeatureFlagEnabled,
   refreshOverridesFromGateway,
 } from "../config/assistant-feature-flags.js";
-import { mockGatewayIpc, resetMockGatewayIpc } from "./mock-gateway-ipc.js";
+import { mockIpc, resetRequestMockChannels } from "./requests-mock.js";
 
 beforeEach(() => {
   clearFeatureFlagOverridesCache();
-  resetMockGatewayIpc();
 });
 
 afterEach(() => {
   clearFeatureFlagOverridesCache();
-  resetMockGatewayIpc();
 });
 
 describe("initFeatureFlagOverrides", () => {
   it("populates cache from gateway IPC response", async () => {
-    mockGatewayIpc({ "foo-enabled": true, "bar-enabled": true });
+    const gateway = await mockIpc("gateway");
+    gateway.on("get_feature_flags", {
+      "foo-enabled": true,
+      "bar-enabled": true,
+    });
 
     await initFeatureFlagOverrides();
 
@@ -37,7 +39,8 @@ describe("initFeatureFlagOverrides", () => {
   });
 
   it("falls back gracefully when gateway socket is unavailable", async () => {
-    mockGatewayIpc(null, { error: true });
+    const gateway = await mockIpc("gateway");
+    gateway.failConnect();
 
     // Disable retries — production retries the IPC fetch on failure to
     // dodge the daemon-vs-gateway startup race, but here we're explicitly
@@ -51,7 +54,11 @@ describe("initFeatureFlagOverrides", () => {
   });
 
   it("respects false values from gateway IPC", async () => {
-    mockGatewayIpc({ "gated-feature": true, "disabled-feature": false });
+    const gateway = await mockIpc("gateway");
+    gateway.on("get_feature_flags", {
+      "gated-feature": true,
+      "disabled-feature": false,
+    });
 
     await initFeatureFlagOverrides();
 
@@ -63,7 +70,8 @@ describe("initFeatureFlagOverrides", () => {
   });
 
   it("does not cache empty gateway response", async () => {
-    mockGatewayIpc({});
+    const gateway = await mockIpc("gateway");
+    gateway.on("get_feature_flags", {});
 
     // Disable retries — this test explicitly simulates a sustained empty
     // response (gateway up but reporting zero flags) and should not wait
@@ -80,10 +88,11 @@ describe("initFeatureFlagOverrides", () => {
     // returns empty (gateway not yet ready), but a later attempt sees
     // the populated flag map. The retry loop in init should bridge this
     // gap without losing the flag.
-    mockGatewayIpc({});
+    const gateway = await mockIpc("gateway");
+    gateway.on("get_feature_flags", {});
     setTimeout(() => {
-      resetMockGatewayIpc();
-      mockGatewayIpc({ "retry-test-flag": true });
+      resetRequestMockChannels();
+      gateway.on("get_feature_flags", { "retry-test-flag": true });
     }, 50);
 
     await initFeatureFlagOverrides({ retryBackoffsMs: [200] });
@@ -93,14 +102,18 @@ describe("initFeatureFlagOverrides", () => {
   });
 
   it("does not re-fetch when cache is already populated", async () => {
-    mockGatewayIpc({ "first-call": true });
+    const gateway = await mockIpc("gateway");
+    gateway.on("get_feature_flags", { "first-call": true });
 
     await initFeatureFlagOverrides();
 
     // Change what IPC would return — if the guard is broken and init
     // re-fetches, "first-call" would flip to false.
-    resetMockGatewayIpc();
-    mockGatewayIpc({ "first-call": false, "second-call": true });
+    resetRequestMockChannels();
+    gateway.on("get_feature_flags", {
+      "first-call": false,
+      "second-call": true,
+    });
 
     await initFeatureFlagOverrides();
 
@@ -114,11 +127,12 @@ describe("initFeatureFlagOverrides", () => {
 
 describe("refreshOverridesFromGateway", () => {
   it("replaces the cache with the new gateway values", async () => {
-    mockGatewayIpc({ "moving-flag": true });
+    const gateway = await mockIpc("gateway");
+    gateway.on("get_feature_flags", { "moving-flag": true });
     await initFeatureFlagOverrides();
 
-    resetMockGatewayIpc();
-    mockGatewayIpc({ "moving-flag": false });
+    resetRequestMockChannels();
+    gateway.on("get_feature_flags", { "moving-flag": false });
 
     expect(await refreshOverridesFromGateway()).toBe(true);
 
@@ -127,11 +141,12 @@ describe("refreshOverridesFromGateway", () => {
   });
 
   it("keeps the last known values when the refresh fails", async () => {
-    mockGatewayIpc({ "moving-flag": true });
+    const gateway = await mockIpc("gateway");
+    gateway.on("get_feature_flags", { "moving-flag": true });
     await initFeatureFlagOverrides();
 
-    resetMockGatewayIpc();
-    mockGatewayIpc(null, { error: true });
+    resetRequestMockChannels();
+    gateway.failConnect();
 
     expect(await refreshOverridesFromGateway()).toBe(false);
 
@@ -143,11 +158,12 @@ describe("refreshOverridesFromGateway", () => {
   });
 
   it("keeps the cache readable for the whole call", async () => {
-    mockGatewayIpc({ "moving-flag": true });
+    const gateway = await mockIpc("gateway");
+    gateway.on("get_feature_flags", { "moving-flag": true });
     await initFeatureFlagOverrides();
 
-    resetMockGatewayIpc();
-    mockGatewayIpc({ "moving-flag": false });
+    resetRequestMockChannels();
+    gateway.on("get_feature_flags", { "moving-flag": false });
 
     const config = {} as any;
     const inFlight = refreshOverridesFromGateway();

package/src/__tests__/input-repairs.test.ts

@@ -8,7 +8,7 @@ import {
   bundledToolInputRepairs,
 } from "../tools/shared/input-repairs.js";
 
-const TOOL = "scaffold_managed_skill";
+const TOOL = "scaffold_cloud_skill";
 const FIND_TOOL = "find_similar_skills";
 
 /** The real manifest entries the repairs describe. */

package/src/__tests__/install-skill-routing.test.ts

@@ -2,6 +2,8 @@ import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { setAllFlagsOnForTesting } from "../__tests__/feature-flag-test-helpers.js";
+
 // ---------------------------------------------------------------------------
 // Mock state
 // ---------------------------------------------------------------------------
@@ -94,9 +96,6 @@ mock.module("../skills/skillssh-registry.js", () => ({
 mock.module("../skills/install-meta.js", () => ({
   readInstallMeta: () => null,
 }));
-mock.module("../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: () => true,
-}));
 mock.module("../config/skill-state.js", () => ({
   resolveSkillStates: () => [],
   skillFlagKey: () => null,
@@ -139,10 +138,10 @@ mock.module("../skills/catalog-install.js", () => ({
 mock.module("../skills/catalog-search.js", () => ({
   filterByQuery: () => [],
 }));
-mock.module("../skills/managed-store.js", () => ({
-  createManagedSkill: () => ({ created: true }),
-  deleteManagedSkill: () => ({ deleted: true }),
-  validateManagedSkillId: () => null,
+mock.module("../skills/cloud-store.js", () => ({
+  createCloudSkill: () => ({ created: true }),
+  deleteCloudSkill: () => ({ deleted: true }),
+  validateCloudSkillId: () => null,
 }));
 mock.module("../plugins/defaults/memory/graph/capability-seed.js", () => ({
   deleteSkillCapabilityNode: () => {},
@@ -181,6 +180,9 @@ import { installSkill } from "../daemon/handlers/skills.js";
 
 describe("installSkill routing", () => {
   beforeEach(() => {
+    // Real flag resolution replaces the former blanket module mock.
+    setAllFlagsOnForTesting();
+
     rmSync(TEST_SKILLS_DIR, { recursive: true, force: true });
     mkdirSync(TEST_SKILLS_DIR, { recursive: true });
     installedSkillIds.clear();
@@ -388,7 +390,7 @@ Body.
     mockCatalogSkills.mockReturnValue([
       {
         id: "platform-skill",
-        displayName: "Platform Skill",
+        displayName: "Cloud Skill",
         description: "A platform-specific skill",
         source: "bundled",
         directoryPath: "/tmp/test-bundled-skills/platform-skill",