@agent-native/core 0.164.4 → 0.164.12

package/corpus/templates/factory/server/plugins/agent-chat.ts

@@ -57,7 +57,9 @@ current factory graph, and executes only the explicit automation prompts that
 are stored in the organization.
 Use the Factory actions as the source of truth. When a user asks to
 create or change a factory, first inspect the current graph, then propose a complete
-versioned graph through save-factory-graph with source=ai and a concise changeSummary.
+versioned graph through save-factory-graph with source=ai, the inspected graphVersion
+as expectedGraphVersion, and a concise changeSummary. Never save a graph from a
+stale read: refresh and re-propose when the action reports a version conflict.
 Never hide a graph change in prose: the visual map and the saved graph must agree.
 The graph is currently a reviewable blueprint, not the runtime router: automation
 markdown resources are the runtime prompts, while enabled triage rules are evaluated
@@ -89,13 +91,15 @@ Builder, auto-approve, or auto-merge those items. Slack clear bugs use the
 thread-preserving start-builder-for-item flow; GitHub and Sentry clear bugs use
 the Builder agent-run flow. Slack repeat reports must be clustered by underlying
 symptom, with one Builder thread for the cluster and 👀 on every grouped report.
-Use /address-feedback for the repository feedback workflow. For pull requests,
-follow review-prs: read the complete diff and review evidence, verify current
-BuilderIO membership, preserve the ultra-scary safety gate, and distinguish
-unknown or unresolved checks from clean ones. Auto-merge also requires a
-verified Factory Builder run. When a user says to do a review-gated item now,
-use the explicit approval action, which records the approver and applies the
-rule's configured executor policy. Keep Slack replies concise and link to the
+After classifying an item, call start-builder-for-item with clearBug true or
+false and a short reason so a skip is recorded. Use /address-feedback for the
+repository feedback workflow. For pull requests, follow review-prs: read the
+complete diff and review evidence, verify current BuilderIO membership, preserve
+the ultra-scary safety gate, and distinguish unknown or unresolved checks from
+clean ones. Auto-merge also requires a verified Factory Builder run. When a user
+says to do a review-gated item now, use the explicit approval action, which
+records the approver and applies the rule's configured executor policy. Keep
+Slack replies concise and link to the
 Factory item when a review is needed. The scheduled builder-io-bot PR babysitter
 posts its exact feedback-fix request through GitHub, persists a 20-minute quiet
 window, and never approves or merges.`,

package/corpus/templates/factory/server/plugins/factory-scheduler-job.ts

@@ -169,6 +169,8 @@ const FACTORY_DEFAULT_MODEL =
   process.env.FACTORY_AUTOMATION_MODEL?.trim() || "gpt-5.6-luna";
 const FACTORY_DEFAULT_MAX_ITERATIONS = 32;
 const FACTORY_DEFAULT_MAX_RUN_INPUT_TOKENS = 1_000_000;
+const SKIP_RECORD_GUARD =
+  "After classifying each processed item, call start-builder-for-item with clearBug true or false and a short evidence-grounded reason so the skip or dispatch is recorded.";
 
 const AUTOMATION_SEEDS: AutomationSeed[] = [
   {
@@ -224,6 +226,7 @@ the representative source, every related source, and the need to fix the
 underlying boundary across the whole cluster. Never add the reaction or tag
 Builder for owner-managed Clips, Design, or Content work, or for a non-bug
 report.
+After classifying each processed item, call start-builder-for-item with clearBug true or false and a short evidence-grounded reason so the skip or dispatch is recorded.
 
 Keep each run bounded. Preserve action errors and do not claim a Builder reply,
 PR, merge, or fix unless an action returned that state.
@@ -254,6 +257,7 @@ For each eligible clear bug, call start-builder-for-item with clearBug true,
 an evidence-grounded reason, and clearErrorReport containing only the bounded
 Sentry evidence. Builder should open a PR; do not claim it did so until the
 run callback or PR observation confirms it.
+After classifying each processed item, call start-builder-for-item with clearBug true or false and a short evidence-grounded reason so the skip or dispatch is recorded.
 `,
   },
   {
@@ -281,6 +285,7 @@ For each eligible item call start-builder-for-item with clearBug true,
 evidence-grounded reason, and the bounded issue body as clearErrorReport.
 Preserve failures and never report a successful Builder run without its action
 confirmation.
+After classifying each processed item, call start-builder-for-item with clearBug true or false and a short evidence-grounded reason so the skip or dispatch is recorded.
 `,
   },
   {
@@ -522,6 +527,14 @@ async function ensureOrganizationAutomations(
       if (promptGuard && !repaired.includes(promptGuard)) {
         repaired = `${repaired.trimEnd()}\n\n${promptGuard}\n`;
       }
+      if (
+        (seed.name === "factory-slack-feedback" ||
+          seed.name === "factory-sentry-errors" ||
+          seed.name === "factory-github-issues") &&
+        !repaired.includes(SKIP_RECORD_GUARD)
+      ) {
+        repaired = `${repaired.trimEnd()}\n\n${SKIP_RECORD_GUARD}\n`;
+      }
       if (repaired === existing.content) return;
 
       const updated = await resourcePutIfCurrent({

package/corpus/templates/factory/server/triage/slack-client.ts

@@ -4,11 +4,13 @@ import {
   addEyesReaction as writeEyesReaction,
   getThread as readThread,
   getTeamInfo as readTeamInfo,
+  getUserInfo as readUserInfo,
   postThreadReply as writeThreadReply,
   type ChannelHistoryResult,
   type SlackPostMessageResult,
   type SlackReactionResult,
   type SlackTeamInfo,
+  type SlackUserInfo,
   type SlackTokenResolver,
   type ThreadRepliesResult,
   type Workspace,
@@ -57,6 +59,9 @@ export function createSlackReader(identity: SlackReaderIdentity) {
     getTeamInfo(workspace: Workspace): Promise<SlackTeamInfo> {
       return readTeamInfo(workspace, tokenResolver);
     },
+    getUserInfo(workspace: Workspace, userId: string): Promise<SlackUserInfo> {
+      return readUserInfo(workspace, userId, tokenResolver);
+    },
     getThread(
       workspace: Workspace,
       channelId: string,

package/corpus/templates/factory/server/triage/slack-poller.ts

@@ -5,6 +5,7 @@ import { createSlackReader } from "./slack-client";
 const SLACK_HISTORY_LIMIT = 100;
 const MAX_HISTORY_PAGES = 5;
 const MAX_SUMMARY_LENGTH = 500;
+export const SLACK_USER_INFO_CONCURRENCY = 4;
 
 export interface SlackPollInput {
   workspace: Workspace;
@@ -37,17 +38,75 @@ function compactText(text: string): string {
     : compact;
 }
 
-function messageLabel(message: SlackMessage): string {
+function messageLabel(message: SlackMessage, resolvedLabel?: string): string {
   if (message.bot_id || message.username) {
     return `Slack bot ${message.username ?? message.bot_id ?? "unknown"}`;
   }
-  return `Slack user ${message.user ?? "unknown"}`;
+  return `Slack user ${resolvedLabel ?? message.user ?? "unknown"}`;
+}
+
+function slackUserLabel(
+  user: { name: string | null; displayName: string | null } | null,
+  userId: string,
+): string {
+  const displayName = user?.displayName?.trim();
+  if (displayName) return displayName;
+  const name = user?.name?.trim();
+  if (name) return name.startsWith("@") ? name : `@${name}`;
+  return userId;
+}
+
+async function resolveUserLabels(
+  slack: ReturnType<typeof createSlackReader>,
+  workspace: Workspace,
+  messages: SlackMessage[],
+): Promise<Map<string, string>> {
+  const userIds = [
+    ...new Set(
+      messages
+        .filter((message) => !message.bot_id && !message.username)
+        .map((message) => message.user?.trim())
+        .filter((userId): userId is string => Boolean(userId)),
+    ),
+  ];
+  const labels = new Map<string, string>();
+  await mapWithConcurrency(
+    userIds,
+    SLACK_USER_INFO_CONCURRENCY,
+    async (userId) => {
+      try {
+        const user = await slack.getUserInfo(workspace, userId);
+        labels.set(userId, slackUserLabel(user, userId));
+      } catch {
+        labels.set(userId, userId);
+      }
+    },
+  );
+  return labels;
+}
+
+async function mapWithConcurrency<T>(
+  values: T[],
+  concurrency: number,
+  mapper: (value: T) => Promise<void>,
+): Promise<void> {
+  let nextIndex = 0;
+  const worker = async () => {
+    while (nextIndex < values.length) {
+      const index = nextIndex++;
+      await mapper(values[index]!);
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(concurrency, values.length) }, worker),
+  );
 }
 
 function toEnvelope(
   channelId: string,
   message: SlackMessage,
   teamDomain?: string,
+  userLabels?: Map<string, string>,
 ): IngestionEnvelope {
   const threadTs = message.thread_ts ?? message.ts;
   const suppliedPermalink = (message as SlackMessage & { permalink?: string })
@@ -63,7 +122,10 @@ function toEnvelope(
     externalId: `${channelId}:${threadTs}`,
     receivedAt: new Date().toISOString(),
     ...(sourceUrl ? { sourceUrl } : {}),
-    title: messageLabel(message),
+    title: messageLabel(
+      message,
+      message.user ? userLabels?.get(message.user) : undefined,
+    ),
     summary: compactText(message.text),
     channelId,
     threadTs,
@@ -149,9 +211,15 @@ export async function pollSlackChannel({
     { value: priorTs, raw: priorLastSlackTs },
   );
 
+  const userLabels = await resolveUserLabels(
+    slack,
+    workspace,
+    uniqueNewMessages.map(({ message }) => message),
+  );
+
   return {
     envelopes: uniqueNewMessages.map(({ message }) =>
-      toEnvelope(channelId, message, teamDomain),
+      toEnvelope(channelId, message, teamDomain, userLabels),
     ),
     nextLastSlackTs: maxSeen.raw,
     nextHistoryCursor,

package/corpus/templates/mail/actions/view-screen.ts

@@ -70,7 +70,7 @@ async function fetchEmailList(
 
       const gmailQuery = buildGmailEmailSearchQuery({ view, q: search });
       const effectiveQuery =
-        view === "all" && !search ? "" : gmailQuery || "in:inbox -in:sent";
+        view === "all" && !search ? "" : gmailQuery || "in:inbox";
       const { messages } = await listGmailMessages(
         effectiveQuery,
         50,

package/corpus/templates/mail/app/components/GoogleConnectBanner.tsx

@@ -76,6 +76,25 @@ const ADD_ACCOUNT_POLL_ABORT_MS = Math.max(
   ADD_ACCOUNT_POLL_INTERVAL_MS * 4,
 );
 
+function newDesktopOAuthVerifier(): string | null {
+  const cryptoApi = globalThis.crypto;
+  const randomUuid = cryptoApi?.randomUUID;
+  if (typeof randomUuid === "function") {
+    return `${randomUuid.call(cryptoApi)}${randomUuid.call(cryptoApi)}`;
+  }
+  if (typeof cryptoApi?.getRandomValues === "function") {
+    const bytes = new Uint8Array(32);
+    cryptoApi.getRandomValues(bytes);
+    let binary = "";
+    for (const byte of bytes) binary += String.fromCharCode(byte);
+    return btoa(binary)
+      .replace(/\+/g, "-")
+      .replace(/\//g, "_")
+      .replace(/=+$/, "");
+  }
+  return null;
+}
+
 interface GoogleConnectBannerProps {
   variant?: "banner" | "hero";
 }
@@ -128,20 +147,81 @@ export function GoogleConnectBanner({
     const flowId =
       crypto.randomUUID?.() ||
       Math.random().toString(36).slice(2) + Date.now().toString(36);
+    const verifier = newDesktopOAuthVerifier();
+    if (!verifier) {
+      setDesktopAuthIssue({
+        code: "desktop_auth_start_failed",
+        message: t("mail.error.failedToConnect"),
+      });
+      return;
+    }
     const origin = window.location.origin;
     const endpoint = addAccount
       ? "/_agent-native/google/add-account/auth-url"
       : "/_agent-native/google/auth-url";
-    const redirectUri = encodeURIComponent(
-      oauthRedirectUri("/_agent-native/google/callback"),
-    );
-    window.open(
-      `${origin}${agentNativePath(endpoint)}?redirect_uri=${redirectUri}&desktop=1&flow_id=${flowId}&redirect=1`,
-      "_blank",
-    );
+    const params = new URLSearchParams({
+      redirect_uri: oauthRedirectUri("/_agent-native/google/callback"),
+      desktop: "1",
+      flow_id: flowId,
+    });
+    const popup = window.open("", "_blank");
+    if (!popup) {
+      setDesktopAuthIssue({
+        code: "popup_blocked",
+        message: t("mail.error.failedToConnect"),
+      });
+      return;
+    }
+    let pollHandle: ReturnType<typeof setInterval> | null = null;
+    const stopPoll = () => {
+      if (!pollHandle) return;
+      clearInterval(pollHandle);
+      if (desktopPollRef.current === pollHandle) {
+        desktopPollRef.current = null;
+      }
+      pollHandle = null;
+    };
+    void fetch(`${origin}${agentNativePath(endpoint)}?${params.toString()}`, {
+      method: "POST",
+      credentials: "include",
+      headers: { "X-Agent-Native-Desktop-Verifier": verifier },
+    })
+      .then(async (response) => {
+        let data: {
+          url?: unknown;
+          message?: unknown;
+          error?: unknown;
+        };
+        try {
+          data = (await response.json()) as typeof data;
+        } catch {
+          throw new Error(t("mail.googleConnect.connectionFailed"));
+        }
+        if (!response.ok || typeof data?.url !== "string") {
+          const message =
+            typeof data.message === "string"
+              ? data.message
+              : typeof data.error === "string"
+                ? data.error
+                : t("mail.googleConnect.connectionFailed");
+          throw new Error(message);
+        }
+        popup.location.href = data.url;
+      })
+      .catch((error) => {
+        stopPoll();
+        popup.close();
+        setDesktopAuthIssue({
+          code: "desktop_auth_start_failed",
+          message:
+            error instanceof Error
+              ? error.message
+              : t("mail.googleConnect.connectionFailed"),
+        });
+      });
     const start = Date.now();
     if (desktopPollRef.current) clearInterval(desktopPollRef.current);
-    desktopPollRef.current = setInterval(async () => {
+    pollHandle = setInterval(async () => {
       if (document.hidden || desktopPollInFlightRef.current) return;
       desktopPollInFlightRef.current = true;
       const controller = new AbortController();
@@ -153,18 +233,21 @@ export function GoogleConnectBanner({
         try {
           const res = await fetch(
             agentNativePath(
-              `/_agent-native/auth/desktop-exchange?flow_id=${flowId}`,
+              `/_agent-native/auth/desktop-exchange?flow_id=${encodeURIComponent(flowId)}`,
             ),
-            { signal: controller.signal },
+            {
+              headers: {
+                "X-Agent-Native-Desktop-Verifier": verifier,
+              },
+              signal: controller.signal,
+            },
           );
           const data = await res.json();
           if (data?.error) {
-            clearInterval(desktopPollRef.current!);
-            desktopPollRef.current = null;
+            stopPoll();
             setDesktopAuthIssue(data);
           } else if (data?.token) {
-            clearInterval(desktopPollRef.current!);
-            desktopPollRef.current = null;
+            stopPoll();
             await fetch(
               agentNativePath(
                 `/_agent-native/auth/session?_session=${data.token}`,
@@ -176,13 +259,11 @@ export function GoogleConnectBanner({
             );
             window.location.reload();
           } else if (Date.now() - start > 120_000) {
-            clearInterval(desktopPollRef.current!);
-            desktopPollRef.current = null;
+            stopPoll();
           }
         } catch {
           if (Date.now() - start > 120_000) {
-            clearInterval(desktopPollRef.current!);
-            desktopPollRef.current = null;
+            stopPoll();
           }
         }
       } finally {
@@ -190,6 +271,7 @@ export function GoogleConnectBanner({
         desktopPollInFlightRef.current = false;
       }
     }, DESKTOP_POLL_INTERVAL_MS);
+    desktopPollRef.current = pollHandle;
   }
 
   const [authError, setAuthError] = useState<string | null>(null);

package/corpus/templates/mail/server/handlers/google-auth.ts

@@ -15,6 +15,9 @@ import {
   oauthCallbackResponse,
   oauthDesktopExchangePage,
   oauthErrorPage,
+  registerDesktopExchange,
+  prepareDesktopOAuthBrowserBinding,
+  matchesDesktopOAuthBrowserBinding,
   safeReturnPath,
   setDesktopExchange,
   setDesktopExchangeError,
@@ -22,6 +25,8 @@ import {
 import { getUserSetting, putUserSetting } from "@agent-native/core/settings";
 import {
   defineEventHandler,
+  getHeader,
+  getMethod,
   getQuery,
   setResponseStatus,
   type H3Event,
@@ -64,17 +69,25 @@ function googleOAuthErrorPayload(
     error?.name === "OAuthAccountOwnedByOtherUserError"
   ) {
     const account = error.accountId || "This Google account";
+    const message = `${account} is connected to another login. Sign out, then sign in with ${account}.`;
     return {
-      message: `${account} is already connected to another login. Sign out, then sign in with the login that originally connected it.`,
+      message,
       code: "account_owner_mismatch",
       accountId: error.accountId,
     };
   }
 
   const msg = error?.message || "Unknown error";
+  const statusCode = Number(error?.statusCode || error?.status || 0);
   const isPermission =
+    error?.oauthErrorCode === "access_denied" ||
+    error?.oauthErrorCode === "forbidden" ||
+    error?.oauthErrorCode === "insufficient_scope" ||
     msg.includes("Insufficient Permission") ||
-    msg.includes("insufficient_scope");
+    msg.includes("insufficient_scope") ||
+    /insufficient authentication scopes/i.test(msg) ||
+    (statusCode === 403 &&
+      /\b(?:scope|permission|forbidden|access denied)\b/i.test(msg));
   return {
     message: isPermission
       ? "This account wasn't granted the required permissions. Make sure you check all the permission boxes on the consent screen. If the app is in testing mode, add this email as a test user in Google Cloud Console."
@@ -99,6 +112,7 @@ function googleOAuthErrorResponse(
 export const getGoogleAuthUrl = defineEventHandler(async (event: H3Event) => {
   try {
     const q = getQuery(event);
+    const method = getMethod(event);
     const redirectUri = resolveOAuthRedirectUri(event);
     if (!redirectUri) {
       setResponseStatus(event, 400);
@@ -113,6 +127,34 @@ export const getGoogleAuthUrl = defineEventHandler(async (event: H3Event) => {
     const desktop =
       isElectron(event) || q.desktop === "1" || q.desktop === "true";
     const flowId = desktop ? (q.flow_id as string) || undefined : undefined;
+    if (method === "POST" && (!desktop || !flowId)) {
+      setResponseStatus(event, 400);
+      return { error: "Invalid desktop exchange challenge." };
+    }
+    let desktopVerifierHash: string | undefined;
+    let desktopBrowserBindingHash: string | undefined;
+    if (flowId) {
+      if (method !== "POST" || q.redirect !== undefined) {
+        setResponseStatus(event, 400);
+        return { error: "Invalid desktop exchange challenge." };
+      }
+      const verifier = getHeader(event, "x-agent-native-desktop-verifier");
+      if (!verifier || q.verifier !== undefined) {
+        setResponseStatus(event, 400);
+        return { error: "Invalid desktop exchange challenge." };
+      }
+      try {
+        desktopBrowserBindingHash = prepareDesktopOAuthBrowserBinding(event);
+        desktopVerifierHash = await registerDesktopExchange(
+          flowId,
+          verifier,
+          desktopBrowserBindingHash,
+        );
+      } catch {
+        setResponseStatus(event, 400);
+        return { error: "Invalid desktop exchange challenge." };
+      }
+    }
     const requestedReturn =
       typeof q.return === "string" ? safeReturnPath(q.return) : "/";
     const returnUrl = requestedReturn !== "/" ? requestedReturn : undefined;
@@ -127,6 +169,8 @@ export const getGoogleAuthUrl = defineEventHandler(async (event: H3Event) => {
       app: OAUTH_STATE_APP_ID,
       returnUrl,
       flowId,
+      desktopVerifierHash,
+      desktopBrowserBindingHash,
     });
     const url = await getAuthUrl(undefined, redirectUri, state, owner);
     if (q.redirect === "1") {
@@ -159,22 +203,28 @@ export const handleGoogleCallback = defineEventHandler(
       );
       desktop = state.desktop ?? false;
       flowId = state.flowId;
+      if (
+        flowId &&
+        (!state.desktopVerifierHash ||
+          !state.desktopBrowserBindingHash ||
+          !matchesDesktopOAuthBrowserBinding(
+            event,
+            state.desktopBrowserBindingHash,
+          ))
+      ) {
+        throw new Error("Desktop OAuth browser binding is invalid.");
+      }
 
       // Handle Google authorization errors (e.g. user denied access, invalid client)
       const googleError = query.error as string | undefined;
       if (googleError) {
         const errorDesc =
           (query.error_description as string | undefined) || googleError;
-        const isPermission =
-          googleError === "access_denied" ||
-          errorDesc.includes("Insufficient Permission");
-        const userMessage = isPermission
-          ? "Access was denied. Make sure to check all the permission boxes on the consent screen. If the app is in testing mode, add this email as a test user in Google Cloud Console."
-          : `Connection failed: ${errorDesc}`;
-        return googleOAuthErrorResponse(event, new Error(userMessage), {
-          desktop,
-          flowId,
-        });
+        return googleOAuthErrorResponse(
+          event,
+          Object.assign(new Error(errorDesc), { oauthErrorCode: googleError }),
+          { desktop, flowId },
+        );
       }
 
       const code = query.code as string;
@@ -183,7 +233,13 @@ export const handleGoogleCallback = defineEventHandler(
         return { error: "Missing authorization code" };
       }
 
-      const { redirectUri, owner: stateOwner, addAccount, returnUrl } = state;
+      const {
+        redirectUri,
+        owner: stateOwner,
+        addAccount,
+        returnUrl,
+        desktopVerifierHash,
+      } = state;
 
       // 1. Resolve owner (needs session context, before exchangeCode)
       const { owner, hasProductionSession } = await resolveOAuthOwner(
@@ -249,7 +305,15 @@ export const handleGoogleCallback = defineEventHandler(
           });
 
       if (flowId && sessionToken) {
-        setDesktopExchange(flowId, sessionToken, email);
+        if (!desktopVerifierHash) {
+          throw new Error("Missing desktop exchange challenge.");
+        }
+        await setDesktopExchange(
+          flowId,
+          sessionToken,
+          email,
+          desktopVerifierHash,
+        );
       }
 
       // 4. Return platform-appropriate response
@@ -284,6 +348,7 @@ export const getGoogleAddAccountUrl = defineEventHandler(
     }
     try {
       const q = getQuery(event);
+      const method = getMethod(event);
       const redirectUri = resolveOAuthRedirectUri(event);
       if (!redirectUri) {
         setResponseStatus(event, 400);
@@ -295,6 +360,34 @@ export const getGoogleAddAccountUrl = defineEventHandler(
       const desktop =
         isElectron(event) || q.desktop === "1" || q.desktop === "true";
       const flowId = desktop ? (q.flow_id as string) || undefined : undefined;
+      if (method === "POST" && (!desktop || !flowId)) {
+        setResponseStatus(event, 400);
+        return { error: "Invalid desktop exchange challenge." };
+      }
+      let desktopVerifierHash: string | undefined;
+      let desktopBrowserBindingHash: string | undefined;
+      if (flowId) {
+        if (method !== "POST" || q.redirect !== undefined) {
+          setResponseStatus(event, 400);
+          return { error: "Invalid desktop exchange challenge." };
+        }
+        const verifier = getHeader(event, "x-agent-native-desktop-verifier");
+        if (!verifier || q.verifier !== undefined) {
+          setResponseStatus(event, 400);
+          return { error: "Invalid desktop exchange challenge." };
+        }
+        try {
+          desktopBrowserBindingHash = prepareDesktopOAuthBrowserBinding(event);
+          desktopVerifierHash = await registerDesktopExchange(
+            flowId,
+            verifier,
+            desktopBrowserBindingHash,
+          );
+        } catch {
+          setResponseStatus(event, 400);
+          return { error: "Invalid desktop exchange challenge." };
+        }
+      }
       const state = encodeOAuthState({
         redirectUri,
         owner: session.email,
@@ -302,6 +395,8 @@ export const getGoogleAddAccountUrl = defineEventHandler(
         addAccount: true,
         app: OAUTH_STATE_APP_ID,
         flowId,
+        desktopVerifierHash,
+        desktopBrowserBindingHash,
       });
       const url = await getAuthUrl(
         undefined,
@@ -333,22 +428,28 @@ export const handleGoogleAddAccountCallback = defineEventHandler(
       );
       desktop = state.desktop ?? false;
       flowId = state.flowId;
+      if (
+        flowId &&
+        (!state.desktopVerifierHash ||
+          !state.desktopBrowserBindingHash ||
+          !matchesDesktopOAuthBrowserBinding(
+            event,
+            state.desktopBrowserBindingHash,
+          ))
+      ) {
+        throw new Error("Desktop OAuth browser binding is invalid.");
+      }
 
       // Handle Google authorization errors (e.g. user denied access, invalid client)
       const googleError = query.error as string | undefined;
       if (googleError) {
         const errorDesc =
           (query.error_description as string | undefined) || googleError;
-        const isPermission =
-          googleError === "access_denied" ||
-          errorDesc.includes("Insufficient Permission");
-        const userMessage = isPermission
-          ? "Access was denied. Make sure to check all the permission boxes on the consent screen. If the app is in testing mode, add this email as a test user in Google Cloud Console."
-          : `Connection failed: ${errorDesc}`;
-        return googleOAuthErrorResponse(event, new Error(userMessage), {
-          desktop,
-          flowId,
-        });
+        return googleOAuthErrorResponse(
+          event,
+          Object.assign(new Error(errorDesc), { oauthErrorCode: googleError }),
+          { desktop, flowId },
+        );
       }
 
       const { redirectUri, owner: stateOwner } = state;

package/corpus/templates/mail/server/lib/gmail-query.ts

@@ -6,8 +6,11 @@ import { isSelfAddressedThread } from "@shared/self-notes.js";
 import type { EmailMessage } from "@shared/types.js";
 
 export const VIEW_QUERIES: Record<string, string> = {
-  inbox: "in:inbox -in:sent",
-  unread: "is:unread in:inbox -in:sent",
+  // Keep sent replies in a matching Gmail thread. The local thread filter
+  // below excludes sent-only threads while preserving received inbox threads
+  // whose latest message was sent by the user.
+  inbox: "in:inbox",
+  unread: "is:unread in:inbox",
   starred: "is:starred",
   sent: "in:sent",
   drafts: "in:drafts",

package/corpus/templates/mail/server/routes/[base]/_agent-native/google/add-account/auth-url.post.ts

@@ -0,0 +1 @@
+export { default } from "../../../../_agent-native/google/add-account/auth-url.post.js";

package/corpus/templates/mail/server/routes/[base]/_agent-native/google/auth-url.post.ts

@@ -0,0 +1 @@
+export { default } from "../../../_agent-native/google/auth-url.post.js";

package/corpus/templates/mail/server/routes/_agent-native/google/add-account/auth-url.post.ts

@@ -0,0 +1 @@
+export { getGoogleAddAccountUrl as default } from "../../../../handlers/google-auth.js";