@mycadet/assistant 0.12.7 → 0.12.8

package/src/providers/speech-to-text/provider-catalog.ts

@@ -504,10 +504,10 @@ export function supportsDiarization(id: SttProviderId): boolean {
  * than a stored API key.
  *
  * Derived from the catalog rather than a hand-kept id list: every check that
- * gates managed speech reads this, so adding a managed provider cannot leave
+ * gates cloud speech reads this, so adding a cloud provider cannot leave
  * one of them behind on a stale literal.
  */
-export function isManagedSttProvider(id: SttProviderId): boolean {
+export function isCloudSttProvider(id: SttProviderId): boolean {
   return CATALOG.get(id)?.credentialProvider === "cadet";
 }
 
@@ -653,7 +653,7 @@ export function listCredentialProviderNames(): readonly string[] {
   const seen = new Set<string>();
   const result: string[] = [];
   for (const entry of CATALOG.values()) {
-    // Connection-based providers (cadet) authenticate via the platform
+    // Connection-based providers (cadet) authenticate via the cloud
     // connection, not a stored API key — offering them on the generic
     // key routes would accept a key that never enables anything.
     if (entry.setupMode !== "api-key") {

package/src/providers/speech-to-text/resolve.ts

@@ -13,7 +13,7 @@ import {
   batchBoundaryGapReason,
   getCredentialProvider,
   getProviderEntry,
-  isManagedSttProvider,
+  isCloudSttProvider,
   resolveSttCatalogKey,
   supportsBoundary,
   supportsDiarization,
@@ -27,7 +27,7 @@ const log = getLogger("stt-resolver");
 
 /**
  * Providers that decode language-less audio as English rather than detecting
- * the spoken language: Deepgram directly, and the managed relay, which dials
+ * the spoken language: Deepgram directly, and the cloud relay, which dials
  * Deepgram server-side. For these, an unset `services.stt.language` is not a
  * neutral state: it is a silent English pin that returns non-English speech
  * as English-sounding nonsense.
@@ -38,7 +38,7 @@ const log = getLogger("stt-resolver");
 const MULTILINGUAL_DEFAULT_PROVIDERS: ReadonlySet<SttProviderId> = new Set([
   "deepgram",
   "cadet",
-  // Managed Flux resolves an absent language to `flux-general-en` relay-side,
+  // Cloud Flux resolves an absent language to `flux-general-en` relay-side,
   // so unset is an English pin here too. With "multi" the relay selects
   // `flux-general-multi` and lets Flux detect and code-switch.
   "cadet-flux",
@@ -157,10 +157,10 @@ export async function resolveBatchTranscriber(
   }
 
   if (provider === "cadet") {
-    // Managed batch rides the platform's speech proxy, which forwards the
+    // Managed batch rides the cloud's speech proxy, which forwards the
     // language to Deepgram server-side. A platform build predating that
     // field ignores it rather than failing, so the daemon can send one
-    // before the platform side deploys.
+    // before the cloud side deploys.
     return (await sttProviderKeyResolves("cadet"))
       ? createDaemonBatchTranscriber(null, "cadet", language)
       : null;
@@ -380,7 +380,7 @@ export interface ResolveStreamingTranscriberOptions {
   /**
    * Provider to resolve a transcriber for. Defaults to
    * `services.stt.provider`. Callers that derive the provider themselves
-   * (e.g. live voice, which runs on the managed-speech effective provider)
+   * (e.g. live voice, which runs on the cloud-speech effective provider)
    * pass it here so the resolved transcriber matches the provider their own
    * readiness check approved.
    */
@@ -421,7 +421,7 @@ export interface ResolveStreamingTranscriberOptions {
    * config for a single session.
    *
    * Leaving both unset does not reach the adapters as "no language": on
-   * Deepgram and the managed relay, where that would mean English rather
+   * Deepgram and the cloud relay, where that would mean English rather
    * than detection, {@link effectiveSttLanguage} fills in code-switching
    * first. See {@link CreateStreamingTranscriberOptions.language} for how
    * each adapter treats what it finally receives.
@@ -518,7 +518,7 @@ export async function resolveStreamingTranscriber(
   // Both managed entries authenticate with the cloud connection, not a
   // stored API key: there is no key to fetch, and readiness is whether the
   // connection resolves.
-  const managed = isManagedSttProvider(provider);
+  const managed = isCloudSttProvider(provider);
   const apiKey = managed
     ? null
     : await getProviderKeyAsync(credentialProviderName);
@@ -576,7 +576,7 @@ interface CreateStreamingTranscriberOptions {
   utteranceEndMs?: number;
   /**
    * Spoken language, forwarded to the adapters that accept one: Deepgram,
-   * xAI, and the managed relay (which passes it to Deepgram server-side).
+   * xAI, and the cloud relay (which passes it to Deepgram server-side).
    *
    * Gemini and Whisper take no language option (both auto-detect natively
    * from the audio), so this is silently ignored for them, matching how
@@ -586,7 +586,7 @@ interface CreateStreamingTranscriberOptions {
    * decode as English, so non-English speech comes back as English-sounding
    * nonsense rather than failing loudly. Any configured language pins
    * nova-3 on BYOK Deepgram (see `deepgramLanguageOptions`); `"multi"`
-   * selects nova-3's code-switching mode (the managed relay pins nova-3
+   * selects nova-3's code-switching mode (the cloud relay pins nova-3
    * server-side).
    */
   language?: string;
@@ -657,19 +657,18 @@ async function createStreamingTranscriber(
       });
     }
     case "cadet": {
-      // Managed speech dials the GATEWAY's speech relay (tunnel contact is
+      // Cloud speech dials the GATEWAY's speech relay (tunnel contact is
       // gateway-only); the apiKey argument is unused. Diarization is
       // unsupported (not in the relay's param allowlist) and silently
       // ignored, matching Gemini/Whisper — as is utteranceEndMs (the relay
       // allowlist has no utterance_end_ms; boundary finals ride on
       // endpointing alone).
-      // The gateway is the credential authority, but the platform
+      // The gateway is the credential authority, but the cloud
       // connection (API key + assistant ID) is checkable locally — gate
       // here so preflight reports "connect your account" instead of
       // resolving a transcriber whose dial is doomed.
-      const { cadetManagedSpeechAvailable } =
-        await import("./cadet-managed.js");
-      if (!(await cadetManagedSpeechAvailable())) {
+      const { cadetCloudSpeechAvailable } = await import("./cadet-cloud.js");
+      if (!(await cadetCloudSpeechAvailable())) {
         return null;
       }
       const { resolveSpeechRelayConnection } =
@@ -679,12 +678,12 @@ async function createStreamingTranscriber(
         return null;
       }
       const { CadetManagedRealtimeTranscriber } =
-        await import("./cadet-managed-realtime.js");
+        await import("./cadet-cloud-realtime.js");
       return new CadetManagedRealtimeTranscriber(connection, {
         sampleRate: options.sampleRate,
         // `language` IS in the relay's param allowlist, and the relay pins
         // the STT model to nova-3 server-side, so "multi" code-switching
-        // needs nothing from the platform, only this forward. Source:
+        // needs nothing from the cloud, only this forward. Source:
         // mycadet-platform: tunnel/internal/tunnel/deepgram.go
         // (deepgramSTTParams allowlist; deepgramSTTModel pin).
         ...(options.language ? { language: options.language } : {}),
@@ -694,13 +693,12 @@ async function createStreamingTranscriber(
       });
     }
     case "cadet-flux": {
-      // Managed Flux: same relay as `cadet`, but the STT v2 endpoint with
+      // Cloud Flux: same relay as `cadet`, but the STT v2 endpoint with
       // `contract=flux` so the turn events arrive intact instead of being
       // translated into the released v1 Deepgram dialect. Gated on the local
       // cloud connection for the same reason as `cadet` above.
-      const { cadetManagedSpeechAvailable } =
-        await import("./cadet-managed.js");
-      if (!(await cadetManagedSpeechAvailable())) {
+      const { cadetCloudSpeechAvailable } = await import("./cadet-cloud.js");
+      if (!(await cadetCloudSpeechAvailable())) {
         return null;
       }
       // The relay maps the language onto a Flux model and refuses the dial
@@ -713,7 +711,7 @@ async function createStreamingTranscriber(
       if (managedFluxModelForLanguage(options.language) === null) {
         log.warn(
           { providerId, language: options.language },
-          "Managed Flux has no model for the configured language; refusing rather than transcribing it as another",
+          "Cloud Flux has no model for the configured language; refusing rather than transcribing it as another",
         );
         return null;
       }
@@ -724,7 +722,7 @@ async function createStreamingTranscriber(
         return null;
       }
       const { CadetManagedFluxRealtimeTranscriber } =
-        await import("./cadet-managed-flux-realtime.js");
+        await import("./cadet-cloud-flux-realtime.js");
       return new CadetManagedFluxRealtimeTranscriber(connection, {
         sampleRate: options.sampleRate,
         // The relay picks `flux-general-en` or `flux-general-multi` from
@@ -778,17 +776,17 @@ async function createStreamingTranscriber(
  */
 /**
  * Human-readable reason for a credential gap, aware that connection-based
- * providers (cadet) are fixed by connecting the platform account, not by
+ * providers (cadet) are fixed by connecting the cloud account, not by
  * entering an API key.
  */
 export function sttCredentialGapReason(credentialProviderName: string): string {
   // Called with either the catalog id ("cadet") or its credential-service
-  // key ("cadet", the persisted identity family) — both mean managed speech.
+  // key ("cadet", the persisted identity family) — both mean cloud speech.
   if (
     credentialProviderName === "cadet" ||
     credentialProviderName === "cadet"
   ) {
-    return "No Cadet Cloud connection for managed speech — run 'assistant cloud connect'";
+    return "No Cadet Cloud connection for cloud speech — run 'assistant cloud connect'";
   }
   return `No API key configured for credential provider "${credentialProviderName}"`;
 }
@@ -798,8 +796,8 @@ export async function sttProviderKeyResolves(
 ): Promise<boolean> {
   // cadet has no stored API key — the cloud connection is the credential.
   if (credentialProviderName === "cadet") {
-    const { cadetManagedSpeechAvailable } = await import("./cadet-managed.js");
-    return cadetManagedSpeechAvailable();
+    const { cadetCloudSpeechAvailable } = await import("./cadet-cloud.js");
+    return cadetCloudSpeechAvailable();
   }
   return (await getProviderKeyAsync(credentialProviderName)) !== undefined;
 }

package/src/providers/together/client.ts

@@ -9,7 +9,7 @@ export interface TogetherProviderOptions {
 const DEFAULT_TOGETHER_BASE_URL = "https://api.together.ai/v1";
 
 /**
- * Together AI exposes an OpenAI-compatible endpoint. Used as the managed route
+ * Together AI exposes an OpenAI-compatible endpoint. Used as the cloud route
  * for MiniMax M3. Together serializes object-typed tool args correctly, so —
  * unlike {@link FireworksProvider} — no `coerceObjectArgsToJsonString`
  * workaround is needed.

package/src/providers/types.ts

@@ -367,7 +367,7 @@ export interface SendMessageConfig {
    * True when the caller appended {@link NATIVE_WEB_SEARCH_TOOL_NAME} purely
    * to activate the route's provider-native web search, rather than passing an
    * app-executed search tool of the same name (which is what runs when a
-   * search backend like Brave or the platform search proxy is configured).
+   * search backend like Brave or the cloud search proxy is configured).
    * Only the caller can tell those apart, and a route change after that
    * decision has to: `RetryProvider` drops the tool on a backup that runs no
    * native search, and must not touch it when the daemon executes it itself.
@@ -406,9 +406,9 @@ export interface SendMessageConfig {
    */
   promptCacheKey?: string;
   /**
-   * Internal per-request HTTP headers for managed-proxy usage attribution.
+   * Internal per-request HTTP headers for cloud-proxy usage attribution.
    * Provider clients may pass these through SDK request options only when the
-   * transport is Cadet-managed, and must never include this object in provider
+   * transport is Cadet Cloud, and must never include this object in provider
    * JSON request bodies.
    */
   usageAttributionHeaders?: Record<string, string>;
@@ -578,7 +578,7 @@ export interface ContextOverflowErrorOptions {
  *
  * A regex-on-message fallback still exists in
  * `daemon/parse-actual-tokens-from-error.ts` as a safety net for adapters
- * that rewrap the error (e.g. managed-proxy) before it reaches the agent
+ * that rewrap the error (e.g. cloud-proxy) before it reaches the agent
  * loop.
  */
 export class ContextOverflowError extends ProviderError {

package/src/providers/voice-error-copy.ts

@@ -24,7 +24,7 @@ export function describeSttFailure(
   providerId?: SttProviderId,
 ): string {
   // Adapters that already produce user-facing, provider-appropriate copy
-  // (managed speech: reconnect the platform, top up Cadet credits) mark the
+  // (cloud speech: reconnect the cloud, top up Cadet credits) mark the
   // error so its remediation survives verbatim instead of being rewritten to
   // the BYOK "check your API key" copy — which is wrong for managed users, who
   // hold no speech-to-text key.

package/src/runtime/__tests__/desktop-stream-upgrade.test.ts

@@ -15,7 +15,7 @@ describe("RuntimeHttpServer /v1/desktop/stream upgrade", () => {
   let baseUrl: string;
   let restoreAuthEnv: () => void;
   const originalContainerized = process.env.IS_CONTAINERIZED;
-  const originalPlatform = process.env.IS_PLATFORM;
+  const originalPlatform = process.env.IS_CLOUD;
 
   beforeEach(async () => {
     restoreAuthEnv = requireHttpAuth();
@@ -23,7 +23,7 @@ describe("RuntimeHttpServer /v1/desktop/stream upgrade", () => {
     server = new RuntimeHttpServer({ port, hostname: "127.0.0.1" });
     await server.start();
     baseUrl = `127.0.0.1:${server.actualPort}`;
-    process.env.IS_PLATFORM = "true";
+    process.env.IS_CLOUD = "true";
   });
 
   afterEach(async () => {
@@ -35,9 +35,9 @@ describe("RuntimeHttpServer /v1/desktop/stream upgrade", () => {
       process.env.IS_CONTAINERIZED = originalContainerized;
     }
     if (originalPlatform === undefined) {
-      delete process.env.IS_PLATFORM;
+      delete process.env.IS_CLOUD;
     } else {
-      process.env.IS_PLATFORM = originalPlatform;
+      process.env.IS_CLOUD = originalPlatform;
     }
     setOverridesForTesting({});
   });
@@ -78,7 +78,7 @@ describe("RuntimeHttpServer /v1/desktop/stream upgrade", () => {
     const closed = await waitForClose(ws);
     expect(closed.code).toBe(4008);
     expect(closed.reason).toBe(
-      "Virtual desktop is available only on enabled platform-hosted assistants",
+      "Virtual desktop is available only on enabled cloud-hosted assistants",
     );
   });
   for (const flag of [false, undefined]) {
@@ -93,20 +93,20 @@ describe("RuntimeHttpServer /v1/desktop/stream upgrade", () => {
       const closed = await waitForClose(ws);
       expect(closed.code).toBe(4008);
       expect(closed.reason).toBe(
-        "Virtual desktop is available only on enabled platform-hosted assistants",
+        "Virtual desktop is available only on enabled cloud-hosted assistants",
       );
     });
   }
 });
 
 test("self-hosted containers cannot stream with the feature flag enabled", async () => {
-  const originalPlatform = process.env.IS_PLATFORM;
+  const originalPlatform = process.env.IS_CLOUD;
   const originalContainerized = process.env.IS_CONTAINERIZED;
   const restoreAuth = requireHttpAuth();
   const server = new RuntimeHttpServer({ port: 0, hostname: "127.0.0.1" });
   try {
     await server.start();
-    process.env.IS_PLATFORM = "false";
+    process.env.IS_CLOUD = "false";
     process.env.IS_CONTAINERIZED = "true";
     setOverridesForTesting({ "assistant-desktop": true });
     const baseUrl = `127.0.0.1:${server.actualPort}`;
@@ -118,9 +118,9 @@ test("self-hosted containers cannot stream with the feature flag enabled", async
     await server.stop();
     restoreAuth();
     if (originalPlatform === undefined) {
-      delete process.env.IS_PLATFORM;
+      delete process.env.IS_CLOUD;
     } else {
-      process.env.IS_PLATFORM = originalPlatform;
+      process.env.IS_CLOUD = originalPlatform;
     }
     if (originalContainerized === undefined) {
       delete process.env.IS_CONTAINERIZED;

package/src/runtime/agent-wake.ts

@@ -1301,7 +1301,7 @@ export async function wakeAgentForOpportunity(
       // `provider_error` fires at the provider-call site; `error` fires from
       // the loop's generic catch — check both so a rewrapping retry layer
       // can't hide the signal. The heuristic check also catches adapter
-      // paths (e.g. managed-proxy rewrappers) that surface the overflow as
+      // paths (e.g. cloud-proxy rewrappers) that surface the overflow as
       // an untyped error the typed `instanceof` check would miss.
       if (
         suppressAutoCompaction &&

package/src/runtime/auth/__tests__/middleware.test.ts

@@ -327,7 +327,7 @@ describe("authenticateRequest for /v1/host-browser-result", () => {
 
 // ---------------------------------------------------------------------------
 // Dev bypass covers only a request that supplied no Authorization header. A
-// bearer sent to a platform pod (the gateway's exchange token, or a trusted
+// bearer sent to a cloud pod (the gateway's exchange token, or a trusted
 // contact's) is verified on its own terms.
 // ---------------------------------------------------------------------------
 

package/src/runtime/auth/middleware.ts

@@ -17,7 +17,7 @@
  * Replaces both the legacy bearer shared-secret check and the
  * actor-token HMAC middleware with a single JWT verification path.
  *
- * When DISABLE_HTTP_AUTH is set (platform-managed deployments), a request
+ * When DISABLE_HTTP_AUTH is set (cloud-managed deployments), a request
  * carrying no bearer gets a synthetic AuthContext so downstream code always
  * has a typed context to consume. A request that carries one is verified
  * normally, and a bad token is refused rather than falling back.

package/src/runtime/auth/scopes.ts

@@ -54,7 +54,7 @@ const PROFILE_SCOPES: Record<ScopeProfile, ReadonlySet<Scope>> = {
   // route. `enforcePolicy` admits it only where the route's policy names
   // oauth.proxy, so a route naming no scope refuses it too.
   oauth_proxy_v1: new Set<Scope>(["oauth.proxy"]),
-  // Managed speech relay only (ATL-1033): the daemon's relay-dial token must
+  // Cloud speech relay only (ATL-1033): the daemon's relay-dial token must
   // not open any other edge-scoped route.
   speech_relay_v1: new Set<Scope>(["speech.relay"]),
   ui_page_v1: new Set<Scope>(["settings.read"]),

package/src/runtime/capabilities.ts

@@ -48,7 +48,7 @@ export type PromptTrustGuidance =
 export interface CapabilitySet {
   // --- Tool approval mechanism ---
   /**
-   * Auto-approves *ordinary* tool calls (e.g. background/platform-hosted bash)
+   * Auto-approves *ordinary* tool calls (e.g. background/cloud-hosted bash)
    * and honors the actor's own pending-confirmation callback. The
    * sensitive/guardian-required tool path is governed separately by
    * `sensitiveToolApproval`; the two are independent levers.

package/src/runtime/channel-invite-transports/discord.ts

@@ -4,7 +4,7 @@
  * Resolves the assistant's Discord bot username for use in invite
  * instructions. Discord invites use the universal 6-digit code path for
  * redemption, so this adapter only implements `resolveChannelHandle`,
- * no `buildShareLink` or `extractInboundToken` needed. The platform
+ * no `buildShareLink` or `extractInboundToken` needed. The cloud
  * constraint that shapes the instruction copy lives with the copy
  * (`invite-instruction-generator.ts`): a person can only DM the bot once
  * they share a server with it.

package/src/runtime/channel-invite-transports/email.ts

@@ -2,10 +2,10 @@
  * Email channel invite adapter.
  *
  * Resolves the assistant's email address for use in invite instructions.
- * The address is a managed inbox registration, which lives on the platform
+ * The address is a cloud inbox registration, which lives on the cloud
  * (nothing about one lands in workspace config), so it resolves through the
  * shared registered-inbox reader. Returns `undefined` when no address is
- * registered or the platform cannot be asked, which causes the invite
+ * registered or the cloud cannot be asked, which causes the invite
  * instruction generator to emit generic "on Email" wording.
  *
  * Email invites use the universal 6-digit code path for redemption, so

package/src/runtime/channel-readiness-service.ts

@@ -143,20 +143,22 @@ async function checkCredential(
 
 /** Check that public ingress is configured and enabled. */
 async function checkIngress(
-  allowManagedCallbacks = false,
+  allowCloudCallbacks = false,
   options: { twilio?: boolean } = {},
 ): Promise<ReadinessCheckResult> {
-  const { configured, usesManagedCallbacks } =
-    await hasWebhookRoutingConfigured(allowManagedCallbacks, options);
+  const { configured, usesCloudCallbacks } = await hasWebhookRoutingConfigured(
+    allowCloudCallbacks,
+    options,
+  );
   return check(
     "ingress",
     configured,
-    usesManagedCallbacks
+    usesCloudCallbacks
       ? "Managed platform callback routing is configured"
       : options.twilio
         ? "Twilio public ingress URL is configured"
         : "Public ingress URL is configured",
-    allowManagedCallbacks
+    allowCloudCallbacks
       ? options.twilio
         ? "No Twilio public ingress URL or managed callback route is configured"
         : "No public ingress URL or managed callback route is configured"
@@ -274,7 +276,7 @@ const emailProbe: ChannelProbe = {
       check(
         "platform_email",
         true,
-        "Email is handled through the platform (Mailgun)",
+        "Email is handled through the cloud (Mailgun)",
         "Email requires platform registration",
       ),
       check(
@@ -283,16 +285,16 @@ const emailProbe: ChannelProbe = {
         "Email invite code redemption is enabled",
         "Email invite code redemption is disabled",
       ),
-      // Managed callbacks allowed: inbound email arrives through the platform
+      // Managed callbacks allowed: inbound email arrives through the cloud
       // callback route the gateway registers (`registerEmailCallbackRoute`,
-      // the same pattern as Telegram's webhook route), so a platform-connected
+      // the same pattern as Telegram's webhook route), so a cloud-connected
       // deployment with no public ingress URL still receives email.
       await checkIngress(true),
     ];
   },
   /**
-   * Ask the platform whether an inbox address is registered, falling back to
-   * a "your own" provider credential. The platform's email-addresses API is
+   * Ask the cloud whether an inbox address is registered, falling back to
+   * a "your own" provider credential. The cloud's email-addresses API is
    * the only writer of managed inbox registrations (nothing about one lands
    * in workspace config), and a BYO deployment's configuration claim is its
    * stored provider API key, so those are the only sources this check may
@@ -305,7 +307,7 @@ const emailProbe: ChannelProbe = {
    */
   async runRemoteChecks(): Promise<ReadinessCheckResult[]> {
     // Imported here rather than at module scope, matching the other probes:
-    // the platform client pulls in a module graph that unrelated consumers of
+    // the cloud client pulls in a module graph that unrelated consumers of
     // this service should not have to mock.
     const { resolveRegisteredInbox } =
       await import("../email/registered-inbox.js");
@@ -357,7 +359,7 @@ const emailProbe: ChannelProbe = {
             name,
             passed: false,
             message:
-              "Email is not configured. Connect to Cadet Cloud for a managed inbox (assistant cloud connect), or configure your own provider",
+              "Email is not configured. Connect to Cadet Cloud for a cloud inbox (assistant cloud connect), or configure your own provider",
           },
         ];
       case "unavailable":
@@ -366,7 +368,7 @@ const emailProbe: ChannelProbe = {
             name,
             passed: true,
             indeterminate: true,
-            message: `Could not reach the platform to check inbox registration (${inbox.detail})`,
+            message: `Could not reach the cloud to check inbox registration (${inbox.detail})`,
           },
         ];
     }

package/src/runtime/channel-reply-session.test.ts

@@ -208,7 +208,7 @@ describe("channelCanStreamReply", () => {
 
 describe("createChannelReplySession", () => {
   test("a start the channel refuses falls back without streaming", async () => {
-    // Whether THIS conversation can carry a growing reply is the platform's
+    // Whether THIS conversation can carry a growing reply is the cloud's
     // rule, answered by the transport's own reply to `start`. Slack refusing
     // a turn with no thread, and Telegram refusing a chat that is not
     // private, both arrive here as the same not-ok.

package/src/runtime/channel-reply-session.ts

@@ -63,7 +63,7 @@ export type ChannelReplySession = {
  *
  * Only the channel-level half is answered here, and only by asking whether
  * the transport implements the operation: implementing it is the whole of
- * declaring it. Whether THIS conversation can carry one is the platform's
+ * declaring it. Whether THIS conversation can carry one is the cloud's
  * own rule (Slack streams into a thread, Telegram only into a private chat),
  * so it is answered by the transport's own reply to `start` and reaches this
  * module as an ordinary not-ok, which falls back exactly like a failure.

package/src/runtime/http-server.ts

@@ -24,7 +24,7 @@ import {
   getRuntimeHttpPort,
   isHttpAuthDisabled,
 } from "../config/env.js";
-import { getIsPlatform } from "../config/env-registry.js";
+import { getIsCloud } from "../config/env-registry.js";
 import { getConfig } from "../config/loader.js";
 import {
   getDbMigrationReadiness,
@@ -152,7 +152,7 @@ const PAGES_PATH_RE = /^\/pages\/[^/]+$/;
 function routerEndpointForPath(path: string): string | null {
   if (path.startsWith("/v1/")) {
     // Strip trailing slashes so routes match regardless of whether the caller
-    // includes one (e.g. platform proxy paths use Django's trailing-slash
+    // includes one (e.g. cloud proxy paths use Django's trailing-slash
     // convention, so the gateway may forward paths with a trailing /).
     return path.slice("/v1/".length).replace(/\/$/, "");
   }
@@ -455,7 +455,7 @@ export class RuntimeHttpServer {
             if (!virtualDesktopEnabled()) {
               ws.close(
                 DESKTOP_CLOSE.unavailable,
-                "Virtual desktop is available only on enabled platform-hosted assistants",
+                "Virtual desktop is available only on enabled cloud-hosted assistants",
               );
               return;
             }
@@ -647,7 +647,7 @@ export class RuntimeHttpServer {
     }
 
     if (isHttpAuthDisabled()) {
-      if (getIsPlatform()) {
+      if (getIsCloud()) {
         log.info(
           "DISABLE_HTTP_AUTH is set — HTTP auth disabled (expected: platform handles auth)",
         );

package/src/runtime/introduction-policy.ts

@@ -12,7 +12,7 @@
  *   | `block`            | revoked              | —                        |
  *
  * The verification handshake is a signal-driven exception, not the default:
- * which actions are offered (and which leads) is derived from the platform's
+ * which actions are offered (and which leads) is derived from the cloud's
  * own identity confidence — never from per-individual-contact rules.
  *
  * This module is the single source of truth for:
@@ -46,7 +46,7 @@ import type { ApprovalAction } from "./channel-approval-types.js";
  *
  * Each signal is tri-state: `true` / `false` are positive platform
  * resolutions (Slack `users.info` succeeded and said so); `undefined` means
- * the platform could not vouch either way (lookup failure, channel without
+ * the cloud could not vouch either way (lookup failure, channel without
  * workspace identity). Policy must treat `undefined` as NOT vouched.
  */
 export interface RequesterIdentitySignals {
@@ -135,7 +135,7 @@ export { VERIFIED_VIA_CHANNEL_CLAIM, VERIFIED_VIA_MANUAL };
 export type { BindingStrength };
 
 /**
- * Whether the platform itself vouches for the requester's identity inside the
+ * Whether the cloud itself vouches for the requester's identity inside the
  * guardian's workspace. Only Slack carries workspace identity today: a
  * non-stranger, non-restricted member (human or workspace app) is
  * authenticated by Slack. Every other channel is an inbound channel claim.
@@ -219,7 +219,7 @@ export function requesterCanCompleteHandshake(
  *
  * The handshake is the exception, not the default:
  * - never where it cannot complete (see {@link requesterCanCompleteHandshake});
- * - not for workspace-vouched identities — the platform already
+ * - not for workspace-vouched identities — the cloud already
  *   authenticated them;
  * - not on voice — a phone call has no text handshake path;
  * - offered everywhere else: it leads for identities nobody is vouching for.