@mycadet/assistant 0.12.7 → 0.12.9

package/src/inbound/pod-webhook-claim.ts

@@ -1,11 +1,11 @@
 /**
- * The platform-pod tier of webhook URL resolution, shared by the two seams that
+ * The cloud-pod tier of webhook URL resolution, shared by the two seams that
  * resolve callback URLs: `resolveCallbackUrl` and the `webhooks_register` route
  * handler.
  *
  * A pod's Tunnel only forwards subpaths the gateway has claimed, so the
  * published ingress URL is handed out only once the claim succeeds. Anything
- * else leaves the caller to register with the platform instead.
+ * else leaves the caller to register with the cloud instead.
  */
 
 /**

package/src/inbound/public-ingress-urls.ts

@@ -51,11 +51,11 @@ export interface IngressConfig {
  * True when the user has explicitly switched public ingress off.
  *
  * An explicit opt-out is a decision not to accept inbound webhooks at all, so
- * it must not be silently routed around via platform callbacks. An *absent*
- * ingress config is merely "not set up yet" and is eligible for the platform
+ * it must not be silently routed around via cloud callbacks. An *absent*
+ * ingress config is merely "not set up yet" and is eligible for the cloud
  * fallback, so only a literal `false` counts here.
  *
- * Every consumer that offers a platform-callback fallback has to consult this
+ * Every consumer that offers a cloud-callback fallback has to consult this
  * before falling back, which is why it lives here rather than in each caller.
  */
 export function isPublicIngressDisabled(config: IngressConfig): boolean {

package/src/inbound/tunnel-probe.ts

@@ -39,6 +39,7 @@ import {
   normalizeHttpPublicBaseUrlWithoutTrailingSlash,
   trimmedNonEmptyString,
 } from "@mycadet/service-contracts/ingress";
+import { z } from "zod";
 
 import { isPlainObject } from "../util/object.js";
 import { truncate } from "../util/truncate.js";
@@ -81,11 +82,17 @@ const UNREADABLE_CONFIG_DETAIL = "no assistant config served";
 const UNMARKED_CONFIG_DETAIL = "not a pairing edge config";
 
 /**
- * Stamped into the served config by the nginx pairing edge and nothing else
- * (`remoteWebIngressConfig` in `cli/src/lib/nginx-ingress.ts`), which makes it
- * the marker that separates that edge from any other JSON a live URL serves.
+ * The config a self-hosted edge serves (`remoteWebIngressConfig` in
+ * `cli/src/lib/nginx-ingress.ts`). The `remote` field is always stamped by
+ * that injector and never carries `"cloud"` — that spelling is the cloud's
+ * own serving, which is not an edge — so the field is the marker separating
+ * the edge from any other JSON a live URL serves.
  */
-const PAIRING_EDGE_MODE = "remote-gateway";
+const ServedConfigSchema = z.object({
+  remote: z.string(),
+  assistantId: z.string().optional(),
+  assistantName: z.string().optional(),
+});
 
 export async function probeTunnel(args: {
   publicBaseUrl: string;
@@ -241,18 +248,17 @@ async function readServedConfig(
   let detail = UNREADABLE_CONFIG_DETAIL;
   try {
     const body: unknown = await response.json();
-    if (isPlainObject(body)) {
-      if (body.mode === PAIRING_EDGE_MODE) {
-        return {
-          kind: "served",
-          config: {
-            assistantId: trimmedNonEmptyString(body.assistantId),
-            assistantName: trimmedNonEmptyString(body.assistantName),
-          },
-        };
-      }
-      detail = UNMARKED_CONFIG_DETAIL;
+    const parsed = ServedConfigSchema.safeParse(body);
+    if (parsed.success && parsed.data.remote !== "cloud") {
+      return {
+        kind: "served",
+        config: {
+          assistantId: trimmedNonEmptyString(parsed.data.assistantId),
+          assistantName: trimmedNonEmptyString(parsed.data.assistantName),
+        },
+      };
     }
+    detail = UNMARKED_CONFIG_DETAIL;
   } catch {
     /* an unparseable body is an edge answering with something else */
   }

package/src/inbound/tunnel-webhooks-gate.ts

@@ -3,14 +3,14 @@ import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags
 const TUNNEL_WEBHOOKS_FLAG_KEY = "tunnel-webhooks" as const;
 
 /**
- * Whether platform pods resolve webhook callback URLs from the
+ * Whether cloud pods resolve webhook callback URLs from the
  * Tunnel-published ingress URL instead of registering platform callback
  * routes.
  *
- * Gates the platform-pod tier in all three webhook resolution sites
+ * Gates the cloud-pod tier in all three webhook resolution sites
  * (`resolveCallbackUrl`, `hasWebhookRoutingConfigured`,
  * `handleWebhooksRegister`), which must agree tier for tier. Off means the
- * pre-Tunnel behavior: platform pods always register with the platform
+ * pre-Tunnel behavior: cloud pods always register with the cloud
  * gateway. On means ingress-first with platform registration as the
  * fallback, so a pod whose tunnel has not published a URL yet keeps
  * working either way.

package/src/ipc/__tests__/db-readiness-ipc-gate.test.ts

@@ -108,7 +108,7 @@ describe("AssistantIpcServer DB migration readiness gate", () => {
     setDbMigrationFailed(new Error("boom"));
     expect(gate("admin_rollbackmigrations_post")).toBeNull();
     expect(gate("migrations_import_post")).toBeNull();
-    // All restore transports are repair-capable: preflights, the managed
+    // All restore transports are repair-capable: preflights, the cloud
     // platform's GCS path, and its job-status polling.
     expect(gate("migrations_importpreflight_post")).toBeNull();
     expect(gate("migrations_importfromgcs_post")).toBeNull();

package/src/ipc/__tests__/email-ipc.test.ts

@@ -2,8 +2,8 @@
  * Behavioral parity tests for the email CLI commands.
  *
  * Exercises the full IPC round-trip using a real AssistantIpcServer with a
- * mocked CadetPlatformClient. Validates that each email subcommand:
- *   - sends the correct HTTP request to the platform API
+ * mocked CadetCloudClient. Validates that each email subcommand:
+ *   - sends the correct HTTP request to the cloud API
  *   - surfaces success responses to the CLI caller
  *   - surfaces platform errors to the CLI caller
  */
@@ -20,7 +20,7 @@ import { runAssistantCommandFull } from "../../cli/__tests__/run-assistant-comma
 import { AssistantIpcServer } from "../assistant-server.js";
 
 // ---------------------------------------------------------------------------
-// Mock state — set up a controllable CadetPlatformClient at module boundary
+// Mock state — set up a controllable CadetCloudClient at module boundary
 // ---------------------------------------------------------------------------
 
 let mockFetchFn: (
@@ -31,10 +31,10 @@ let mockFetchFn: (
 
 const mockAssistantId = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
 
-mock.module("../../platform/client.js", () => ({
-  CadetPlatformClient: {
+mock.module("../../cloud/client.js", () => ({
+  CadetCloudClient: {
     create: async () => ({
-      platformAssistantId: mockAssistantId,
+      cloudAssistantId: mockAssistantId,
       fetch: (path: string, init?: RequestInit) => mockFetchFn(path, init),
     }),
   },
@@ -361,7 +361,7 @@ test("send --json returns delivery_id", async () => {
   expect(process.exitCode).toBe(0);
 });
 
-test("send --attach reads the file and forwards base64 attachments to the platform", async () => {
+test("send --attach reads the file and forwards base64 attachments to the cloud", async () => {
   const dir = mkdtempSync(join(tmpdir(), "email-attach-"));
   const filePath = join(dir, "report.pdf");
   const fileBytes = "pdf-bytes-here";
@@ -413,7 +413,7 @@ test("send --attach reads the file and forwards base64 attachments to the platfo
   }
 });
 
-test("send with a missing --attach path fails without calling the platform", async () => {
+test("send with a missing --attach path fails without calling the cloud", async () => {
   let sendCalled = false;
   mockFetchFn = async (path) => {
     if (path.includes("/email-addresses/")) {

package/src/ipc/gateway-client.test.ts

@@ -8,11 +8,7 @@
  */
 import { afterEach, describe, expect, test } from "bun:test";
 
-import {
-  getMockPersistentCallCount,
-  mockGatewayIpc,
-  resetMockGatewayIpc,
-} from "../__tests__/mock-gateway-ipc.js";
+import { mockIpc } from "../__tests__/requests-mock.js";
 import { ServiceUnavailableError } from "../runtime/routes/errors.js";
 import {
   ipcCall,
@@ -25,7 +21,6 @@ import {
 
 afterEach(() => {
   resetPersistentClient();
-  resetMockGatewayIpc();
 });
 
 // ---------------------------------------------------------------------------
@@ -34,22 +29,24 @@ afterEach(() => {
 
 describe("ipcCall", () => {
   test("delegates to package ipcCall and returns result", async () => {
-    mockGatewayIpc(null, {
-      results: { test_method: { key: "value" } },
-    });
+    const gateway = await mockIpc("gateway");
+    gateway.setDefaults({ test_method: { key: "value" } });
 
     const result = await ipcCall("test_method");
     expect(result).toEqual({ key: "value" });
   });
 
   test("returns undefined when mock simulates error", async () => {
-    mockGatewayIpc(null, { error: true });
+    const gateway = await mockIpc("gateway");
+    gateway.failConnect();
 
     const result = await ipcCall("test_method");
     expect(result).toBeUndefined();
   });
 
   test("returns undefined for unconfigured methods", async () => {
+    await mockIpc("gateway");
+
     const result = await ipcCall("unconfigured_method");
     expect(result).toBeUndefined();
   });
@@ -61,16 +58,16 @@ describe("ipcCall", () => {
 
 describe("ipcCallPersistent", () => {
   test("returns result from persistent client", async () => {
-    mockGatewayIpc(null, {
-      results: { persistent_test: "persistent-result" },
-    });
+    const gateway = await mockIpc("gateway");
+    gateway.setDefaults({ persistent_test: "persistent-result" });
 
     const result = await ipcCallPersistent("persistent_test");
     expect(result).toBe("persistent-result");
   });
 
   test("maps a missing gateway socket to ServiceUnavailableError", async () => {
-    mockGatewayIpc(null, { error: true });
+    const gateway = await mockIpc("gateway");
+    gateway.failConnect();
 
     await expect(ipcCallPersistent("any_method")).rejects.toBeInstanceOf(
       ServiceUnavailableError,
@@ -92,21 +89,23 @@ describe("ipcCallPersistent", () => {
 
 describe("ipcGetFeatureFlags", () => {
   test("parses boolean flag values from IPC response", async () => {
-    mockGatewayIpc({ "flag-a": true, "flag-b": false });
+    const gateway = await mockIpc("gateway");
+    gateway.setDefaults({
+      get_feature_flags: { "flag-a": true, "flag-b": false },
+    });
 
     const flags = await ipcGetFeatureFlags();
     expect(flags).toEqual({ "flag-a": true, "flag-b": false });
   });
 
   test("accepts boolean and string values, filters other types from response", async () => {
-    mockGatewayIpc(null, {
-      results: {
-        get_feature_flags: {
-          valid: true,
-          number: 42,
-          string: "yes",
-          nested: { deep: true },
-        },
+    const gateway = await mockIpc("gateway");
+    gateway.setDefaults({
+      get_feature_flags: {
+        valid: true,
+        number: 42,
+        string: "yes",
+        nested: { deep: true },
       },
     });
 
@@ -115,25 +114,26 @@ describe("ipcGetFeatureFlags", () => {
   });
 
   test("returns empty record when IPC returns undefined", async () => {
-    // Explicitly suppress the mock's default `get_feature_flags` sentinel
-    // (which exists to short-circuit `initFeatureFlagOverrides()`'s retry
-    // loop) so this test exercises the underlying-undefined path.
-    mockGatewayIpc(null, { results: { get_feature_flags: undefined } });
+    // Explicitly suppress the transport's default `get_feature_flags`
+    // sentinel (which exists to short-circuit `initFeatureFlagOverrides()`'s
+    // retry loop) so this test exercises the underlying-undefined path.
+    const gateway = await mockIpc("gateway");
+    gateway.setDefaults({ get_feature_flags: undefined });
     const flags = await ipcGetFeatureFlags();
     expect(flags).toEqual({});
   });
 
   test("returns empty record when IPC returns array", async () => {
-    mockGatewayIpc(null, {
-      results: { get_feature_flags: [true, false] },
-    });
+    const gateway = await mockIpc("gateway");
+    gateway.setDefaults({ get_feature_flags: [true, false] });
 
     const flags = await ipcGetFeatureFlags();
     expect(flags).toEqual({});
   });
 
   test("returns empty record on error", async () => {
-    mockGatewayIpc(null, { error: true });
+    const gateway = await mockIpc("gateway");
+    gateway.failConnect();
 
     const flags = await ipcGetFeatureFlags();
     expect(flags).toEqual({});
@@ -142,12 +142,11 @@ describe("ipcGetFeatureFlags", () => {
 
 describe("ipcGetTunnelStatus", () => {
   test("parses the shared Tunnel status response", async () => {
-    mockGatewayIpc(null, {
-      results: {
-        get_tunnel_status: {
-          connected: true,
-          publicUrl: "https://example.test",
-        },
+    const gateway = await mockIpc("gateway");
+    gateway.setDefaults({
+      get_tunnel_status: {
+        connected: true,
+        publicUrl: "https://example.test",
       },
     });
 
@@ -158,10 +157,9 @@ describe("ipcGetTunnelStatus", () => {
   });
 
   test("keeps connected status when publicUrl is malformed", async () => {
-    mockGatewayIpc(null, {
-      results: {
-        get_tunnel_status: { connected: false, publicUrl: 42 },
-      },
+    const gateway = await mockIpc("gateway");
+    gateway.setDefaults({
+      get_tunnel_status: { connected: false, publicUrl: 42 },
     });
 
     expect(await ipcGetTunnelStatus()).toEqual({
@@ -171,9 +169,8 @@ describe("ipcGetTunnelStatus", () => {
   });
 
   test("returns null when connected is missing or malformed", async () => {
-    mockGatewayIpc(null, {
-      results: { get_tunnel_status: { connected: "yes" } },
-    });
+    const gateway = await mockIpc("gateway");
+    gateway.setDefaults({ get_tunnel_status: { connected: "yes" } });
 
     expect(await ipcGetTunnelStatus()).toBeNull();
   });
@@ -193,38 +190,37 @@ describe("ipcClassifyRisk retry", () => {
   const emptyParams = {} as unknown as Parameters<typeof ipcClassifyRisk>[0];
 
   test("retries a transient failure and then succeeds", async () => {
-    mockGatewayIpc(null, {
-      failFirstN: 1,
-      results: { classify_risk: CLASSIFY_OK },
-    });
+    const gateway = await mockIpc("gateway");
+    gateway.failFirstN(1);
+    gateway.setDefaults({ classify_risk: CLASSIFY_OK });
 
     const result = await ipcClassifyRisk(emptyParams);
     expect(result?.risk).toBe("low");
-    expect(getMockPersistentCallCount("classify_risk")).toBe(2);
+    expect(gateway.persistentCallCount("classify_risk")).toBe(2);
   });
 
   test("returns undefined after exhausting retries (3 attempts)", async () => {
-    mockGatewayIpc(null, { error: true });
+    const gateway = await mockIpc("gateway");
+    gateway.failConnect();
 
     const result = await ipcClassifyRisk(emptyParams);
     expect(result).toBeUndefined();
-    expect(getMockPersistentCallCount("classify_risk")).toBe(3);
+    expect(gateway.persistentCallCount("classify_risk")).toBe(3);
   });
 
   test("does NOT retry a structured IpcCallError (fails after 1 attempt)", async () => {
-    mockGatewayIpc(null, {
-      failFirstN: 3,
-      ipcCallError: true,
-      results: { classify_risk: CLASSIFY_OK },
-    });
+    const gateway = await mockIpc("gateway");
+    gateway.failFirstN(3, { ipcCallError: true });
+    gateway.setDefaults({ classify_risk: CLASSIFY_OK });
 
     const result = await ipcClassifyRisk(emptyParams);
     expect(result).toBeUndefined();
-    expect(getMockPersistentCallCount("classify_risk")).toBe(1);
+    expect(gateway.persistentCallCount("classify_risk")).toBe(1);
   });
 
   test("stops retrying once the signal is aborted", async () => {
-    mockGatewayIpc(null, { error: true });
+    const gateway = await mockIpc("gateway");
+    gateway.failConnect();
     const controller = new AbortController();
     controller.abort();
 
@@ -232,6 +228,6 @@ describe("ipcClassifyRisk retry", () => {
     expect(result).toBeUndefined();
     // An already-aborted signal short-circuits the retry loop after the first
     // failed attempt rather than exhausting all three.
-    expect(getMockPersistentCallCount("classify_risk")).toBe(1);
+    expect(gateway.persistentCallCount("classify_risk")).toBe(1);
   });
 });

package/src/ipc/gateway-flag-listener.ts

@@ -12,9 +12,9 @@ const log = getLogger("gateway-flag-listener");
 
 /**
  * Refresh the flag-overrides cache from the gateway, then reconcile the
- * flag-gated managed profile (OS Beta). Both the `feature_flags_changed` event
+ * flag-gated cloud profile (OS Beta). Both the `feature_flags_changed` event
  * and a reconnect refresh the cache; `reconcileFlagGatedProfiles` then adds or
- * removes the managed profile and, when it reports a change, a `config_changed`
+ * removes the cloud profile and, when it reports a change, a `config_changed`
  * broadcast refreshes the profile picker on clients. The reconcile runs only
  * when the refresh confirmed flags loaded from the gateway — a transient IPC
  * failure leaves the cache unset and resolves `os-beta` to its registry default
@@ -109,7 +109,7 @@ function connectToGateway(): void {
     currentBackoffMs = INITIAL_BACKOFF_MS;
     socket = conn;
     // A reconnect may have missed a flag flip while disconnected, so reconcile
-    // the managed profile too — not just the cache.
+    // the cloud profile too — not just the cache.
     refreshFlagsAndReconcileProfiles("reconnect");
   });
 

package/src/ipc/routes/db-proxy.ts

@@ -3,7 +3,7 @@
  * against the assistant's SQLite database. Migrations (m0002, m0010, m0014,
  * et al.) need raw read/drop access to legacy assistant tables on first boot
  * of upgraded installs, and cross-container SQLite file access corrupts the
- * DB on platform pods (fcntl locks are not shared across mount namespaces) —
+ * DB on cloud pods (fcntl locks are not shared across mount namespaces) —
  * so they go through this route.
  *
  * This route is intentionally NOT in the shared ROUTES array — it is a

package/src/live-voice/__tests__/live-activity-reporter.test.ts

@@ -1,7 +1,7 @@
 /**
  * Tests for the Live Activity phase reporter.
  *
- * The dispatch itself reaches the platform, so these cover the decisions made
+ * The dispatch itself reaches the cloud, so these cover the decisions made
  * before it: which frames move the phase, which repeats are suppressed, and
  * that ending is latched. The suppression is the load-bearing part —
  * `tts_audio` arrives many times a second and ActivityKit silently drops
@@ -258,7 +258,7 @@ describe("LiveActivityReporter", () => {
     });
   });
 
-  // A session can end more than one way and the platform deletes the
+  // A session can end more than one way and the cloud deletes the
   // registration on the first, so a second end would push at an activity that
   // is already gone.
   test("ending twice pushes once", async () => {

package/src/live-voice/__tests__/{live-voice-managed-speech-fallback.test.ts → live-voice-cloud-speech-fallback.test.ts}

@@ -1,10 +1,10 @@
 /**
- * Live voice on managed speech without a config write.
+ * Live voice on cloud speech without a config write.
  *
  * `/v1/live-voice` validates guardian identity only — it does not enforce the
  * caller's `settings.write` scope — so the WebSocket transport must never
  * persist `services.stt/tts.provider`. Instead every live-voice leg resolves
- * the EFFECTIVE providers: while managed speech is available, a configured
+ * the EFFECTIVE providers: while cloud speech is available, a configured
  * BYOK provider whose credential does not resolve is served by `"cadet"`.
  * These tests pin both halves of that contract — the readiness verdict and
  * the runtime legs agree, and `config.json` is byte-identical afterwards.
@@ -39,13 +39,13 @@ const realSttResolveModule = {
 const realSecureKeysModule = {
   ...(await import("../../security/secure-keys.js")),
 };
-const realManagedSpeechModule = {
-  ...(await import("../../platform/managed-speech.js")),
+const realCloudSpeechModule = {
+  ...(await import("../../cloud/cloud-speech.js")),
 };
 
 // -- Mutable stub state -------------------------------------------------------
 
-/** Whether the platform connection can serve managed speech. */
+/** Whether the cloud connection can serve cloud speech. */
 let managedAvailable = false;
 /** Credential-store keys that resolve to a value. */
 let providerKeys: Record<string, string>;
@@ -89,16 +89,16 @@ mock.module("../../security/secure-keys.js", () => ({
       : realSecureKeysModule.getSecureKeyAsync(account),
 }));
 
-mock.module("../../platform/managed-speech.js", () => ({
-  ...realManagedSpeechModule,
+mock.module("../../cloud/cloud-speech.js", () => ({
+  ...realCloudSpeechModule,
   managedSpeechAvailable: async () =>
     fallbackMocksActive
       ? managedAvailable
-      : realManagedSpeechModule.managedSpeechAvailable(),
+      : realCloudSpeechModule.managedSpeechAvailable(),
 }));
 
+import { resolveEffectiveSpeechProviders } from "../../config/cloud-speech-defaults.js";
 import { getConfig, invalidateConfigCache } from "../../config/loader.js";
-import { resolveEffectiveSpeechProviders } from "../../config/managed-speech-defaults.js";
 import {
   _resetTtsProviderOverridesForTests,
   _setTtsProviderForTests,
@@ -134,7 +134,7 @@ function readConfigFile(): string {
   return readFileSync(CONFIG_PATH, "utf8");
 }
 
-/** A streaming TTS adapter standing in for the managed `cadet` provider. */
+/** A streaming TTS adapter standing in for the cloud `cadet` provider. */
 function registerManagedTtsProvider(): TtsProvider {
   const provider: TtsProvider = {
     id: "cadet",
@@ -173,8 +173,8 @@ beforeEach(() => {
   requestedSttProviders = [];
 });
 
-describe("live voice on managed speech", () => {
-  test("unkeyed BYOK TTS resolves the managed provider and reports ready", async () => {
+describe("live voice on cloud speech", () => {
+  test("unkeyed BYOK TTS resolves the cloud provider and reports ready", async () => {
     managedAvailable = true;
     providerKeys = { deepgram: "test-key" };
     const configBefore = readConfigFile();
@@ -188,7 +188,7 @@ describe("live voice on managed speech", () => {
     expect(readConfigFile()).toBe(configBefore);
   });
 
-  test("synthesis runs on the managed provider while the config still names the BYOK one", async () => {
+  test("synthesis runs on the cloud provider while the config still names the BYOK one", async () => {
     managedAvailable = true;
     providerKeys = { deepgram: "test-key" };
     registerManagedTtsProvider();
@@ -209,7 +209,7 @@ describe("live voice on managed speech", () => {
     expect(readConfigFile()).toBe(configBefore);
   });
 
-  test("unkeyed BYOK STT resolves the managed provider and reports ready", async () => {
+  test("unkeyed BYOK STT resolves the cloud provider and reports ready", async () => {
     managedAvailable = true;
     providerKeys = { elevenlabs: "test-key" };
     const configBefore = readConfigFile();
@@ -228,7 +228,7 @@ describe("live voice on managed speech", () => {
     expect(readConfigFile()).toBe(configBefore);
   });
 
-  test("managed speech unavailable keeps the configured providers and reports not-ready", async () => {
+  test("cloud speech unavailable keeps the configured providers and reports not-ready", async () => {
     managedAvailable = false;
     const configBefore = readConfigFile();
 

package/src/live-voice/__tests__/live-voice-credential-preflight.test.ts

@@ -40,8 +40,8 @@ const realSttResolveModule = {
 const realSecureKeysModule = {
   ...(await import("../../security/secure-keys.js")),
 };
-const realManagedSpeechModule = {
-  ...(await import("../../platform/managed-speech.js")),
+const realCloudSpeechModule = {
+  ...(await import("../../cloud/cloud-speech.js")),
 };
 
 // -- Mutable stub state --------------------------------------------------------
@@ -76,12 +76,12 @@ mock.module("../../security/secure-keys.js", () => ({
 
 let managedAvailable = false;
 
-mock.module("../../platform/managed-speech.js", () => ({
-  ...realManagedSpeechModule,
+mock.module("../../cloud/cloud-speech.js", () => ({
+  ...realCloudSpeechModule,
   managedSpeechAvailable: async () =>
     preflightMocksActive
       ? managedAvailable
-      : realManagedSpeechModule.managedSpeechAvailable(),
+      : realCloudSpeechModule.managedSpeechAvailable(),
 }));
 
 import { setConfig } from "../../__tests__/helpers/set-config.js";
@@ -295,7 +295,7 @@ describe("resolveLiveVoiceCredentialReadiness — managed (cadet) TTS", () => {
     expect(readiness).toEqual({ status: "ready" });
   });
 
-  test("cadet TTS without a platform connection → connection copy, not API-key copy", async () => {
+  test("cadet TTS without a cloud connection → connection copy, not API-key copy", async () => {
     ttsProvider = "cadet";
     ttsProviders = {};
     managedAvailable = false;
@@ -306,7 +306,7 @@ describe("resolveLiveVoiceCredentialReadiness — managed (cadet) TTS", () => {
         kind: "tts",
         providerId: "cadet",
         reason:
-          'TTS provider "cadet" needs a Cadet Cloud connection for managed speech',
+          'TTS provider "cadet" needs a Cadet Cloud connection for cloud speech',
       },
     ]);
     expect(readiness.userMessage).toContain("assistant cloud connect");

package/src/live-voice/__tests__/live-voice-stt.test.ts

@@ -1593,7 +1593,7 @@ describe("LiveVoiceSession STT", () => {
   });
 
   test("the pin gate follows the dialed provider, not the configured one", async () => {
-    // A BYOK gemini config without credentials silently dials the managed
+    // A BYOK gemini config without credentials silently dials the cloud
     // cadet transcriber, which DOES honor the pin; the gate must follow
     // what was dialed, not what was configured.
     const originalRaw = loadRawConfig();