@mycadet/assistant 0.12.7 → 0.12.8

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();

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

@@ -1,5 +1,5 @@
 /**
- * Reports a live-voice session's phase to the platform, which pushes it to the
+ * Reports a live-voice session's phase to the cloud, which pushes it to the
  * iOS Live Activity over APNs.
  *
  * ## Why the server reports a phase the client already knows
@@ -27,7 +27,7 @@
  * throw here would cost the conversation.
  */
 
-import { CadetPlatformClient } from "../platform/client.js";
+import { CadetCloudClient } from "../cloud/client.js";
 import { getLogger } from "../util/logger.js";
 import type { LiveVoiceServerFramePayload } from "./protocol.js";
 
@@ -188,7 +188,7 @@ export class LiveActivityReporter {
    * Retire the activity as the session ends.
    *
    * Latched, because a session can end more than one way — a clean hangup, a
-   * dropped socket, a process shutdown — and the platform deletes the
+   * dropped socket, a process shutdown — and the cloud deletes the
    * registration on the first one. Sending a second would push at an activity
    * that is already gone.
    */
@@ -234,7 +234,7 @@ export class LiveActivityReporter {
       }
       signal.addEventListener("abort", () => resolve(), { once: true });
     });
-    // Race the whole operation, including platform-client and credential
+    // Race the whole operation, including cloud-client and credential
     // resolution. The same signal reaches `fetch`, so a timed-out operation
     // that resolves credentials later cannot send its stale snapshot.
     void Promise.race([
@@ -284,12 +284,12 @@ export class LiveActivityReporter {
     signal: AbortSignal,
   ): Promise<void> {
     try {
-      const client = await CadetPlatformClient.create();
-      if (!client?.platformAssistantId) {
+      const client = await CadetCloudClient.create();
+      if (!client?.cloudAssistantId) {
         return;
       }
       const path = `/v1/assistants/${encodeURIComponent(
-        client.platformAssistantId,
+        client.cloudAssistantId,
       )}/live-activity/dispatch/`;
       const response = await client.fetch(path, {
         method: "POST",

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

@@ -21,8 +21,8 @@ import {
   fishAudioReferenceIdConfigured,
   ttsSecretResolves,
 } from "../calls/telephony-tts-capability.js";
-import { resolveEffectiveSpeechProviders } from "../config/managed-speech-defaults.js";
-import { managedSpeechAvailable } from "../platform/managed-speech.js";
+import { managedSpeechAvailable } from "../cloud/cloud-speech.js";
+import { resolveEffectiveSpeechProviders } from "../config/cloud-speech-defaults.js";
 import { getProviderEntry } from "../providers/speech-to-text/provider-catalog.js";
 import {
   resolveStreamingTranscriber,
@@ -144,7 +144,7 @@ async function resolveSttGap(
       },
       clause:
         entry.credentialProvider === "cadet"
-          ? `a Cadet Cloud connection for managed speech (run 'assistant cloud connect')`
+          ? `a Cadet Cloud connection for cloud speech (run 'assistant cloud connect')`
           : `an API key for the speech-to-text provider "${entry.id}"`,
     };
   }
@@ -197,7 +197,7 @@ async function resolveTtsGap(
     };
   }
 
-  // Managed speech authenticates via the cloud connection — full
+  // Cloud speech authenticates via the cloud connection — full
   // availability (API key + assistant ID) is the credential, so the
   // stored-secret loop below would pass half-connected states that
   // synthesis rejects.
@@ -207,9 +207,9 @@ async function resolveTtsGap(
         gap: {
           kind: "tts",
           providerId: entry.id,
-          reason: `TTS provider "${entry.id}" needs a Cadet Cloud connection for managed speech`,
+          reason: `TTS provider "${entry.id}" needs a Cadet Cloud connection for cloud speech`,
         },
-        clause: `a Cadet Cloud connection for managed speech (run 'assistant cloud connect')`,
+        clause: `a Cadet Cloud connection for cloud speech (run 'assistant cloud connect')`,
       };
     }
     return null;

package/src/live-voice/live-voice-session.ts

@@ -392,7 +392,7 @@ export interface LiveVoiceSessionOptions {
   metricsClock?: VoiceMetricsClock;
   /**
    * Mirrors phase changes to the iOS Live Activity. Injectable so tests can
-   * assert what a session reports without reaching the platform.
+   * assert what a session reports without reaching the cloud.
    */
   liveActivityReporter?: LiveActivityReporter;
   createTurnId?: () => string;
@@ -1223,7 +1223,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   // that can point at the screen. Cleared when the share ends.
   private shareTargets: ShareTargetSnapshot | null = null;
   /**
-   * Mirrors phase changes to the iOS Live Activity through the platform, for
+   * Mirrors phase changes to the iOS Live Activity through the cloud, for
    * the case the client cannot cover: an app backgrounded long enough for iOS
    * to suspend the web layer that would otherwise push them.
    */
@@ -8326,7 +8326,7 @@ async function defaultResolveStreamingTranscriber(
   options: ResolveStreamingTranscriberOptions,
 ): Promise<StreamingTranscriber | null> {
   const { resolveEffectiveSpeechProviders } =
-    await import("../config/managed-speech-defaults.js");
+    await import("../config/cloud-speech-defaults.js");
   const { resolveStreamingTranscriber } =
     await import("../providers/speech-to-text/resolve.js");
   const { stt } = await resolveEffectiveSpeechProviders(undefined, {

package/src/live-voice/live-voice-tts.ts

@@ -221,7 +221,7 @@ async function resolveLiveVoiceStreamingTtsProvider(
 ): Promise<ResolvedStreamingTtsProvider> {
   const config = configOverride ?? (await loadAssistantConfig());
   const { resolveEffectiveSpeechProviders } =
-    await import("../config/managed-speech-defaults.js");
+    await import("../config/cloud-speech-defaults.js");
   const { tts: effectiveProviderId } =
     await resolveEffectiveSpeechProviders(config);
   const { provider: providerId, providerConfig } = resolveTtsConfig(

package/src/mcp/__tests__/mcp-oauth-client-registration.test.ts

@@ -24,7 +24,7 @@ const CLIENT_METADATA_URL = `${PUBLIC_BASE_URL}/oauth/client-metadata.json`;
 let resolvedCallbackUrl = CALLBACK_URL;
 let publicBaseUrl: string | undefined = PUBLIC_BASE_URL;
 
-mock.module("../../inbound/platform-callback-registration.js", () => ({
+mock.module("../../inbound/cloud-callback-registration.js", () => ({
   resolveCallbackUrl: async () => resolvedCallbackUrl,
 }));
 
@@ -45,8 +45,8 @@ mock.module("../../daemon/identity-helpers.js", () => ({
   getAssistantName: () => "Jarvis",
 }));
 
-import { setPlatformAssistantId } from "../../config/env.js";
-setPlatformAssistantId("019d6d4f-6dbd-779f-91d3-cb273b9429a5");
+import { setCloudAssistantId } from "../../config/env.js";
+setCloudAssistantId("019d6d4f-6dbd-779f-91d3-cb273b9429a5");
 
 const { McpOAuthProvider } = await import("../mcp-oauth-provider.js");
 
@@ -247,7 +247,7 @@ describe("McpOAuthProvider client metadata", () => {
     expect(provider.clientMetadataUrl).toBe(CLIENT_METADATA_URL);
   });
 
-  test("preserves DCR fallback for a platform-relayed callback", async () => {
+  test("preserves DCR fallback for a cloud-relayed callback", async () => {
     const provider = newProvider();
 
     await provider.startCallbackServer();