@mycadet/assistant 0.12.7 → 0.12.9

package/src/__tests__/skills.test.ts

@@ -1077,7 +1077,7 @@ describe("ingress-dependent setup skills declare public-ingress intentionally",
       "utf-8",
     );
     expect(content).toContain("avoid-when:");
-    expect(content.toLowerCase()).toContain("platform-managed");
+    expect(content.toLowerCase()).toContain("cloud-managed");
   });
 });
 

package/src/__tests__/slim-skill-category.test.ts

@@ -3,8 +3,9 @@
  * catalog entry > SKILL.md frontmatter > "system" fallback.
  */
 import { join } from "node:path";
-import { describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { setAllFlagsOnForTesting } from "../__tests__/feature-flag-test-helpers.js";
 import type { SkillSummary } from "../config/skills.js";
 import type { CatalogSkill } from "../skills/catalog-install.js";
 import type { SkillInstallMeta } from "../skills/install-meta.js";
@@ -27,10 +28,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: () => mockInstallMeta,
 }));
@@ -81,10 +78,10 @@ mock.module("../skills/skillssh-registry.js", () => ({
   searchSkillsRegistry: 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", () => ({
@@ -120,6 +117,11 @@ mock.module("../daemon/handlers/shared.js", () => ({
 
 import { listSkills } from "../daemon/handlers/skills.js";
 
+beforeEach(() => {
+  // Real flag resolution replaces the former blanket module mock.
+  setAllFlagsOnForTesting();
+});
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------

package/src/__tests__/stt-stream-session.test.ts

@@ -141,7 +141,7 @@ class FailingTranscriber implements StreamingTranscriber {
 
 /**
  * Mock managed transcriber whose start() throws a userFacing SttError,
- * mirroring the managed relay's mapped dial rejection.
+ * mirroring the cloud relay's mapped dial rejection.
  */
 class ManagedFailingTranscriber implements StreamingTranscriber {
   readonly providerId = "cadet" as const;
@@ -359,7 +359,7 @@ describe("SttStreamSession", () => {
     test("managed start failure surfaces its remediation verbatim", async () => {
       const { ws, session } = createSession("cadet");
       const managedMessage =
-        "Managed speech needs a working Cadet Cloud connection — reconnect with 'assistant cloud connect'.";
+        "Cloud speech needs a working Cadet Cloud connection — reconnect with 'assistant cloud connect'.";
 
       await session.start(
         async () => new ManagedFailingTranscriber(managedMessage),
@@ -368,7 +368,7 @@ describe("SttStreamSession", () => {
       const frames = ws.frames;
       expect(frames[0].type).toBe("error");
       expect(frames[0].category).toBe("auth");
-      // The managed remediation passes through; the BYOK "check your API key"
+      // The cloud remediation passes through; the BYOK "check your API key"
       // rewrite must not clobber it for a connection-backed provider.
       expect(frames[0].message).toBe(managedMessage);
       expect(frames[0].message as string).not.toContain("API key");

package/src/__tests__/subagent-call-site-routing.test.ts

@@ -121,7 +121,7 @@ mock.module("../prompts/system-prompt.js", () => ({
 // `provider_connection` exclusively. `getProvider` throws while this file's
 // tests run (the production code under test must not call it), and delegates
 // to the real registry afterwards: `mock.module` patches persist for the rest
-// of the `bun test` process, and later test files (e.g. the platform-proxy
+// of the `bun test` process, and later test files (e.g. the cloud-proxy
 // integration suite) call the real `getProvider`. The real function is
 // snapshotted before `mock.module` rebinds the import.
 const anthropicStub = { name: "anthropic" };

package/src/__tests__/subagent-disposal.test.ts

@@ -15,8 +15,8 @@ import {
 import { SubagentManager } from "../subagent/manager.js";
 import type { SubagentState } from "../subagent/types.js";
 
-/** Minimal shape matching the private ManagedSubagent interface for test injection. */
-interface FakeManagedSubagent {
+/** Minimal shape matching the private CloudSubagent interface for test injection. */
+interface FakeCloudSubagent {
   conversation: {
     abort: () => void;
     dispose: () => void;
@@ -48,7 +48,7 @@ interface FakeManagedSubagent {
 
 /** Type-safe accessor for SubagentManager's private internals via bracket notation. */
 interface ManagerInternals {
-  subagents: Map<string, FakeManagedSubagent>;
+  subagents: Map<string, FakeCloudSubagent>;
   parentToChildren: Map<string, Set<string>>;
   labelIndex: Map<string, string>;
   runSubagent: (subagentId: string, objective: string) => Promise<void>;
@@ -61,7 +61,7 @@ function asInternals(manager: SubagentManager): ManagerInternals {
 }
 
 function makeFakeConversation(): NonNullable<
-  FakeManagedSubagent["conversation"]
+  FakeCloudSubagent["conversation"]
 > {
   return {
     abort: () => {},
@@ -83,7 +83,7 @@ function injectFakeSubagent(
   subagentId: string,
   state: SubagentState,
   parentSendToClient?: (msg: AssistantEvent) => void,
-  conversation?: FakeManagedSubagent["conversation"],
+  conversation?: FakeCloudSubagent["conversation"],
 ): void {
   const internals = asInternals(manager);
 

package/src/__tests__/subagent-fork-notifications.test.ts

@@ -33,8 +33,8 @@ import { setBroadcastOverrideForTesting } from "../runtime/assistant-event-hub.j
 import { SubagentManager } from "../subagent/manager.js";
 import type { SubagentState } from "../subagent/types.js";
 
-/** Minimal shape matching the private ManagedSubagent interface for test injection. */
-interface FakeManagedSubagent {
+/** Minimal shape matching the private CloudSubagent interface for test injection. */
+interface FakeCloudSubagent {
   conversation: {
     abort: () => void;
     dispose: () => void;
@@ -64,7 +64,7 @@ interface FakeManagedSubagent {
 
 /** Type-safe accessor for SubagentManager's private internals via bracket notation. */
 interface ManagerInternals {
-  subagents: Map<string, FakeManagedSubagent>;
+  subagents: Map<string, FakeCloudSubagent>;
   parentToChildren: Map<string, Set<string>>;
   runSubagent: (subagentId: string, objective: string) => Promise<void>;
   stopSweep: () => void;
@@ -80,7 +80,7 @@ function injectFakeSubagent(
   state: SubagentState,
   parentSendToClient?: (msg: AssistantEvent) => void,
 ): void {
-  const fakeSession: FakeManagedSubagent["conversation"] = {
+  const fakeSession: FakeCloudSubagent["conversation"] = {
     abort: () => {},
     dispose: () => {},
     messages: [],

package/src/__tests__/subagent-fork-spawn.test.ts

@@ -10,8 +10,8 @@ import type { Message } from "../providers/types.js";
 import { SubagentManager } from "../subagent/manager.js";
 import type { SubagentConfig, SubagentState } from "../subagent/types.js";
 
-/** Minimal shape matching the private ManagedSubagent interface for test injection. */
-interface FakeManagedSubagent {
+/** Minimal shape matching the private CloudSubagent interface for test injection. */
+interface FakeCloudSubagent {
   conversation: {
     abort: () => void;
     dispose: () => void;
@@ -43,7 +43,7 @@ interface FakeManagedSubagent {
 
 /** Type-safe accessor for SubagentManager's private internals via bracket notation. */
 interface ManagerInternals {
-  subagents: Map<string, FakeManagedSubagent>;
+  subagents: Map<string, FakeCloudSubagent>;
   parentToChildren: Map<string, Set<string>>;
   runSubagent: (subagentId: string, objective: string) => Promise<void>;
   sweepTerminal: () => void;
@@ -55,7 +55,7 @@ function asInternals(manager: SubagentManager): ManagerInternals {
 }
 
 function makeFakeConversation(): NonNullable<
-  FakeManagedSubagent["conversation"]
+  FakeCloudSubagent["conversation"]
 > {
   return {
     abort: () => {},
@@ -77,7 +77,7 @@ function injectFakeSubagent(
   subagentId: string,
   state: SubagentState,
   parentSendToClient?: (msg: AssistantEvent) => void,
-  conversation?: FakeManagedSubagent["conversation"],
+  conversation?: FakeCloudSubagent["conversation"],
 ): void {
   const internals = asInternals(manager);
 

package/src/__tests__/subagent-manager-notify.test.ts

@@ -38,8 +38,8 @@ import { setBroadcastOverrideForTesting } from "../runtime/assistant-event-hub.j
 import { SubagentManager } from "../subagent/manager.js";
 import type { SubagentState } from "../subagent/types.js";
 
-/** Minimal shape matching the private ManagedSubagent interface for test injection. */
-interface FakeManagedSubagent {
+/** Minimal shape matching the private CloudSubagent interface for test injection. */
+interface FakeCloudSubagent {
   runInFlight?: boolean;
   conversation: {
     abort: () => void;
@@ -73,10 +73,10 @@ interface FakeManagedSubagent {
 
 /** Type-safe accessor for SubagentManager's private internals via bracket notation. */
 interface ManagerInternals {
-  subagents: Map<string, FakeManagedSubagent>;
+  subagents: Map<string, FakeCloudSubagent>;
   parentToChildren: Map<string, Set<string>>;
   runSubagent: (subagentId: string, objective: string) => Promise<void>;
-  releaseConversation: (managed: FakeManagedSubagent) => void;
+  releaseConversation: (managed: FakeCloudSubagent) => void;
   stopSweep: () => void;
 }
 
@@ -94,7 +94,7 @@ function injectFakeSubagent(
   state: SubagentState,
   parentSendToClient?: (msg: AssistantEvent) => void,
 ): void {
-  const fakeSession: FakeManagedSubagent["conversation"] = {
+  const fakeSession: FakeCloudSubagent["conversation"] = {
     abort: () => {},
     dispose: () => {},
     messages: [],

package/src/__tests__/subagent-tool-gate-mode.test.ts

@@ -1290,7 +1290,7 @@ describe("createResolveToolsCallback: wire tool surface record and replay", () =
   });
 
   test("replays wireToolReplay verbatim on the wire while execution still derives from the fork's own context", () => {
-    projectedSkillToolNames = ["scaffold_managed_skill"];
+    projectedSkillToolNames = ["scaffold_cloud_skill"];
     const replay: ToolDefinition[] = [
       makeToolDef("bash"),
       makeToolDef("remember"),
@@ -1320,7 +1320,7 @@ describe("createResolveToolsCallback: wire tool surface record and replay", () =
     // Execution-side inventory is still the fork's own derivation (plus the
     // preactivated skill tools), never widened by the replayed definitions.
     expect(ctx.allowedToolNames).toEqual(
-      new Set(["remember", "bash", "scaffold_managed_skill"]),
+      new Set(["remember", "bash", "scaffold_cloud_skill"]),
     );
   });
 

package/src/__tests__/system-prompt.test.ts

@@ -62,7 +62,7 @@ mock.module("../oauth/oauth-store.js", () => ({
   listConnections: () => mockOauthConnections,
 }));
 
-mock.module("../credential-execution/managed-catalog.js", () => ({
+mock.module("../credential-execution/cloud-catalog.js", () => ({
   getCachedManagedConnections: () => mockManagedConnections,
 }));
 

package/src/__tests__/telegram-bot-username-resolution.test.ts

@@ -4,7 +4,8 @@
  * This function fills the bot-username gap when the token was configured
  * without a `getMe` call (e.g. via `credential set` or ingress secret
  * redirect). Each branch is exercised in isolation by controlling the
- * mutable mock variables below.
+ * bot-username mock and registering the fetch responses each test assumes
+ * (requests-mock).
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -12,6 +13,7 @@ import { loadRawConfig } from "../config/loader.js";
 import { credentialKey } from "../security/credential-key.js";
 import { useMemorySecureKeyMap } from "./helpers/secure-keys.js";
 import { setConfig } from "./helpers/set-config.js";
+import { type HttpMockController, mockHttp } from "./requests-mock.js";
 
 // The REAL secure-keys module pinned to a live memory backend, seeded under
 // the credential key the telegram transport reads.
@@ -41,16 +43,11 @@ function readResolvedBotUsername(): unknown {
 }
 
 // ---------------------------------------------------------------------------
-// Global fetch mock — swapped per test
+// HTTP mock — per-test requests-mock registrations; the preload's afterEach
+// restores the real fetch after every test
 // ---------------------------------------------------------------------------
 
-let mockFetchResponse: {
-  ok: boolean;
-  status: number;
-  json: () => Promise<unknown>;
-};
-let mockFetchThrows: Error | undefined;
-let fetchCallCount = 0;
+let http: HttpMockController;
 
 beforeEach(() => {
   mockBotUsername = undefined;
@@ -58,21 +55,11 @@ beforeEach(() => {
   // Clear any username a prior test persisted; all tests share one workspace
   // config.json, and the file is the write target under test.
   setConfig("telegram", {});
-  mockFetchThrows = undefined;
-  mockFetchResponse = {
-    ok: true,
+  http = mockHttp();
+  http.on("GET", "api.telegram.org", {
     status: 200,
-    json: async () => ({ ok: true, result: { username: "ResolvedBot" } }),
-  };
-  fetchCallCount = 0;
-
-  globalThis.fetch = (async (..._args: unknown[]) => {
-    fetchCallCount++;
-    if (mockFetchThrows) {
-      throw mockFetchThrows;
-    }
-    return mockFetchResponse;
-  }) as typeof globalThis.fetch;
+    body: { ok: true, result: { username: "ResolvedBot" } },
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -93,63 +80,60 @@ describe("ensureTelegramBotUsernameResolved", () => {
 
     await ensureTelegramBotUsernameResolved();
 
-    expect(fetchCallCount).toBe(0);
+    expect(http.callCount()).toBe(0);
     expect(readResolvedBotUsername()).toBeUndefined();
   });
 
   test("(b) fetches getMe and writes username to config on success", async () => {
     mockBotUsername = undefined;
     secureKeys.set(TELEGRAM_BOT_TOKEN, "bot-token-123");
-    mockFetchResponse = {
-      ok: true,
+    http.on("GET", "api.telegram.org", {
       status: 200,
-      json: async () => ({ ok: true, result: { username: "MyNewBot" } }),
-    };
+      body: { ok: true, result: { username: "MyNewBot" } },
+    });
 
     await ensureTelegramBotUsernameResolved();
 
-    expect(fetchCallCount).toBe(1);
+    expect(http.callCount()).toBe(1);
     expect(readResolvedBotUsername()).toBe("MyNewBot");
   });
 
   test("(c) handles non-200 response gracefully without writing to config", async () => {
     mockBotUsername = undefined;
     secureKeys.set(TELEGRAM_BOT_TOKEN, "bot-token-123");
-    mockFetchResponse = {
-      ok: false,
+    http.on("GET", "api.telegram.org", {
       status: 401,
-      json: async () => ({ ok: false, description: "Unauthorized" }),
-    };
+      body: { ok: false, description: "Unauthorized" },
+    });
 
     await ensureTelegramBotUsernameResolved();
 
-    expect(fetchCallCount).toBe(1);
+    expect(http.callCount()).toBe(1);
     expect(readResolvedBotUsername()).toBeUndefined();
   });
 
   test("(d) handles missing username in response gracefully", async () => {
     mockBotUsername = undefined;
     secureKeys.set(TELEGRAM_BOT_TOKEN, "bot-token-123");
-    mockFetchResponse = {
-      ok: true,
+    http.on("GET", "api.telegram.org", {
       status: 200,
-      json: async () => ({ ok: true, result: {} }),
-    };
+      body: { ok: true, result: {} },
+    });
 
     await ensureTelegramBotUsernameResolved();
 
-    expect(fetchCallCount).toBe(1);
+    expect(http.callCount()).toBe(1);
     expect(readResolvedBotUsername()).toBeUndefined();
   });
 
   test("(e) handles network errors (fetch throws) gracefully", async () => {
     mockBotUsername = undefined;
     secureKeys.set(TELEGRAM_BOT_TOKEN, "bot-token-123");
-    mockFetchThrows = new Error("ECONNREFUSED");
+    http.on("GET", "api.telegram.org", new Error("ECONNREFUSED"));
 
     await ensureTelegramBotUsernameResolved();
 
-    expect(fetchCallCount).toBe(1);
+    expect(http.callCount()).toBe(1);
     expect(readResolvedBotUsername()).toBeUndefined();
   });
 
@@ -159,37 +143,35 @@ describe("ensureTelegramBotUsernameResolved", () => {
 
     await ensureTelegramBotUsernameResolved();
 
-    expect(fetchCallCount).toBe(0);
+    expect(http.callCount()).toBe(0);
     expect(readResolvedBotUsername()).toBeUndefined();
   });
 
   test("writes to config when bot username not in config", async () => {
     mockBotUsername = undefined;
     secureKeys.set(TELEGRAM_BOT_TOKEN, "bot-token-123");
-    mockFetchResponse = {
-      ok: true,
+    http.on("GET", "api.telegram.org", {
       status: 200,
-      json: async () => ({ ok: true, result: { username: "FreshBot" } }),
-    };
+      body: { ok: true, result: { username: "FreshBot" } },
+    });
 
     await ensureTelegramBotUsernameResolved();
 
-    expect(fetchCallCount).toBe(1);
+    expect(http.callCount()).toBe(1);
     expect(readResolvedBotUsername()).toBe("FreshBot");
   });
 
   test("writes to config when bot username resolved from API", async () => {
     mockBotUsername = undefined;
     secureKeys.set(TELEGRAM_BOT_TOKEN, "bot-token-456");
-    mockFetchResponse = {
-      ok: true,
+    http.on("GET", "api.telegram.org", {
       status: 200,
-      json: async () => ({ ok: true, result: { username: "AnotherBot" } }),
-    };
+      body: { ok: true, result: { username: "AnotherBot" } },
+    });
 
     await ensureTelegramBotUsernameResolved();
 
-    expect(fetchCallCount).toBe(1);
+    expect(http.callCount()).toBe(1);
     expect(readResolvedBotUsername()).toBe("AnotherBot");
   });
 });

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

@@ -18,7 +18,7 @@ let oauthConnectionStore: Record<
   { id: string; status: string; accountInfo?: string | null }
 > = {};
 const syncCalls: Array<{ provider: string; accountInfo?: string }> = [];
-let platformContextEnabled = false;
+let cloudContextEnabled = false;
 
 const registerCallbackRouteMock = mock(
   async (callbackPath: string, _type: string) =>
@@ -28,17 +28,17 @@ const registerCallbackRouteMock = mock(
 // Spread the real module: it is a shared barrel and replacing it wholesale
 // breaks unrelated importers pulled in by the module under test.
 const actualPlatformCallbackRegistration =
-  await import("../inbound/platform-callback-registration.js");
-mock.module("../inbound/platform-callback-registration.js", () => ({
+  await import("../inbound/cloud-callback-registration.js");
+mock.module("../inbound/cloud-callback-registration.js", () => ({
   ...actualPlatformCallbackRegistration,
   registerCallbackRoute: registerCallbackRouteMock,
-  resolvePlatformCallbackRegistrationContext: async () => ({
+  resolveCloudCallbackRegistrationContext: async () => ({
     isPlatform: false,
-    platformBaseUrl: platformContextEnabled ? "https://cloud.mycadet.ai" : "",
-    assistantId: platformContextEnabled ? "assistant-123" : "",
-    hasAssistantApiKey: platformContextEnabled,
-    authHeader: platformContextEnabled ? "Api-Key secret" : null,
-    enabled: platformContextEnabled,
+    cloudBaseUrl: "",
+    assistantId: cloudContextEnabled ? "assistant-123" : "",
+    hasAssistantApiKey: cloudContextEnabled,
+    authHeader: cloudContextEnabled ? "Api-Key secret" : null,
+    enabled: cloudContextEnabled,
   }),
 }));
 
@@ -120,7 +120,7 @@ describe("Telegram config handler", () => {
     reseedMemorySecureKeys(secureKeyStore);
     oauthConnectionStore = {};
     syncCalls.length = 0;
-    platformContextEnabled = false;
+    cloudContextEnabled = false;
     registerCallbackRouteMock.mockClear();
     setIngressPublicBaseUrl("");
     globalThis.fetch = originalFetch;
@@ -145,12 +145,12 @@ describe("Telegram config handler", () => {
     expect(oauthConnectionStore["telegram"]?.accountInfo).toBe("@testbot");
   });
 
-  // A platform-connected local assistant (IS_PLATFORM unset, valid platform
+  // A platform-connected local assistant (IS_CLOUD unset, valid platform
   // credentials, no public ingress) receives Telegram webhooks only through
   // managed platform callbacks, so saving the bot token must register the
   // route.
-  test("set registers the platform callback route for a platform-connected local assistant", async () => {
-    platformContextEnabled = true;
+  test("set registers the cloud callback route for a cloud-connected local assistant", async () => {
+    cloudContextEnabled = true;
     globalThis.fetch = mockTelegramApi();
 
     const result = await setTelegramConfig(
@@ -164,7 +164,7 @@ describe("Telegram config handler", () => {
     );
   });
 
-  test("set does not register a platform callback route when not platform-connected", async () => {
+  test("set does not register a cloud callback route when not platform-connected", async () => {
     globalThis.fetch = mockTelegramApi();
 
     const result = await setTelegramConfig(
@@ -177,8 +177,8 @@ describe("Telegram config handler", () => {
 
   // A logged-in local assistant holds cloud credentials for the LLM proxy,
   // so credential presence must not override an explicitly configured ingress.
-  test("set does not register a platform callback route when a public ingress is configured", async () => {
-    platformContextEnabled = true;
+  test("set does not register a cloud callback route when a public ingress is configured", async () => {
+    cloudContextEnabled = true;
     setIngressPublicBaseUrl("https://abc.ngrok.io");
     globalThis.fetch = mockTelegramApi();
 

package/src/__tests__/telephony-tts-guard.test.ts

@@ -192,10 +192,10 @@ mock.module("../calls/audio-store.js", () => ({
   },
 }));
 
-let mockManagedSpeechAvailable = true;
+let mockCloudSpeechAvailable = true;
 
-mock.module("../platform/managed-speech.js", () => ({
-  managedSpeechAvailable: async () => mockManagedSpeechAvailable,
+mock.module("../cloud/cloud-speech.js", () => ({
+  managedSpeechAvailable: async () => mockCloudSpeechAvailable,
 }));
 
 mock.module("../inbound/public-ingress-urls.js", () => ({
@@ -470,10 +470,10 @@ describe("resolveCallTtsProvider with requiresPcmAudio", () => {
     expect(result.audioFormat).toBe("mp3");
   });
 
-  test("managed speech stands in for a configured provider whose credential is missing", async () => {
+  test("cloud speech stands in for a configured provider whose credential is missing", async () => {
     testConfig.services.tts.provider = "deepgram";
-    // No deepgram key, managed speech available: the phone speaks through
-    // managed speech, the same substitution live voice makes.
+    // No deepgram key, cloud speech available: the phone speaks through
+    // cloud speech, the same substitution live voice makes.
     registerStubProvider("deepgram", async () => {
       throw new Error("should not be used");
     });
@@ -486,8 +486,8 @@ describe("resolveCallTtsProvider with requiresPcmAudio", () => {
     expect(result.useSynthesizedPath).toBe(true);
   });
 
-  test("without managed speech a credential-less configured provider is kept", async () => {
-    mockManagedSpeechAvailable = false;
+  test("without cloud speech a credential-less configured provider is kept", async () => {
+    mockCloudSpeechAvailable = false;
     try {
       testConfig.services.tts.provider = "deepgram";
       registerStubProvider("deepgram", async () => {
@@ -497,7 +497,7 @@ describe("resolveCallTtsProvider with requiresPcmAudio", () => {
       const result = await resolveCallTtsProvider();
       expect(result.provider?.id).toBe("deepgram");
     } finally {
-      mockManagedSpeechAvailable = true;
+      mockCloudSpeechAvailable = true;
     }
   });
 });
@@ -795,21 +795,21 @@ describe("speakSystemPrompt aborted synthesis", () => {
 });
 
 describe("cadet managed playability", () => {
-  test("playable only when the platform identity is fully provisioned", async () => {
+  test("playable only when the cloud identity is fully provisioned", async () => {
     // The stored secret resolves, but availability decides.
     storedKeys["cadet"] = "stored";
-    mockManagedSpeechAvailable = true;
+    mockCloudSpeechAvailable = true;
     const playable = await evaluateTelephonyTtsPlayability("cadet");
     expect(playable.status).toBe("playable");
   });
 
   test("half-connected platform (secret without identity) is not playable", async () => {
     storedKeys["cadet"] = "stored";
-    mockManagedSpeechAvailable = false;
+    mockCloudSpeechAvailable = false;
     const playable = await evaluateTelephonyTtsPlayability("cadet");
     expect(playable).toMatchObject({
       status: "not-playable",
-      reason: "missing-platform-connection",
+      reason: "missing-cloud-connection",
     });
   });
 });

package/src/__tests__/test-preload.ts

@@ -20,9 +20,12 @@
 import { cpSync, mkdirSync, mkdtempSync, realpathSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterAll } from "bun:test";
+import { afterAll, afterEach } from "bun:test";
 
-import { installGatewayIpcMock } from "./mock-gateway-ipc.js";
+import {
+  installGatewayIpcMock,
+  resetRequestMockChannels,
+} from "./requests-mock.js";
 
 // --- Phase 1: env override (zero source-module imports above this point) ---
 
@@ -30,7 +33,7 @@ const tmpRoot = realpathSync(mkdtempSync(join(tmpdir(), "cadet-test-")));
 const testDir = join(tmpRoot, "workspace");
 mkdirSync(testDir);
 process.env.CADET_WORKSPACE_DIR = testDir;
-process.env.CADET_PLATFORM_URL = "https://test-cloud.mycadet.ai";
+process.env.CADET_CLOUD_URL = "https://test-cloud.mycadet.ai";
 // Cap libvips threads so image conversions don't stampede the shared
 // CI cores when many worker processes run sharp at once.
 process.env.VIPS_CONCURRENCY = "1";
@@ -66,15 +69,22 @@ delete process.env.CES_CREDENTIAL_URL;
 // --- Phase 2: install the IPC mock (no source-module imports) ---
 
 // Mock gateway IPC so no test accidentally connects to a real gateway socket.
-// The mock returns a sentinel for `get_feature_flags` to short-circuit the
-// retry loop in `initFeatureFlagOverrides()`. Tests that need specific IPC
-// responses use `mockGatewayIpc()` / `resetMockGatewayIpc()`.
+// The transport answers a sentinel for `get_feature_flags` to short-circuit
+// the retry loop in `initFeatureFlagOverrides()`. Tests that need specific
+// IPC behavior use `mockIpc("gateway")` (`.on`, `.setDefaults`,
+// `.failConnect`, `.failFirstN`).
 installGatewayIpcMock();
 
+// requests-mock channels (mockIpc/mockHttp) are per-test by construction:
+// clear registrations + history and restore fetch after every test.
+afterEach(() => {
+  resetRequestMockChannels();
+});
+
 afterAll(() => {
   process.exitCode = 0;
   delete process.env.CADET_WORKSPACE_DIR;
-  delete process.env.CADET_PLATFORM_URL;
+  delete process.env.CADET_CLOUD_URL;
   if (savedIsContainerized !== undefined) {
     process.env.IS_CONTAINERIZED = savedIsContainerized;
   }