@vellumai/assistant 0.7.1 → 0.7.3

package/src/runtime/auth/route-policy.ts

@@ -151,8 +151,11 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "confirm", scopes: ["approval.write"] },
   { endpoint: "secret", scopes: ["approval.write"] },
   { endpoint: "trust-rules", scopes: ["approval.write"] },
+  { endpoint: "host-app-control-result", scopes: ["approval.write"] },
   { endpoint: "host-bash-result", scopes: ["approval.write"] },
   { endpoint: "host-browser-result", scopes: ["approval.write"] },
+  { endpoint: "host-browser-event", scopes: ["approval.write"] },
+  { endpoint: "host-browser-session-invalidated", scopes: ["approval.write"] },
   { endpoint: "host-cu-result", scopes: ["approval.write"] },
   { endpoint: "host-file-result", scopes: ["approval.write"] },
   { endpoint: "host-transfer-result", scopes: ["approval.write"] },
@@ -183,6 +186,9 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "calls/instruction", scopes: ["calls.write"] },
 
   // Settings / integrations / identity
+  { endpoint: "disk-pressure/status", scopes: ["settings.read"] },
+  { endpoint: "disk-pressure/acknowledge", scopes: ["settings.write"] },
+  { endpoint: "disk-pressure/override", scopes: ["settings.write"] },
   { endpoint: "ps", scopes: ["settings.read"] },
   { endpoint: "identity", scopes: ["settings.read"] },
   { endpoint: "identity/intro", scopes: ["settings.read"] },
@@ -204,6 +210,8 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "contacts/invites:POST", scopes: ["settings.write"] },
   { endpoint: "contacts/invites/redeem", scopes: ["settings.write"] },
   { endpoint: "contacts/invites:DELETE", scopes: ["settings.write"] },
+  { endpoint: "contacts/prompt:POST", scopes: ["settings.write"] },
+  { endpoint: "resolve_contact_prompt:POST", scopes: ["settings.write"] },
   { endpoint: "integrations/telegram/config", scopes: ["settings.read"] },
   { endpoint: "integrations/telegram/config:POST", scopes: ["settings.write"] },
   {
@@ -322,6 +330,7 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "clients", scopes: ["settings.read"] },
   { endpoint: "clients/disconnect", scopes: ["settings.write"] },
   { endpoint: "debug", scopes: ["settings.read"] },
+  { endpoint: "debug/bash", scopes: ["settings.write"] },
 
   // Workspace file browsing
   { endpoint: "workspace/tree", scopes: ["settings.read"] },
@@ -422,7 +431,16 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "memory-items:DELETE", scopes: ["settings.write"] },
   { endpoint: "memory/v2/backfill:POST", scopes: ["settings.write"] },
   { endpoint: "memory/v2/validate:POST", scopes: ["settings.read"] },
+  { endpoint: "memory/v2/concept-page:POST", scopes: ["settings.read"] },
   { endpoint: "memory/v2/reembed-skills:POST", scopes: ["settings.write"] },
+  { endpoint: "memory/v2/explain-similarity:POST", scopes: ["settings.read"] },
+  { endpoint: "memory/v2/fit-anisotropy:POST", scopes: ["settings.write"] },
+  {
+    endpoint: "memory/v2/rebuild-corpus-stats:POST",
+    scopes: ["settings.write"],
+  },
+  { endpoint: "memory/v2/concept-frequency:POST", scopes: ["settings.read"] },
+  { endpoint: "memory/v2/fit-anisotropy:POST", scopes: ["settings.write"] },
 
   // Trust rule listing
   { endpoint: "trust-rules/manage:GET", scopes: ["settings.read"] },
@@ -490,6 +508,9 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "consolidation", scopes: ["settings.read"] },
   { endpoint: "consolidation:POST", scopes: ["settings.write"] },
 
+  // Gateway log proxy
+  { endpoint: "gateway/logs/tail", scopes: ["settings.read"] },
+
   // Heartbeat (config, runs, checklist — all share the "heartbeat" policyKey)
   { endpoint: "heartbeat:GET", scopes: ["settings.read"] },
   { endpoint: "heartbeat", scopes: ["settings.write"] },
@@ -551,6 +572,12 @@ registerPolicy("conversations/clear-all", {
   allowedPrincipalTypes: ["actor", "svc_gateway", "svc_daemon", "local"],
 });
 
+// Event emission: gateway-only internal notification
+registerPolicy("events/emit", {
+  requiredScopes: ["internal.write"],
+  allowedPrincipalTypes: ["svc_gateway"],
+});
+
 // Channel inbound: gateway-only
 registerPolicy("channels/inbound", {
   requiredScopes: ["ingress.write"],
@@ -563,6 +590,11 @@ const INTERNAL_ENDPOINTS = [
   "internal/twilio/status",
   "internal/twilio/connect-action",
   "internal/oauth/callback",
+  "internal/mcp/auth/start",
+  "internal/mcp/auth/status",
+  "internal/mcp/reload", // ← new
+  "internal/oauth/connect/start",
+  "internal/oauth/connect/status",
 ];
 for (const endpoint of INTERNAL_ENDPOINTS) {
   registerPolicy(endpoint, {

package/src/runtime/auth/same-actor.ts

@@ -0,0 +1,216 @@
+/**
+ * Same-actor (same-user) binding check used by host proxies and result
+ * routes.
+ *
+ * Verifies that the submitting (source) actor's principal id matches the
+ * actor principal id captured for the target client at SSE subscription
+ * time. This is the authoritative gate that prevents cross-user
+ * execution and cross-user result submission across all three host-proxy
+ * capabilities (host_bash, host_file, host_cu).
+ *
+ * Two entry points map onto the two control-flow styles in the codebase:
+ *   - {@link enforceSameActorOrErrorResult} for proxies — returns a
+ *     tool-execution error result on rejection, `null` on success.
+ *   - {@link enforceSameActorOrThrow} for HTTP/IPC route handlers —
+ *     throws {@link ForbiddenError} on rejection so the route adapter
+ *     maps it to HTTP 403.
+ *
+ * Both paths log a single structured warn line on rejection with the
+ * shape `{ sourceActorPrincipalId, targetClientId, targetActorPrincipalId,
+ * op, reason }` so that bash, file, and CU rejections render identically
+ * in the audit log.
+ */
+import type { HostProxyCapability } from "../../channels/types.js";
+import { getLogger } from "../../util/logger.js";
+import type { AssistantEventHub } from "../assistant-event-hub.js";
+import { ForbiddenError } from "../routes/errors.js";
+
+const log = getLogger("same-actor");
+
+/**
+ * Canonical user-facing rejection message. Used by both the proxy and
+ * route paths so operators and auditors see identical wording regardless
+ * of whether the failure surfaced as a tool-execution result or an HTTP
+ * 403.
+ */
+const REJECTION_MESSAGE =
+  "Submitting actor does not match the target client's actor for this request. The targeted client's authenticated user must submit the result.";
+
+/** OpenAPI 403 description for `*-result` endpoints, kept identical. */
+export const SAME_ACTOR_FORBIDDEN_DESCRIPTION =
+  "Submitting client does not match the targeted client, or the submitting actor's principal does not match the target client's actor.";
+
+/** Per-capability scope for the structured warn log entry. */
+export type SameActorOp =
+  | "host_bash"
+  | "host_file"
+  | "host_cu"
+  | "host_transfer";
+
+/**
+ * Args for the live-lookup variant: caller supplies the hub + target client
+ * id, and the helper looks up the target's actor principal in real time.
+ * Used at proxy request time (registration), where the SSE subscription is
+ * present by definition.
+ */
+export interface SameActorLiveArgs {
+  hub: Pick<AssistantEventHub, "getActorPrincipalIdForClient">;
+  sourceActorPrincipalId: string | undefined;
+  targetClientId: string;
+  op: SameActorOp;
+}
+
+/**
+ * Args for the persisted-value variant: caller supplies a target actor
+ * principal id captured at registration time. Used at result-submission
+ * time, where the SSE subscription may have briefly disconnected and the
+ * live hub lookup would falsely 403 a legitimate result.
+ */
+export interface SameActorPersistedArgs {
+  sourceActorPrincipalId: string | undefined;
+  targetActorPrincipalId: string | undefined;
+  targetClientId: string;
+  op: SameActorOp;
+}
+
+export type SameActorArgs = SameActorLiveArgs;
+
+type RejectionReason = "missing_source" | "missing_target" | "mismatch";
+
+function isLive(
+  args: SameActorLiveArgs | SameActorPersistedArgs,
+): args is SameActorLiveArgs {
+  return (args as SameActorLiveArgs).hub != null;
+}
+
+/**
+ * Internal: returns the rejection reason or `undefined` when the source
+ * matches the target. Always logs on rejection so all callers share the
+ * same audit shape.
+ */
+function detectRejection(
+  args: SameActorLiveArgs | SameActorPersistedArgs,
+): RejectionReason | undefined {
+  const { sourceActorPrincipalId, targetClientId, op } = args;
+  const targetActorPrincipalId = isLive(args)
+    ? args.hub.getActorPrincipalIdForClient(targetClientId)
+    : args.targetActorPrincipalId;
+
+  let reason: RejectionReason | undefined;
+  if (sourceActorPrincipalId == null) {
+    reason = "missing_source";
+  } else if (targetActorPrincipalId == null) {
+    reason = "missing_target";
+  } else if (sourceActorPrincipalId !== targetActorPrincipalId) {
+    reason = "mismatch";
+  }
+  if (reason == null) return undefined;
+
+  log.warn(
+    {
+      sourceActorPrincipalId,
+      targetClientId,
+      targetActorPrincipalId,
+      op,
+      reason,
+    },
+    "Rejecting cross-user host proxy request",
+  );
+  return reason;
+}
+
+/**
+ * Route-flavored variant: throws {@link ForbiddenError} on rejection so
+ * the existing route adapter maps it to HTTP 403. Returns void on
+ * success.
+ *
+ * Accepts EITHER {@link SameActorLiveArgs} (live hub lookup, used at
+ * proxy registration time) OR {@link SameActorPersistedArgs} (compare
+ * against a value captured earlier, used at result-submission time so a
+ * brief SSE reconnect doesn't 403 a legitimate result).
+ */
+export function enforceSameActorOrThrow(
+  args: SameActorLiveArgs | SameActorPersistedArgs,
+): void {
+  if (detectRejection(args) != null) {
+    throw new ForbiddenError(REJECTION_MESSAGE);
+  }
+}
+
+/**
+ * Proxy-flavored variant: returns a tool-execution-shaped error result
+ * on rejection (so the proxy can pass it directly back to the agent),
+ * or `null` on success. Always uses the live hub lookup — proxy
+ * registration runs while the target SSE subscription is active.
+ */
+export function enforceSameActorOrErrorResult(
+  args: SameActorLiveArgs,
+): { content: string; isError: true } | null {
+  if (detectRejection(args) == null) return null;
+  return { content: REJECTION_MESSAGE, isError: true };
+}
+
+/**
+ * Result of attempting to auto-resolve a single same-user target client.
+ *
+ * - `match`: exactly one same-user client supports the capability. Use the
+ *   returned clientId.
+ * - `none`: no same-user client supports the capability. Caller's choice
+ *   how to handle (typically: fall through to no-target, which broadcasts
+ *   to nobody when no clients are connected).
+ * - `ambiguous`: more than one same-user client supports the capability.
+ *   Caller MUST refuse to silently broadcast across them; instead surface
+ *   an error asking the caller to specify `target_client_id`.
+ */
+export type AutoResolveResult =
+  | { kind: "match"; clientId: string }
+  | { kind: "none" }
+  | { kind: "ambiguous" };
+
+/**
+ * Filter capable clients by `actorPrincipalId === sourcePrincipalId` and
+ * report whether exactly one matched, zero matched, or more than one
+ * matched.
+ *
+ * Used by host proxies to auto-resolve a target client when the caller
+ * did not specify one. Skipping when the caller has no principal keeps
+ * the same-user binding closed: an unauthenticated caller cannot
+ * piggyback on a connected user's session.
+ *
+ * Why three outcomes (vs. just `string | undefined`)? Earlier revisions
+ * collapsed `none` and `ambiguous` into `undefined`, which caused the
+ * proxy to fall through to an untargeted broadcast — fanning a single
+ * targeted-style request out across every same-user machine. Surfacing
+ * `ambiguous` separately lets the proxy reject with a clear "specify
+ * target_client_id" error instead.
+ */
+export function pickSameUserAutoResolve(args: {
+  hub: Pick<AssistantEventHub, "listClientsByCapability">;
+  capability: HostProxyCapability;
+  sourceActorPrincipalId: string | undefined;
+}): AutoResolveResult {
+  const { hub, capability, sourceActorPrincipalId } = args;
+  if (sourceActorPrincipalId == null) return { kind: "none" };
+  const sameUser = hub
+    .listClientsByCapability(capability)
+    .filter((c) => c.actorPrincipalId === sourceActorPrincipalId);
+  if (sameUser.length === 0) return { kind: "none" };
+  if (sameUser.length === 1) {
+    return { kind: "match", clientId: sameUser[0].clientId };
+  }
+  return { kind: "ambiguous" };
+}
+
+/**
+ * Standard error result for proxies when {@link pickSameUserAutoResolve}
+ * returns `ambiguous`. Asks the caller to specify `target_client_id`.
+ */
+export function ambiguousSameUserError(capability: HostProxyCapability): {
+  content: string;
+  isError: true;
+} {
+  return {
+    content: `Multiple ${capability} clients are connected for this user. Specify target_client_id to disambiguate. Run \`assistant clients list --capability ${capability}\` to see client IDs.`,
+    isError: true,
+  };
+}

package/src/runtime/btw-sidechain.ts

@@ -1,5 +1,4 @@
 import type { LLMCallSite } from "../config/schemas/llm.js";
-import { buildToolDefinitions } from "../daemon/conversation-tool-setup.js";
 import { buildSystemPrompt } from "../prompts/system-prompt.js";
 import {
   createTimeout,
@@ -27,7 +26,7 @@ export interface RunBtwSidechainParams {
   provider?: Provider;
   messages?: Message[];
   systemPrompt?: string;
-  tools?: ToolDefinition[];
+  tools: ToolDefinition[];
   maxTokens?: number;
   /**
    * Unified call-site identifier. The provider layer resolves
@@ -68,7 +67,7 @@ export async function runBtwSidechain(
     throw new Error("BTW side-chain requires a provider");
   }
 
-  const tools = params.tools ?? buildToolDefinitions();
+  const tools = params.tools;
   const history = params.messages ?? params.conversation?.getMessages() ?? [];
   const messages = [...history, userMessage(trimmedContent)];
   const systemPrompt =

package/src/runtime/channel-invite-transport.ts

@@ -20,57 +20,11 @@ import { slackInviteAdapter } from "./channel-invite-transports/slack.js";
 import { telegramInviteAdapter } from "./channel-invite-transports/telegram.js";
 import { voiceInviteAdapter } from "./channel-invite-transports/voice.js";
 import { whatsappInviteAdapter } from "./channel-invite-transports/whatsapp.js";
-
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
-
-export interface InviteShareLink {
-  /** The full URL the recipient can open to redeem the invite. */
-  url: string;
-  /** Human-readable text suitable for display alongside the link. */
-  displayText: string;
-}
-
-export interface ChannelInviteAdapter {
-  /** The channel this adapter handles. */
-  channel: ChannelId;
-
-  /**
-   * Build a channel-specific shareable link (e.g. Telegram deep link).
-   * Optional — not all channels support link-based invites.
-   */
-  buildShareLink?(params: {
-    rawToken: string;
-    sourceChannel: ChannelId;
-  }): InviteShareLink;
-
-  /**
-   * Extract a channel-specific invite token from an inbound message
-   * (e.g. Telegram `/start iv_<token>`). Optional — only needed for
-   * channels with link-based invites.
-   */
-  extractInboundToken?(params: {
-    commandIntent?: Record<string, unknown>;
-    content: string;
-    sourceMetadata?: Record<string, unknown>;
-  }): string | undefined;
-
-  /**
-   * Resolve the channel-specific handle to reach the assistant (e.g.
-   * "@botName", "+15551234567", "hello@vellum.me").
-   * Returns `undefined` when the handle cannot be resolved (e.g.
-   * credentials not yet configured).
-   */
-  resolveChannelHandle?(): string | undefined;
-
-  /**
-   * Async variant of `resolveChannelHandle` for adapters that need to
-   * perform I/O (e.g. querying a provider API for the assigned address).
-   * When both are present, `resolveAdapterHandle()` prefers this method.
-   */
-  resolveChannelHandleAsync?(): Promise<string | undefined>;
-}
+import type { ChannelInviteAdapter } from "./channel-invite-types.js";
+export type { ChannelInviteAdapter, InviteShareLink } from "./channel-invite-types.js";
 
 // ---------------------------------------------------------------------------
 // Registry

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

@@ -12,7 +12,7 @@
  */
 
 import { getNestedValue, loadRawConfig } from "../../config/loader.js";
-import type { ChannelInviteAdapter } from "../channel-invite-transport.js";
+import type { ChannelInviteAdapter } from "../channel-invite-types.js";
 
 // ---------------------------------------------------------------------------
 // Adapter implementation

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

@@ -9,7 +9,7 @@
 
 import type { ChannelId } from "../../channels/types.js";
 import { getConfig } from "../../config/loader.js";
-import type { ChannelInviteAdapter } from "../channel-invite-transport.js";
+import type { ChannelInviteAdapter } from "../channel-invite-types.js";
 
 // ---------------------------------------------------------------------------
 // Slack bot info resolution

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

@@ -26,7 +26,7 @@ import { getLogger } from "../../util/logger.js";
 import type {
   ChannelInviteAdapter,
   InviteShareLink,
-} from "../channel-invite-transport.js";
+} from "../channel-invite-types.js";
 
 // ---------------------------------------------------------------------------
 // Bot username resolution

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

@@ -15,7 +15,7 @@ import type { ChannelId } from "../../channels/types.js";
 import type {
   ChannelInviteAdapter,
   InviteShareLink,
-} from "../channel-invite-transport.js";
+} from "../channel-invite-types.js";
 
 // ---------------------------------------------------------------------------
 // Adapter implementation

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

@@ -10,7 +10,7 @@
 
 import type { ChannelId } from "../../channels/types.js";
 import { getConfig } from "../../config/loader.js";
-import type { ChannelInviteAdapter } from "../channel-invite-transport.js";
+import type { ChannelInviteAdapter } from "../channel-invite-types.js";
 
 // ---------------------------------------------------------------------------
 // Phone number resolution

package/src/runtime/channel-invite-types.ts

@@ -0,0 +1,54 @@
+/**
+ * Types extracted from channel-invite-transport.ts to break the
+ * transport ↔ channel-invite-transports/* cycles (×5).
+ */
+
+import type { ChannelId } from "../channels/types.js";
+
+export interface InviteShareLink {
+  /** The full URL the recipient can open to redeem the invite. */
+  url: string;
+  /** Human-readable text suitable for display alongside the link. */
+  displayText: string;
+}
+
+export interface ChannelInviteAdapter {
+  /** The channel this adapter handles. */
+  channel: ChannelId;
+
+  /**
+   * Build a channel-specific shareable link (e.g. Telegram deep link).
+   * Optional — not all channels support link-based invites.
+   */
+  buildShareLink?(params: {
+    rawToken: string;
+    sourceChannel: ChannelId;
+  }): InviteShareLink;
+
+  /**
+   * Extract a channel-specific invite token from an inbound message
+   * (e.g. Telegram `/start iv_<token>`). Optional — only needed for
+   * channels with link-based invites.
+   */
+  extractInboundToken?(params: {
+    commandIntent?: Record<string, unknown>;
+    content: string;
+    sourceMetadata?: Record<string, unknown>;
+  }): string | undefined;
+
+  /**
+   * Resolve the channel-specific handle to reach the assistant (e.g.
+   * // generic-examples:ignore-next-line — reason: illustrative docstring examples, not real data
+   * "@botName", "+15551234567", "hello@vellum.me").
+   * Returns `undefined` when the handle cannot be resolved (e.g.
+   * credentials not yet configured).
+   */
+  resolveChannelHandle?(): string | undefined;
+
+  /**
+   * Async variant of `resolveChannelHandle` for adapters that need to
+   * perform I/O (e.g. querying a provider API for the assigned address).
+   * When both are present, `resolveAdapterHandle()` prefers this method.
+   */
+  resolveChannelHandleAsync?(): Promise<string | undefined>;
+}

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

@@ -1,3 +1,8 @@
+import {
+  normalizePublicBaseUrl,
+  resolveTwilioPublicBaseUrl,
+} from "@vellumai/service-contracts/twilio-ingress";
+
 import { resolveTwilioPhoneNumber } from "../calls/twilio-config.js";
 import { hasTwilioCredentials } from "../calls/twilio-rest.js";
 import { getChannelInvitePolicy } from "../channels/config.js";
@@ -19,31 +24,35 @@ import type {
 /** Remote check results are cached for 5 minutes before being considered stale. */
 export const REMOTE_TTL_MS = 5 * 60 * 1000;
 
-function hasIngressConfigured(): boolean {
+function hasIngressConfigured(options: { twilio?: boolean } = {}): boolean {
   try {
     const raw = loadRawConfig();
     const ingress = (raw?.ingress ?? {}) as Record<string, unknown>;
-    const publicBaseUrl = (ingress.publicBaseUrl as string) ?? "";
+    const effectiveBaseUrl = options.twilio
+      ? (resolveTwilioPublicBaseUrl(ingress) ?? "")
+      : (normalizePublicBaseUrl(ingress.publicBaseUrl) ?? "");
     const enabled =
       (ingress.enabled as boolean | undefined) ??
-      (publicBaseUrl ? true : false);
-    return enabled && publicBaseUrl.length > 0;
+      (effectiveBaseUrl ? true : false);
+    return enabled && effectiveBaseUrl.trim().length > 0;
   } catch {
     return false;
   }
 }
 
-function hasWebhookRoutingConfigured(allowManagedCallbacks = false): {
+function hasWebhookRoutingConfigured(
+  allowManagedCallbacks = false,
+  options: { twilio?: boolean } = {},
+): {
   configured: boolean;
   usesManagedCallbacks: boolean;
 } {
-  const ingressConfigured = hasIngressConfigured();
+  const ingressConfigured = hasIngressConfigured(options);
   if (ingressConfigured) {
     return { configured: true, usesManagedCallbacks: false };
   }
 
-  const usesManagedCallbacks =
-    allowManagedCallbacks && getIsPlatform();
+  const usesManagedCallbacks = allowManagedCallbacks && getIsPlatform();
   return {
     configured: usesManagedCallbacks,
     usesManagedCallbacks,
@@ -79,19 +88,29 @@ async function checkCredential(
 }
 
 /** Check that public ingress is configured and enabled. */
-function checkIngress(allowManagedCallbacks = false): ReadinessCheckResult {
+function checkIngress(
+  allowManagedCallbacks = false,
+  options: { twilio?: boolean } = {},
+): ReadinessCheckResult {
   const { configured, usesManagedCallbacks } = hasWebhookRoutingConfigured(
     allowManagedCallbacks,
+    options,
   );
   return check(
     "ingress",
     configured,
     usesManagedCallbacks
       ? "Managed platform callback routing is configured"
-      : "Public ingress URL is configured",
+      : options.twilio
+        ? "Twilio public ingress URL is configured"
+        : "Public ingress URL is configured",
     allowManagedCallbacks
-      ? "No public ingress URL or managed callback route is configured"
-      : "Public ingress URL is not configured or disabled",
+      ? options.twilio
+        ? "No Twilio public ingress URL or managed callback route is configured"
+        : "No public ingress URL or managed callback route is configured"
+      : options.twilio
+        ? "Twilio public ingress URL is not configured or disabled"
+        : "Public ingress URL is not configured or disabled",
   );
 }
 
@@ -102,7 +121,7 @@ const voiceProbe: ChannelProbe = {
   async runLocalChecks(): Promise<ReadinessCheckResult[]> {
     const hasCreds = await hasTwilioCredentials();
     const hasPhone = !!resolveTwilioPhoneNumber();
-    const ingress = checkIngress(true);
+    const ingress = checkIngress(true, { twilio: true });
 
     return [
       check(