@vellumai/assistant 0.11.6 → 0.11.7-staging.2

package/src/runtime/routes/chatgpt-subscription-auth-routes.ts

@@ -1,88 +1,259 @@
 /**
- * Route definitions for ChatGPT subscription OAuth authentication.
+ * Route definitions for ChatGPT subscription ("Sign in with ChatGPT") auth.
+ *
+ * Device code is the primary path: the daemon mints a short user code, the user
+ * types it at OpenAI's device page, and the daemon polls in the background and
+ * stores the tokens itself. The copy-paste PKCE path stays as the fallback for
+ * accounts that have not enabled device-code authorization for Codex.
+ *
+ * POST /v1/inference/chatgpt-subscription/device-auth: mint a user code and
+ *   start the background poll. Returns `{ state, user_code, verification_url,
+ *   expires_at, interval_seconds }`.
+ * GET /v1/inference/chatgpt-subscription/device-auth/status/:state: poll the
+ *   device flow's status (`pending` | `connected` | `error`).
+ * DELETE /v1/inference/chatgpt-subscription/device-auth/:state: stop the
+ *   background poll for an abandoned flow.
  *
  * POST /v1/inference/chatgpt-subscription/auth — generate a PKCE authorize
  *   URL for the user to visit. Returns `{ authorize_url, state }`.
- *
  * POST /v1/inference/chatgpt-subscription/auth/exchange — accept the
- *   authorization code + state from the redirect, exchange for tokens,
- *   store in CES, and upsert the provider connection.
+ *   authorization code + state from the redirect and exchange it for tokens.
  */
 
 import { z } from "zod";
 
-import { getDb } from "../../persistence/db-connection.js";
-import { CHATGPT_SUBSCRIPTION_CONNECTION_NAME } from "../../providers/inference/auth.js";
-import {
-  createConnection,
-  getConnection,
-  updateConnection,
-} from "../../providers/inference/connections.js";
-import type { OAuth2Config } from "../../security/oauth2.js";
+import { storeChatgptSubscriptionTokens } from "../../providers/inference/chatgpt-subscription-auth.js";
+import { OPENAI_OAUTH_CONFIG } from "../../providers/inference/chatgpt-subscription-credentials.js";
 import {
   exchangeCodeForTokens,
   generateCodeChallenge,
   generateCodeVerifier,
   generateState,
 } from "../../security/oauth2.js";
-import { setSecureKeyAsync } from "../../security/secure-keys.js";
+import {
+  completeDeviceAuth,
+  DeviceAuthError,
+  OPENAI_DEVICE_AUTH_MAX_LIFETIME_MS,
+  requestDeviceCode,
+} from "../../security/openai-device-auth.js";
 import { getLogger } from "../../util/logger.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
+import { BadRequestError, NotFoundError } from "./errors.js";
+import { createPendingFlowRegistry } from "./oauth-pending-flows.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
-const log = getLogger("chatgpt-subscription-auth");
+const log = getLogger("chatgpt-subscription-auth-routes");
 
-// ---------------------------------------------------------------------------
-// OAuth config
-// ---------------------------------------------------------------------------
+const REDIRECT_URI = "http://localhost:1455/auth/callback";
 
-const OPENAI_OAUTH_CONFIG: OAuth2Config = {
-  authorizeUrl: "https://auth.openai.com/oauth/authorize",
-  tokenExchangeUrl: "https://auth.openai.com/oauth/token",
-  clientId: "app_EMoamEEZ73f0CkXaXp7hrann",
-  scopes: ["openid", "profile", "email", "offline_access"],
-  scopeSeparator: " ",
-  authorizeParams: { id_token_add_organizations: "true" },
-};
+/**
+ * Copy-paste PKCE flows, keyed by the `state` in the authorize URL. The
+ * verifier is held until the user pastes the redirect's code back.
+ */
+const pendingPkceFlows = createPendingFlowRegistry<{ codeVerifier: string }>();
 
-const REDIRECT_URI = "http://localhost:1455/auth/callback";
-const CONNECTION_NAME = CHATGPT_SUBSCRIPTION_CONNECTION_NAME;
+/**
+ * Device-code flows, keyed by OpenAI's `device_auth_id`. Each entry carries the
+ * controller that stops its background poll. Entries outlive the device code
+ * itself so a client polling right after expiry still reads the terminal status
+ * instead of a 404.
+ */
+const pendingDeviceFlows = createPendingFlowRegistry<{
+  abort: AbortController;
+}>({
+  ttlMs: OPENAI_DEVICE_AUTH_MAX_LIFETIME_MS + 5 * 60 * 1000,
+});
+
+/**
+ * The one device flow whose background poll is still running. A sign-in is a
+ * single-user act at a single moment, so starting one ends whichever came
+ * before it rather than leaving two polls hitting OpenAI every few seconds.
+ */
+let inFlightDeviceAuthId: string | null = null;
+
+/** Stop a flow's poll and record why, when it has not already settled. */
+function cancelDeviceFlow(state: string): boolean {
+  const flow = pendingDeviceFlows.get(state);
+  if (!flow || flow.status !== "pending") {
+    return false;
+  }
+  flow.abort.abort();
+  pendingDeviceFlows.mark(state, "error", {
+    error: "The sign-in was cancelled.",
+    errorCode: "aborted",
+  });
+  if (inFlightDeviceAuthId === state) {
+    inFlightDeviceAuthId = null;
+  }
+  return true;
+}
+
+/** Release the in-flight slot once this flow's poll is done with it. */
+function releaseDeviceFlow(state: string): void {
+  if (inFlightDeviceAuthId === state) {
+    inFlightDeviceAuthId = null;
+  }
+}
+
+/**
+ * Whether `state` is still the unsettled flow the daemon is running.
+ *
+ * A cancel or a newer sign-in can land after the poll has returned an
+ * authorization code but before the exchange and the credential writes finish.
+ * Checking this on either side of the store keeps an abandoned flow from
+ * writing tokens the user asked it to drop, or from overwriting the
+ * credentials of the sign-in that replaced it.
+ */
+function isDeviceFlowStillLive(state: string): boolean {
+  return (
+    inFlightDeviceAuthId === state &&
+    pendingDeviceFlows.get(state)?.status === "pending"
+  );
+}
+
+/** Failures the user caused or waited out: expected ends, not defects. */
+function isExpectedDeviceAuthEnd(code: string): boolean {
+  return code === "aborted" || code === "expired_token";
+}
+
+interface DeviceAuthStartResponse {
+  state: string;
+  user_code: string;
+  verification_url: string;
+  expires_at: string;
+  interval_seconds: number;
+}
+
+interface FlowStatusResponse {
+  status: "pending" | "connected" | "error";
+  error?: string;
+  error_code?: string;
+}
 
 // ---------------------------------------------------------------------------
-// Module-level PKCE state storage
+// Device-code handlers
 // ---------------------------------------------------------------------------
 
-interface PendingAuth {
-  codeVerifier: string;
-  createdAt: number;
+/**
+ * Mint a device code and return it immediately. The approval poll and the
+ * token exchange run in the background, one per `device_auth_id`, and flip the
+ * tracked flow's status when they settle.
+ */
+async function handleStartDeviceAuth(
+  _args: RouteHandlerArgs,
+): Promise<DeviceAuthStartResponse> {
+  pendingDeviceFlows.cleanupExpired();
+  if (inFlightDeviceAuthId) {
+    cancelDeviceFlow(inFlightDeviceAuthId);
+  }
+
+  const request = await requestDeviceCode(OPENAI_OAUTH_CONFIG.clientId);
+  const abort = new AbortController();
+  pendingDeviceFlows.start(request.deviceAuthId, { abort });
+  inFlightDeviceAuthId = request.deviceAuthId;
+
+  void completeDeviceAuth(OPENAI_OAUTH_CONFIG, request, {
+    signal: abort.signal,
+  })
+    .then(async (result) => {
+      if (!isDeviceFlowStillLive(request.deviceAuthId)) {
+        log.warn(
+          "ChatGPT subscription device auth flow settled after it was dropped; discarding its tokens",
+        );
+        return;
+      }
+      await storeChatgptSubscriptionTokens(result.tokens);
+      if (!isDeviceFlowStillLive(request.deviceAuthId)) {
+        log.warn(
+          "ChatGPT subscription device auth flow was dropped while its tokens were stored",
+        );
+        return;
+      }
+      pendingDeviceFlows.mark(request.deviceAuthId, "connected");
+      log.info("ChatGPT subscription device auth flow connected");
+    })
+    .catch((err: unknown) => {
+      const message = err instanceof Error ? err.message : String(err);
+      const errorCode =
+        err instanceof DeviceAuthError ? err.code : "device_auth_failed";
+      pendingDeviceFlows.mark(request.deviceAuthId, "error", {
+        error: message,
+        errorCode,
+      });
+      const detail = { err: message, code: errorCode };
+      if (isExpectedDeviceAuthEnd(errorCode)) {
+        log.warn(detail, "ChatGPT subscription device auth flow ended");
+      } else {
+        log.error(detail, "ChatGPT subscription device auth flow failed");
+      }
+    })
+    .finally(() => releaseDeviceFlow(request.deviceAuthId));
+
+  return {
+    state: request.deviceAuthId,
+    user_code: request.userCode,
+    verification_url: request.verificationUrl,
+    expires_at: request.expiresAt,
+    interval_seconds: request.intervalSeconds,
+  };
+}
+
+function handleDeviceAuthStatus({
+  pathParams,
+}: RouteHandlerArgs): FlowStatusResponse {
+  const { state } = pathParams as { state: string };
+  const report = pendingDeviceFlows.readStatus(state);
+
+  if (!report) {
+    throw new NotFoundError(
+      "No active ChatGPT device sign-in for the given state. Restart the sign-in flow.",
+    );
+  }
+
+  const response: FlowStatusResponse = { status: report.status };
+  if (report.error !== undefined) {
+    response.error = report.error;
+  }
+  if (report.errorCode !== undefined) {
+    response.error_code = report.errorCode;
+  }
+  return response;
 }
 
-const pendingAuths = new Map<string, PendingAuth>();
+/**
+ * Stop an abandoned flow's background poll. Without this an abandoned sign-in
+ * keeps polling OpenAI every few seconds until the code expires.
+ */
+function handleCancelDeviceAuth({ pathParams }: RouteHandlerArgs): {
+  cancelled: boolean;
+} {
+  const { state } = pathParams as { state: string };
 
-const PENDING_AUTH_TTL_MS = 10 * 60 * 1000; // 10 minutes
+  if (!pendingDeviceFlows.get(state)) {
+    throw new NotFoundError(
+      "No active ChatGPT device sign-in for the given state.",
+    );
+  }
 
-/** Remove entries older than 10 minutes. */
-function cleanupExpiredEntries(): void {
-  const cutoff = Date.now() - PENDING_AUTH_TTL_MS;
-  for (const [key, entry] of pendingAuths) {
-    if (entry.createdAt < cutoff) {
-      pendingAuths.delete(key);
-    }
+  const cancelled = cancelDeviceFlow(state);
+  if (cancelled) {
+    log.warn("ChatGPT subscription device auth flow cancelled by the client");
   }
+  return { cancelled };
 }
 
 // ---------------------------------------------------------------------------
-// Handlers
+// Copy-paste PKCE handlers
 // ---------------------------------------------------------------------------
 
 async function handleStartAuth(_args: RouteHandlerArgs) {
-  cleanupExpiredEntries();
+  pendingPkceFlows.cleanupExpired();
 
   const codeVerifier = generateCodeVerifier();
   const codeChallenge = generateCodeChallenge(codeVerifier);
   const state = generateState();
 
-  pendingAuths.set(state, { codeVerifier, createdAt: Date.now() });
+  pendingPkceFlows.start(state, { codeVerifier });
 
   const params = new URLSearchParams({
     response_type: "code",
@@ -103,18 +274,19 @@ async function handleStartAuth(_args: RouteHandlerArgs) {
 async function handleExchange(args: RouteHandlerArgs) {
   const { code, state } = args.body as { code: string; state: string };
 
-  const pending = pendingAuths.get(state);
+  const pending = pendingPkceFlows.get(state);
   if (!pending) {
-    throw new Error(
+    throw new BadRequestError(
       "Invalid or expired state parameter. Please restart the auth flow.",
     );
   }
 
-  pendingAuths.delete(state);
+  pendingPkceFlows.delete(state);
 
-  // Check TTL
-  if (Date.now() - pending.createdAt > PENDING_AUTH_TTL_MS) {
-    throw new Error("Auth flow expired. Please restart the auth flow.");
+  if (pendingPkceFlows.isExpired(pending)) {
+    throw new BadRequestError(
+      "Auth flow expired. Please restart the auth flow.",
+    );
   }
 
   const { tokens } = await exchangeCodeForTokens(
@@ -124,70 +296,7 @@ async function handleExchange(args: RouteHandlerArgs) {
     pending.codeVerifier,
   );
 
-  // Store tokens in CES
-  const accessStored = await setSecureKeyAsync(
-    "credential/chatgpt/access_token",
-    tokens.accessToken,
-  );
-  if (!accessStored) {
-    log.error("Failed to store ChatGPT access token in CES");
-    throw new Error("Failed to store access token");
-  }
-
-  if (tokens.refreshToken) {
-    const refreshStored = await setSecureKeyAsync(
-      "credential/chatgpt/refresh_token",
-      tokens.refreshToken,
-    );
-    if (!refreshStored) {
-      log.error("Failed to store ChatGPT refresh token in CES");
-      throw new Error("Failed to store refresh token");
-    }
-  }
-
-  if (tokens.expiresIn) {
-    const expiresAt = Math.floor(Date.now() / 1000 + tokens.expiresIn);
-    await setSecureKeyAsync("credential/chatgpt/expires_at", String(expiresAt));
-  }
-
-  // Upsert provider connection
-  const db = getDb();
-  const authInput = {
-    type: "oauth_subscription" as const,
-    credential: "credential/chatgpt/access_token",
-  };
-
-  const existing = getConnection(db, CONNECTION_NAME);
-  if (existing) {
-    // Stamp the provider with the auth: this row IS the subscription route
-    // (auth modality = provider identity), and dispatch derives the openai
-    // upstream from the identity per-request. Stamping also heals a
-    // claiming row whose provider would otherwise misroute the fresh token.
-    const updateResult = updateConnection(db, CONNECTION_NAME, {
-      auth: authInput,
-      provider: "chatgpt",
-    });
-    if (!updateResult.ok) {
-      log.error(
-        { error: updateResult.error },
-        "Failed to update chatgpt-subscription connection",
-      );
-      throw new Error("Failed to update connection");
-    }
-  } else {
-    const createResult = createConnection(db, {
-      name: CONNECTION_NAME,
-      provider: "chatgpt",
-      auth: authInput,
-    });
-    if (!createResult.ok) {
-      log.error(
-        { error: createResult.error },
-        "Failed to create chatgpt-subscription connection",
-      );
-      throw new Error("Failed to create connection");
-    }
-  }
+  await storeChatgptSubscriptionTokens(tokens);
 
   log.info("ChatGPT subscription auth flow completed successfully");
   return { ok: true };
@@ -198,6 +307,80 @@ async function handleExchange(args: RouteHandlerArgs) {
 // ---------------------------------------------------------------------------
 
 export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "inference_chatgpt_subscription_device_auth",
+    endpoint: "inference/chatgpt-subscription/device-auth",
+    method: "POST",
+    policy: {
+      requiredScopes: ["settings.write"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
+    summary: "Start ChatGPT subscription device-code sign-in",
+    description:
+      "Mint a short user code the user types at OpenAI's device page, and " +
+      "start a background poll that stores the tokens and upserts the " +
+      "provider connection once the sign-in is approved. Returns immediately; " +
+      "poll `.../device-auth/status/{state}` for the outcome. The account must " +
+      "have device-code authorization for Codex enabled in its ChatGPT " +
+      "security settings.",
+    tags: ["inference"],
+    responseBody: z.object({
+      state: z.string(),
+      user_code: z.string(),
+      verification_url: z.string(),
+      expires_at: z.string(),
+      interval_seconds: z.number(),
+    }),
+    handler: handleStartDeviceAuth,
+  },
+  {
+    operationId: "inference_chatgpt_subscription_device_auth_status",
+    endpoint: "inference/chatgpt-subscription/device-auth/status/:state",
+    method: "GET",
+    policy: {
+      requiredScopes: ["settings.read"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
+    summary: "Poll ChatGPT subscription device-code sign-in status",
+    description:
+      "Returns the current status of an in-flight device-code sign-in " +
+      "(pending/connected/error) so the client knows when the tokens have " +
+      "landed. A failure carries OpenAI's error code in `error_code`.",
+    tags: ["inference"],
+    pathParams: [{ name: "state" }],
+    additionalResponses: {
+      "404": { description: "No active device sign-in for the given state" },
+    },
+    responseBody: z.object({
+      status: z.enum(["pending", "connected", "error"]),
+      error: z.string().optional(),
+      error_code: z.string().optional(),
+    }),
+    handler: handleDeviceAuthStatus,
+  },
+  {
+    operationId: "inference_chatgpt_subscription_device_auth_cancel",
+    endpoint: "inference/chatgpt-subscription/device-auth/:state",
+    method: "DELETE",
+    policy: {
+      requiredScopes: ["settings.write"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
+    summary: "Cancel a ChatGPT subscription device-code sign-in",
+    description:
+      "Stop the background poll for a device-code sign-in the user walked " +
+      "away from, and mark the flow `error` with code `aborted`. A flow that " +
+      "already settled is left as it is. 404s an unknown state.",
+    tags: ["inference"],
+    pathParams: [{ name: "state" }],
+    additionalResponses: {
+      "404": { description: "No active device sign-in for the given state" },
+    },
+    responseBody: z.object({
+      cancelled: z.boolean(),
+    }),
+    handler: handleCancelDeviceAuth,
+  },
   {
     operationId: "inference_chatgpt_subscription_auth",
     endpoint: "inference/chatgpt-subscription/auth",

package/src/runtime/routes/contact-prompt-routes.ts

@@ -8,8 +8,10 @@
  *   4. User enters an address; client POSTs to the gateway's
  *      `POST /v1/contacts/prompt` HTTP route.
  *   5. Gateway upserts the contact + channel (gateway owns all contact writes).
- *   6. Gateway calls daemon IPC `resolve_contact_prompt` with the new contact info.
- *   7. Daemon resolves the pending promise; `contacts/prompt` IPC returns to CLI.
+ *   6. If the prompt was opened with --verify, the gateway reads
+ *      `contact_prompt_flags` and attests the new channel.
+ *   7. Gateway calls daemon IPC `resolve_contact_prompt` with the new contact info.
+ *   8. Daemon resolves the pending promise; `contacts/prompt` IPC returns to CLI.
  *
  * The daemon only broadcasts the prompt and waits. It never writes contacts.
  * All writes go through the gateway.
@@ -44,6 +46,8 @@ export interface ContactPromptResult {
 interface PendingContactPrompt {
   resolve: (result: ContactPromptResult) => void;
   timer: ReturnType<typeof setTimeout>;
+  /** When true, the gateway marks the submitted channel verified (manual attest). */
+  verify: boolean;
 }
 
 const pendingContactPrompts = new Map<string, PendingContactPrompt>();
@@ -122,6 +126,16 @@ const ContactPromptParams = z.object({
     .enum(["guardian", "trusted-contact", "unknown"])
     .default("unknown")
     .describe("Intended role of the contact being registered."),
+  verify: z
+    .boolean()
+    .optional()
+    .describe(
+      "When true, submitting the address also marks the channel verified. Same attest as Contacts Verify me.",
+    ),
+});
+
+const ContactPromptFlagsParams = z.object({
+  requestId: z.string().describe("The pending contact_request id."),
 });
 
 // ---------------------------------------------------------------------------
@@ -131,8 +145,15 @@ const ContactPromptParams = z.object({
 async function handleContactPrompt({
   body = {},
 }: RouteHandlerArgs): Promise<ContactPromptResult> {
-  const { channel, placeholder, defaultValue, label, description, role } =
-    ContactPromptParams.parse(body);
+  const {
+    channel,
+    placeholder,
+    defaultValue,
+    label,
+    description,
+    role,
+    verify,
+  } = ContactPromptParams.parse(body);
 
   const requestId = uuid();
 
@@ -143,7 +164,11 @@ async function handleContactPrompt({
       resolve({ ok: false, error: "Prompt timed out" });
     }, CONTACT_PROMPT_TIMEOUT_MS);
 
-    pendingContactPrompts.set(requestId, { resolve, timer });
+    pendingContactPrompts.set(requestId, {
+      resolve,
+      timer,
+      verify: verify === true,
+    });
 
     broadcastMessage({
       type: "contact_request",
@@ -156,10 +181,26 @@ async function handleContactPrompt({
       role,
     });
 
-    log.info({ requestId, channel, role }, "Contact prompt broadcast");
+    log.info(
+      { requestId, channel, role, verify: verify === true },
+      "Contact prompt broadcast",
+    );
   });
 }
 
+/**
+ * Read-only flags for a pending prompt. The gateway asks this after it
+ * writes the channel so a `--verify` prompt can attest without the client
+ * having to echo the flag on submit.
+ */
+function readContactPromptFlags({ body = {} }: RouteHandlerArgs): {
+  verify: boolean;
+} {
+  const { requestId } = ContactPromptFlagsParams.parse(body);
+  const pending = pendingContactPrompts.get(requestId);
+  return { verify: pending?.verify === true };
+}
+
 // ---------------------------------------------------------------------------
 // Routes
 // ---------------------------------------------------------------------------
@@ -202,4 +243,22 @@ export const CONTACT_PROMPT_ROUTES: RouteDefinition[] = [
       "Called by the gateway after it writes the contact and channel. Unblocks the waiting contacts/prompt IPC call.",
     tags: ["contacts"],
   },
+  {
+    operationId: "contact_prompt_flags",
+    endpoint: "contact_prompt_flags",
+    method: "POST",
+    policy: {
+      requiredScopes: ["settings.write"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
+    handler: readContactPromptFlags,
+    summary: "Read flags for a pending contact prompt",
+    description:
+      "Returns whether the pending prompt asked the gateway to mark the submitted channel verified.",
+    tags: ["contacts"],
+    requestBody: ContactPromptFlagsParams,
+    responseBody: z.object({
+      verify: z.boolean(),
+    }),
+  },
 ];

package/src/runtime/routes/contact-routes.ts

@@ -12,6 +12,7 @@ import {
   INVITES_IPC_METHODS,
   RedeemInviteByTokenRequestSchema,
   RedeemVoiceInviteRequestSchema,
+  RiskThresholdSchema,
 } from "@vellumai/gateway-client";
 import type { ContactRead } from "@vellumai/gateway-client/gateway-ipc-contracts";
 import {
@@ -173,11 +174,12 @@ function isContactType(value: string): value is ContactType {
 // `role` is gateway-sourced: relayed reads trust the role on the `ContactRead`,
 // while daemon-native reads derive it from the gateway guardian id set at the
 // serve layer (see prepareContactResponse). Interaction telemetry
-// (lastSeenAt/interactionCount/lastInteraction) is gateway-owned: relayed reads
-// carry it directly, and daemon-native reads batch-hydrate it from the gateway
-// (see hydrateTelemetryFromGateway). On a gateway fail-soft the count
-// `interactionCount` defaults to 0 (never served as null, so callers render a
-// real number); the `lastSeenAt`/`lastInteraction` timestamps degrade to null.
+// (lastSeenAt/interactionCount/lastInteraction) and `autoApproveThreshold`
+// are gateway-owned: relayed reads carry them directly, and daemon-native
+// reads batch-hydrate them from the gateway (see hydrateTelemetryFromGateway).
+// On a gateway fail-soft the count `interactionCount` defaults to 0 (never
+// served as null, so callers render a real number); the
+// `lastSeenAt`/`lastInteraction` timestamps and the ceiling degrade to null.
 // The timestamp fields stay `.nullable()`; `interactionCount` is kept nullable
 // defensively for the relay path, but is never emitted null.
 const contactChannelSchema = z.object({
@@ -207,6 +209,7 @@ const contactSchema = z.object({
   contactType: z.enum(["human", "assistant"]),
   lastInteraction: z.number().nullable().optional(),
   interactionCount: z.number().nullable(),
+  autoApproveThreshold: RiskThresholdSchema.nullable().optional(),
   createdAt: z.number(),
   updatedAt: z.number(),
   channels: z.array(contactChannelSchema),
@@ -252,6 +255,7 @@ async function relayListContacts(limit: number, role: ContactRole | undefined) {
 type ContactWithGatewayTelemetry = Omit<ContactWithChannels, "channels"> & {
   interactionCount: number;
   lastInteraction: number | null;
+  autoApproveThreshold: ContactRead["autoApproveThreshold"];
   channels: Array<
     ContactChannel & {
       lastSeenAt: number | null;
@@ -271,16 +275,16 @@ function channelKey(type: string, address: string): string {
 }
 
 /**
- * Overlay gateway-owned interaction telemetry onto daemon-native contact reads
- * (search / contactType-filtered), which bypass the gateway list relay. The
- * daemon still owns the FILTERING (gateway-native search/contactType is
- * design-blocked), but telemetry (contact + channel
- * interactionCount/lastInteraction, channel lastSeenAt) is gateway-owned — so
- * batch-fetch it via `contacts_list_rich` keyed by the filtered id set and
- * overlay it, keeping the local assistant-DB aggregation out of the served
- * payload. Fail-soft: if the gateway read fails or omits a contact, its
- * interaction counts degrade to 0 and its timestamps to null rather than
- * falling back to the local assistant-DB aggregation.
+ * Overlay gateway-owned interaction telemetry and the contact auto-approve
+ * ceiling onto daemon-native contact reads (search / contactType-filtered),
+ * which bypass the gateway list relay. The daemon still owns the FILTERING
+ * (gateway-native search/contactType is design-blocked), but telemetry
+ * (contact + channel interactionCount/lastInteraction, channel lastSeenAt)
+ * and `autoApproveThreshold` are gateway-owned, so batch-fetch them via
+ * `contacts_list_rich` keyed by the filtered id set and overlay them. Fail-soft:
+ * if the gateway read fails or omits a contact, counts degrade to 0,
+ * timestamps to null, and the ceiling to null rather than falling back to
+ * the local assistant-DB aggregation.
  */
 async function hydrateTelemetryFromGateway(
   contacts: ContactWithChannels[],
@@ -321,6 +325,7 @@ async function hydrateTelemetryFromGateway(
       ...c,
       interactionCount: gw?.interactionCount ?? 0,
       lastInteraction: gw?.lastInteraction ?? null,
+      autoApproveThreshold: gw?.autoApproveThreshold ?? null,
       channels: c.channels.map((ch) => {
         const gwCh =
           gwChannelById.get(ch.id) ??