@mycadet/assistant 0.12.7 → 0.12.8

package/src/email/registered-inbox.ts

@@ -1,10 +1,10 @@
 /**
- * The one place that answers "does this assistant have a managed inbox?".
+ * The one place that answers "does this assistant have a cloud inbox?".
  *
  * Managed email registration lives on Cadet Cloud: the
  * `/v1/assistants/:id/email-addresses/` API is the only writer and the only
  * source of truth. Nothing about a registration lands in workspace config, so
- * any reader that wants the inbox address has to ask the platform. Every
+ * any reader that wants the inbox address has to ask the cloud. Every
  * consumer of the listing (the email readiness probe, the email invite
  * adapter, the channel-availability route, the email management routes, and
  * verification email delivery) reads through this module so they cannot
@@ -18,19 +18,19 @@
 
 import { z } from "zod";
 
-import { CadetPlatformClient } from "../platform/client.js";
+import { CadetCloudClient } from "../cloud/client.js";
 
 export type RegisteredInboxState =
-  /** The platform holds a registered inbox address for this assistant. */
+  /** The cloud holds a registered inbox address for this assistant. */
   | { status: "registered"; address: string }
-  /** The platform answered: no inbox is registered. */
+  /** The cloud answered: no inbox is registered. */
   | { status: "none" }
   /** No cloud credentials, so no managed inbox can exist. */
   | { status: "no_platform" }
-  /** The platform could not be asked; nothing is known either way. */
+  /** The cloud could not be asked; nothing is known either way. */
   | { status: "unavailable"; detail: string };
 
-/** One row of the platform's email-address listing. */
+/** One row of the cloud's email-address listing. */
 export interface RegisteredEmailAddress {
   id: string;
   address: string;
@@ -38,25 +38,25 @@ export interface RegisteredEmailAddress {
 
 export type EmailAddressListResult =
   | { ok: true; addresses: RegisteredEmailAddress[] }
-  /** The platform could not be asked or answered unusably. */
+  /** The cloud could not be asked or answered unusably. */
   | { ok: false; status?: number; detail: string };
 
 /**
  * Validated rather than cast: the response crosses a runtime boundary, and a
  * shape drift should read as a failed listing (nothing established), not as a
- * confidently wrong answer. Unknown keys are ignored, since the platform adds
+ * confidently wrong answer. Unknown keys are ignored, since the cloud adds
  * fields over time.
  */
 const EmailAddressListSchema = z.object({
   count: z.number().optional(),
-  // Required: the platform's paginated listing always carries `results`, so
+  // Required: the cloud's paginated listing always carries `results`, so
   // a 200 without it is shape drift and must read as a failed listing, never
   // as "no inbox".
   results: z.array(z.object({ id: z.string(), address: z.string() })),
 });
 
 /**
- * Fetch the platform's email-address listing for the caller's own client.
+ * Fetch the cloud's email-address listing for the caller's own client.
  *
  * The seam every consumer of the listing shares: the readiness resolver
  * below, the email register/unregister/status/send routes, and verification
@@ -65,12 +65,12 @@ const EmailAddressListSchema = z.object({
  * missing cloud connection) keeps its own error semantics.
  */
 export async function listEmailAddresses(
-  client: CadetPlatformClient,
+  client: CadetCloudClient,
 ): Promise<EmailAddressListResult> {
   let response: Response;
   try {
     response = await client.fetch(
-      `/v1/assistants/${client.platformAssistantId}/email-addresses/`,
+      `/v1/assistants/${client.cloudAssistantId}/email-addresses/`,
     );
   } catch (err) {
     const detail = err instanceof Error ? err.message : String(err);
@@ -108,7 +108,7 @@ export async function listEmailAddresses(
 /**
  * Matches the readiness service's remote-check TTL: the cache exists so the
  * invite-adapter enrichment on the readiness poll (every 15s per client) does
- * not turn into a platform request per poll, and registration changes made
+ * not turn into a cloud request per poll, and registration changes made
  * through the daemon invalidate it explicitly.
  */
 const CACHE_TTL_MS = 5 * 60 * 1000;
@@ -121,9 +121,9 @@ export function invalidateRegisteredInboxCache(): void {
 }
 
 /**
- * Resolve the managed inbox state, serving a cached answer within
+ * Resolve the cloud inbox state, serving a cached answer within
  * {@link CACHE_TTL_MS} unless `fresh` demands a live read. `unavailable` is
- * never cached: a platform blip should heal on the next call, not pin the
+ * never cached: a cloud blip should heal on the next call, not pin the
  * unknown state for the TTL.
  */
 export async function resolveRegisteredInbox(
@@ -142,17 +142,17 @@ export async function resolveRegisteredInbox(
 }
 
 async function fetchRegisteredInbox(): Promise<RegisteredInboxState> {
-  // Creation resolves the managed-proxy context and the credential store,
+  // Creation resolves the cloud-proxy context and the credential store,
   // either of which can reject; a backend blip there is "could not ask",
   // not an error the caller should surface as a failed request.
-  let client: CadetPlatformClient | null;
+  let client: CadetCloudClient | null;
   try {
-    client = await CadetPlatformClient.create();
+    client = await CadetCloudClient.create();
   } catch (err) {
     const detail = err instanceof Error ? err.message : String(err);
     return { status: "unavailable", detail };
   }
-  if (!client?.platformAssistantId) {
+  if (!client?.cloudAssistantId) {
     return { status: "no_platform" };
   }
 

package/src/heartbeat/heartbeat-service.ts

@@ -236,7 +236,7 @@ export class HeartbeatService {
     return countCompletedRunsToday() >= config.maxDailyRuns;
   }
 
-  async runManagedWakeIfDue(
+  async runCloudWakeIfDue(
     options: ManagedWakeHeartbeatRunOptions = {},
   ): Promise<ManagedWakeHeartbeatRunResult> {
     const now = options.now ?? Date.now();

package/src/hooks/hook-loader.ts

@@ -343,14 +343,14 @@ export async function runInitHook(
 const SHUTDOWN_TIMEOUT_MS = 5_000;
 
 /**
- * Run one owner's `shutdown` — the targeted single-owner teardown for a managed
+ * Run one owner's `shutdown` — the targeted single-owner teardown for a cloud
  * uninstall, disable, or reload (the whole-chain `runHook(HOOKS.SHUTDOWN)` at
  * process exit runs *every* owner's; this runs exactly one). Resolves it through
  * the same {@link resolveHook} the dispatch path uses — cache or disk, so it
  * needs nothing pre-warmed and works in any process (a `shutdown` hook must not
  * assume it shares a process with its `init`; see {@link ShutdownContext}) —
  * then invokes it under the shared {@link withTimeout} so a hook that hangs
- * can't block teardown (e.g. the `rmSync` a managed uninstall runs next). No-op
+ * can't block teardown (e.g. the `rmSync` a cloud uninstall runs next). No-op
  * when the owner defines no `shutdown`. Best-effort: a thrown, timed-out, or
  * malformed shutdown is logged and swallowed.
  */

package/src/inbound/__tests__/oauth-callback-url.test.ts

@@ -15,7 +15,7 @@ const resolveCallbackUrl = mock(
   async () => "https://ingress.example/webhooks/oauth/callback",
 );
 
-mock.module("../platform-callback-registration.js", () => ({
+mock.module("../cloud-callback-registration.js", () => ({
   resolveCallbackUrl,
 }));
 
@@ -86,7 +86,7 @@ describe("resolveOauthCallbackUrl", () => {
     expect(typeA).toEqual(typeB);
   });
 
-  test("registers one route type so the platform holds a single admin row", async () => {
+  test("registers one route type so the cloud holds a single admin row", async () => {
     await resolveOauthCallbackUrl();
     const [, , type] = resolveCallbackUrl.mock.calls[0] as unknown[];
     expect(type).toEqual("oauth");

package/src/inbound/__tests__/tunnel-probe.test.ts

@@ -21,8 +21,8 @@ import { probeTunnel } from "../tunnel-probe.js";
 
 const BASE = "https://edge.example";
 
-/** The marker the nginx pairing edge stamps into every config it serves. */
-const PAIRING_EDGE_MODE = "remote-gateway";
+/** The remote value the nginx pairing edge stamps into every config it serves. */
+const PAIRING_EDGE_REMOTE = "docker";
 
 type Route = { status?: number; body?: string; reject?: unknown };
 
@@ -68,7 +68,7 @@ function stubFetch(routes: { healthz?: Route; config?: Route }): {
     const route = isHealth
       ? (routes.healthz ?? { body: "ok" })
       : (routes.config ?? {
-          body: JSON.stringify({ mode: PAIRING_EDGE_MODE }),
+          body: JSON.stringify({ remote: PAIRING_EDGE_REMOTE }),
         });
     if (route.reject !== undefined) {
       throw route.reject;
@@ -85,7 +85,7 @@ function stubFetch(routes: { healthz?: Route; config?: Route }): {
 function configBody(config: Record<string, unknown>): Route {
   return {
     status: 200,
-    body: JSON.stringify({ mode: PAIRING_EDGE_MODE, ...config }),
+    body: JSON.stringify({ remote: PAIRING_EDGE_REMOTE, ...config }),
   };
 }
 
@@ -226,10 +226,10 @@ describe("probeTunnel", () => {
       config: {
         status: 200,
         body: JSON.stringify({
-          mode: PAIRING_EDGE_MODE,
+          remote: PAIRING_EDGE_REMOTE,
           apiBaseUrl: "/v1",
-          platformDisabled: true,
-          disablePlatform: true,
+          cloudDisabled: true,
+          disableCloud: true,
           assistantName: "Ada",
           assistantId: "asst_1",
           hubUrl: "https://mycadet.ai",
@@ -437,7 +437,7 @@ describe("probeTunnel", () => {
           },
         },
         json: async (): Promise<unknown> => ({
-          mode: PAIRING_EDGE_MODE,
+          remote: PAIRING_EDGE_REMOTE,
           assistantId: "asst_1",
         }),
       } as unknown as Response),

package/src/inbound/{platform-callback-registration.ts → cloud-callback-registration.ts}

@@ -1,33 +1,30 @@
 /**
  * Platform callback route registration.
  *
- * Both platform-managed (IS_PLATFORM=true) and self-hosted assistants can
- * register callback routes with the platform so inbound provider webhooks
+ * Both cloud-managed (IS_CLOUD=true) and self-hosted assistants can
+ * register callback routes with the cloud so inbound provider webhooks
  * (Telegram, Twilio, email, OAuth) are forwarded correctly.
  *
- * Platform-managed assistants pick up context from environment variables.
+ * Cloud assistants pick up context from environment variables.
  * Self-hosted assistants use stored credentials (from `assistant cloud
  * connect` or the ensure-registration bootstrap).
  *
- * The platform endpoint is:
- *   POST {CADET_PLATFORM_URL}/v1/internal/gateway/callback-routes/register/
+ * The cloud endpoint is:
+ *   POST {CADET_CLOUD_URL}/v1/internal/gateway/callback-routes/register/
  *
  * It accepts { assistant_id, callback_path, type } and returns a stable
  * callback_url that external services should use. Self-hosted assistants
  * also send callback_base_url (configured or detected public ingress) so
- * the platform can register a route that points at this instance.
+ * the cloud can register a route that points at this instance.
  */
 
-import { getPlatformBaseUrl } from "../config/env.js";
-import { getIsPlatform } from "../config/env-registry.js";
+import { resolveCloudAssistantId } from "../config/cloud-identity.js";
+import { getCloudBaseUrl } from "../config/env.js";
+import { getIsCloud } from "../config/env-registry.js";
 import { getConfig } from "../config/loader.js";
-import { resolvePlatformAssistantId } from "../config/platform-identity.js";
 import { ipcRegisterWebhookRoute } from "../ipc/gateway-client.js";
 import { credentialKey } from "../security/credential-key.js";
-import {
-  getSecureKeyAsync,
-  getSecureKeyResultAsync,
-} from "../security/secure-keys.js";
+import { getSecureKeyResultAsync } from "../security/secure-keys.js";
 import { getLogger } from "../util/logger.js";
 import { resolveClaimedPodWebhookUrl } from "./pod-webhook-claim.js";
 import {
@@ -36,14 +33,14 @@ import {
 } from "./public-ingress-urls.js";
 import { isTunnelWebhooksEnabled } from "./tunnel-webhooks-gate.js";
 
-const log = getLogger("platform-callback-registration");
+const log = getLogger("cloud-callback-registration");
 
-export interface PlatformCallbackRegistrationContext {
+export interface CloudCallbackRegistrationContext {
   isPlatform: boolean;
-  platformBaseUrl: string;
+  cloudBaseUrl: string;
   assistantId: string;
   /**
-   * Whether a managed assistant API key is available: `null` when the
+   * Whether a cloud assistant API key is available: `null` when the
    * credential store could not be read, so its absence is not evidence that
    * no key is stored. A client deciding whether to provision one must not
    * read `null` as "missing".
@@ -53,20 +50,14 @@ export interface PlatformCallbackRegistrationContext {
   enabled: boolean;
 }
 
-export async function resolvePlatformCallbackRegistrationContext(): Promise<PlatformCallbackRegistrationContext> {
-  const platform = getIsPlatform();
-  const [storedBaseUrlRaw, storedAssistantApiKey, assistantId] =
-    await Promise.all([
-      getSecureKeyAsync(credentialKey("cadet", "platform_base_url")),
-      getSecureKeyResultAsync(credentialKey("cadet", "assistant_api_key")),
-      resolvePlatformAssistantId(),
-    ]);
+export async function resolveCloudCallbackRegistrationContext(): Promise<CloudCallbackRegistrationContext> {
+  const platform = getIsCloud();
+  const [storedAssistantApiKey, assistantId] = await Promise.all([
+    getSecureKeyResultAsync(credentialKey("cadet", "assistant_api_key")),
+    resolveCloudAssistantId(),
+  ]);
 
-  const storedBaseUrl = storedBaseUrlRaw?.trim();
-  const platformBaseUrl = (storedBaseUrl || getPlatformBaseUrl()).replace(
-    /\/+$/,
-    "",
-  );
+  const cloudBaseUrl = getCloudBaseUrl().replace(/\/+$/, "");
   const envAssistantCredential = process.env.ASSISTANT_API_KEY?.trim();
   const assistantCredential =
     storedAssistantApiKey.value?.trim() || envAssistantCredential || undefined;
@@ -80,17 +71,15 @@ export async function resolvePlatformCallbackRegistrationContext(): Promise<Plat
 
   return {
     isPlatform: platform,
-    platformBaseUrl,
+    cloudBaseUrl,
     assistantId,
     hasAssistantApiKey,
     authHeader,
     // Enabled when we have enough context to register callback routes.
-    // Does NOT require IS_PLATFORM — self-hosted assistants with stored
+    // Does NOT require IS_CLOUD — self-hosted assistants with stored
     // credentials can also register routes.
     enabled:
-      platformBaseUrl.length > 0 &&
-      assistantId.length > 0 &&
-      authHeader !== null,
+      cloudBaseUrl.length > 0 && assistantId.length > 0 && authHeader !== null,
   };
 }
 
@@ -102,34 +91,34 @@ interface RegisterCallbackRouteResponse {
 }
 
 /**
- * Register a callback route with the platform's internal gateway endpoint.
+ * Register a callback route with the cloud's internal gateway endpoint.
  *
  * @param callbackPath - The path portion after the ingress base URL
  *   (e.g. "webhooks/twilio/voice"). Leading/trailing slashes are stripped
- *   by the platform.
+ *   by the cloud.
  * @param type - The route type identifier (e.g. "twilio_voice",
  *   "twilio_status", "oauth", "telegram").
  * @param sourceIdentifier - Optional human-readable source identifier
  *   (e.g. bot handle, phone number) for display in admin UI.
- * @returns The platform-provided callback URL that external services should use.
- * @throws If the platform request fails.
+ * @returns The cloud-provided callback URL that external services should use.
+ * @throws If the cloud request fails.
  */
 export async function registerCallbackRoute(
   callbackPath: string,
   type: string,
   sourceIdentifier?: string,
 ): Promise<string> {
-  const context = await resolvePlatformCallbackRegistrationContext();
+  const context = await resolveCloudCallbackRegistrationContext();
   if (!context.enabled || !context.authHeader) {
     throw new Error(
       "Platform callbacks not available — missing platform registration context",
     );
   }
 
-  const platformBaseUrl = context.platformBaseUrl;
+  const cloudBaseUrl = context.cloudBaseUrl;
   const assistantId = context.assistantId;
 
-  const url = `${platformBaseUrl}/v1/internal/gateway/callback-routes/register/`;
+  const url = `${cloudBaseUrl}/v1/internal/gateway/callback-routes/register/`;
 
   const headers: Record<string, string> = {
     "Content-Type": "application/json",
@@ -178,11 +167,11 @@ export async function registerCallbackRoute(
 
 /**
  * Self-hosted assistants must send the public ingress URL when registering
- * with the platform. Platform pods omit it: Django ignores client-provided
- * bases and always uses the platform callback URL.
+ * with the cloud. Cloud pods omit it: Django ignores client-provided
+ * bases and always uses the cloud callback URL.
  */
 function resolveSelfHostedCallbackBaseUrl(): string | undefined {
-  if (getIsPlatform()) {
+  if (getIsCloud()) {
     return undefined;
   }
   try {
@@ -217,14 +206,14 @@ export async function registerLocalWebhookRoute(
   if (!result.ok) {
     log.warn(
       { path, type, reason: result.reason },
-      "Gateway webhook route registration failed, falling back to the platform",
+      "Gateway webhook route registration failed, falling back to the cloud",
     );
     return false;
   }
   if (result.disabled) {
     log.info(
       { path, type },
-      "Gateway is not serving its own webhooks, falling back to the platform",
+      "Gateway is not serving its own webhooks, falling back to the cloud",
     );
     return false;
   }
@@ -234,14 +223,14 @@ export async function registerLocalWebhookRoute(
 }
 
 /**
- * Resolve a callback URL, registering with the platform when appropriate.
+ * Resolve a callback URL, registering with the cloud when appropriate.
  *
  * Resolution order, matching `handleWebhooksRegister` in
  * `runtime/routes/webhook-routes.ts` and `hasWebhookRoutingConfigured` in
  * `config/webhook-routing.ts`:
  *
- *   1. **Platform pods** (`IS_PLATFORM`) with the `tunnel-webhooks` flag off
- *      always register with the platform gateway. With the flag on, they try
+ *   1. **Cloud pods** (`IS_CLOUD`) with the `tunnel-webhooks` flag off
+ *      always register with the cloud gateway. With the flag on, they try
  *      the direct supplier first — the gateway's Tunnel client publishes the
  *      tunnel URL into `ingress.publicBaseUrl` — and fall back to platform
  *      registration on any failure, including an explicit
@@ -254,21 +243,21 @@ export async function registerLocalWebhookRoute(
  *   3. **Platform-connected assistants with no ingress** register with the
  *      platform gateway rather than surfacing the direct builder's error.
  *      Connectivity is decided by credentials (platform base URL + assistant
- *      ID + assistant API key), not by `IS_PLATFORM`, which is only ever true
- *      on a platform pod.
+ *      ID + assistant API key), not by `IS_CLOUD`, which is only ever true
+ *      on a cloud pod.
  *
  * Off a pod, an explicit `ingress.enabled: false` is a decision not to accept
  * inbound webhooks at all, so `PublicIngressDisabledError` propagates instead
- * of being routed around. Ingress precedes the platform fallback because any
+ * of being routed around. Ingress precedes the cloud fallback because any
  * logged-in local assistant holds cloud credentials for the LLM proxy:
  * treating credential presence as "managed" would silently reroute an
- * explicitly configured self-hosted callback through the platform.
+ * explicitly configured self-hosted callback through the cloud.
  *
  * The `directUrl` parameter is a **lazy supplier** (a function returning a
  * string) rather than an eagerly-evaluated string. This is critical because
  * the direct URL builders (e.g. `getTwilioVoiceWebhookUrl`) call
  * `getPublicBaseUrl()` which throws when no public ingress URL is configured.
- * On a platform pod the direct URL is never needed, and deferring evaluation
+ * On a cloud pod the direct URL is never needed, and deferring evaluation
  * avoids the throw.
  *
  * @param directUrl - Lazy supplier for the direct callback URL.
@@ -285,7 +274,7 @@ export async function resolveCallbackUrl(
   queryParams?: Record<string, string>,
   sourceIdentifier?: string,
 ): Promise<string> {
-  if (getIsPlatform()) {
+  if (getIsCloud()) {
     if (isTunnelWebhooksEnabled()) {
       const claimed = await resolveClaimedPodWebhookUrl(directUrl, () =>
         registerLocalWebhookRoute(callbackPath, type, sourceIdentifier),
@@ -310,10 +299,10 @@ export async function resolveCallbackUrl(
       return ingressUrl;
     }
 
-    // No ingress configured. Fall back to the platform gateway when this
-    // assistant is connected to the platform. Platform pods always are, so
+    // No ingress configured. Fall back to the cloud gateway when this
+    // assistant is connected to the cloud. Cloud pods always are, so
     // they skip the context probe and register directly.
-    const context = await resolvePlatformCallbackRegistrationContext();
+    const context = await resolveCloudCallbackRegistrationContext();
     if (!context.enabled) {
       throw ingressError;
     }
@@ -330,7 +319,7 @@ export async function resolveCallbackUrl(
   } catch (err) {
     // Registration is only attempted once the local ingress has been ruled
     // out, so there is nothing left to fall back to. Surface a clear error so
-    // callers (and the user) understand this is a platform-side issue, not a
+    // callers (and the user) understand this is a cloud-side issue, not a
     // tunnel problem.
     const detail = err instanceof Error ? err.message : String(err);
     throw new Error(

package/src/inbound/oauth-callback-url.ts

@@ -9,7 +9,7 @@
  * caller needs a listener of its own.
  *
  * Which base URL is correct depends on how the assistant is reachable: a
- * platform pod and a platform-connected assistant are served through a
+ * platform pod and a cloud-connected assistant are served through a
  * managed callback route, a self-hosted deployment through its configured
  * public ingress. `resolveCallbackUrl` owns that decision, and this is the
  * OAuth-shaped entry point to it, mirroring `plugin-api/webhook-url.ts`
@@ -17,7 +17,7 @@
  */
 
 import { loadConfig } from "../config/loader.js";
-import { resolveCallbackUrl } from "./platform-callback-registration.js";
+import { resolveCallbackUrl } from "./cloud-callback-registration.js";
 import {
   getMcpOAuthClientMetadataUrl,
   getOAuthCallbackUrl,
@@ -33,9 +33,9 @@ import {
 export const OAUTH_CALLBACK_PATH = "webhooks/oauth/callback";
 
 /**
- * Registration type recorded with the platform.
+ * Registration type recorded with the cloud.
  *
- * The platform keys a callback route by `(path, type)`, and there is one
+ * The cloud keys a callback route by `(path, type)`, and there is one
  * OAuth route, so one type describes it. Registering the same path under
  * several types would produce duplicate admin rows pointing at the same
  * URL.
@@ -51,7 +51,7 @@ const OAUTH_REGISTRATION_TYPE = "oauth";
  * across attempts, which is what an exact-match `redirect_uri` check needs.
  *
  * @throws when no public ingress is configured and the assistant is not
- *   connected to the platform. There is no URL that would work in that
+ *   connected to the cloud. There is no URL that would work in that
  *   case, and returning a plausible one produces an authorization request
  *   whose callback silently never arrives.
  */
@@ -69,7 +69,7 @@ export async function resolveOauthCallbackUrl(): Promise<string> {
  *
  * A URL-based client id must be HTTPS, and its document must publish the exact
  * redirect URI used by the authorization request. The gateway document is
- * derived from public ingress, so a platform-relayed callback cannot use it.
+ * derived from public ingress, so a cloud-relayed callback cannot use it.
  * Returning undefined preserves Dynamic Client Registration as the SDK's
  * fallback in either case.
  */

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