Merge upstream/main (5 commits, 2026-10-27) into mtcode

Follows upstream's "new design is the only design" (pingdotgg#25778): the fork drops
redesignEnabled with it and keeps its own settings rows. The agent context
budget takes the smaller MCP tool list from pingdotgg#25790.

Also declares zod as a server dependency. @cursor/sdk 1.0.38 made zod a peer
dependency, and the desktop stage's production install does not add peers,
so the packaged server failed to start with "Cannot find module 'zod/v4'"
(the Linux smoke test caught it and stopped the 0.1.40 release).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: sheehanmunim

apps/desktop/src/window/DesktopWindow.ts

@@ -137,7 +137,7 @@ function getIconOption(
 }
 
 function getInitialWindowBackgroundColor(shouldUseDarkColors: boolean): string {
-  return shouldUseDarkColors ? "#0a0a0a" : "#ffffff";
+  return shouldUseDarkColors ? "#000000" : "#ffffff";
 }
 
 type DisplayBounds = Pick<Electron.Rectangle, "x" | "y" | "width" | "height">;

apps/mobile/src/App.tsx

@@ -9,9 +9,12 @@ import { GestureHandlerRootView } from "react-native-gesture-handler";
 import { KeyboardProvider } from "react-native-keyboard-controller";
 import { SafeAreaProvider } from "react-native-safe-area-context";
 import {
+  CommonActions,
+  createPathConfigForStaticNavigation,
   createStaticNavigation,
   getActionFromState,
   getStateFromPath,
+  type NavigationAction,
   type NavigationState,
 } from "@react-navigation/native";
 
@@ -28,12 +31,20 @@ import {
   presentPendingIncomingShare,
   startIncomingShareInbox,
 } from "./features/sharing/IncomingShareProvider";
+import {
+  installAgentNotificationNavigation,
+  setAgentNotificationPathname,
+} from "./features/agent-awareness/notificationNavigation";
+import {
+  installAppShortcuts,
+  recordAppShortcutNavigationState,
+} from "./features/shortcuts/appShortcutsRuntime";
 import {
   AppearancePreferencesProvider,
   installAppearanceRuntime,
   useAppearancePreferences,
 } from "./features/settings/appearance/AppearancePreferencesProvider";
-import { RootStack } from "./Stack";
+import { RootStack, workspaceLocationFromState } from "./Stack";
 import { appAtomRegistry } from "./state/atom-registry";
 import { subscribeComposerDraftModelReconciliation } from "./state/use-composer-drafts";
 import { environmentThreadShells } from "./state/threads";
@@ -61,7 +72,12 @@ import {
 } from "./features/workspace/workspace-selection-store";
 import { workspaceDetailLinkAction } from "./features/workspace/workspace-detail-selection";
 import { NativeLayoutMetricsProvider } from "./native/native-layout-metrics";
-import { attachRootNavigation, rootNavigationRef } from "./lib/rootNavigation";
+import {
+  attachRootNavigation,
+  flushRootNavigationQueue,
+  linkToRootPath,
+  rootNavigationRef,
+} from "./lib/rootNavigation";
 import { pruneNewTaskBranchCheckouts } from "./features/threads/NewTaskDraftRouteScreen";
 
 import "../global.css";
@@ -73,6 +89,20 @@ if (process.env.EXPO_PUBLIC_SHOWCASE === "1") {
 void SplashScreen.preventAutoHideAsync().catch(() => {});
 void hydrateWorkspaceSelections();
 
+const linkingConfig = {
+  initialRouteName: "Home",
+  screens: createPathConfigForStaticNavigation(RootStack, { initialRouteName: "Home" }) ?? {},
+} as const;
+
+function getAppStateFromPath(path: string, options: Parameters<typeof getStateFromPath>[1]) {
+  return takeScheduledTaskNewLink(
+    restoreSettingsLinkState(
+      restoreDraftLinkState(getStateFromPath(path, options), path),
+      settingsLinkPage(),
+    ),
+  );
+}
+
 const appLinking = {
   prefixes: [
     Linking.createURL("/"),
@@ -91,25 +121,33 @@ const appLinking = {
     // Our router handles the selection; React Navigation's type only lists its own actions.
     (workspaceDetailLinkAction(state) as ReturnType<typeof getActionFromState>) ??
     getActionFromState(state, options),
-  getStateFromPath: (path: string, options: Parameters<typeof getStateFromPath>[1]) =>
-    takeScheduledTaskNewLink(
-      restoreSettingsLinkState(
-        restoreDraftLinkState(getStateFromPath(path, options), path),
-        settingsLinkPage(),
-      ),
-    ),
+  getStateFromPath: getAppStateFromPath,
 };
 
+function appLinkAction(href: string): NavigationAction {
+  const state = getAppStateFromPath(href, linkingConfig);
+  if (!state) throw new Error(`Failed to parse the href to a navigation state (${href}).`);
+  return appLinking.getActionFromState(state, linkingConfig) ?? CommonActions.reset(state);
+}
+
+function linkToAppPath(href: string): void {
+  linkToRootPath(href, appLinkAction);
+}
+
 const Navigation = createStaticNavigation(RootStack);
 
 function handleNavigationStateChange(state: NavigationState | undefined): void {
   recordWorkspaceSelections(state);
-  if (state) pruneNewTaskBranchCheckouts(state);
   presentPendingIncomingShare();
+  if (!state) return;
+  setAgentNotificationPathname(workspaceLocationFromState(state).pathname);
+  recordAppShortcutNavigationState(state);
+  pruneNewTaskBranchCheckouts(state);
 }
 
 function handleNavigationReady(): void {
   handleNavigationStateChange(rootNavigationRef.getRootState());
+  flushRootNavigationQueue();
 }
 
 declare const module: { readonly hot?: FoundationHotModule } | undefined;
@@ -128,6 +166,8 @@ const appServiceDisposers = [
   installThreadOutboxDelivery(),
   installComposerAttachmentUploads(),
   startIncomingShareInbox(),
+  installAgentNotificationNavigation(linkToAppPath),
+  installAppShortcuts(linkToAppPath),
 ];
 disposeOnFoundationReplace(typeof module === "undefined" ? undefined : module.hot, () => {
   for (const dispose of appServiceDisposers) dispose();

apps/mobile/src/Stack.tsx

@@ -25,6 +25,11 @@ import { getCompactBrandHeaderOptions } from "./components/CompactBrandTitle";
 import { getConnectName } from "./lib/branding";
 import { WorkspaceConnectionStatusProvider } from "./features/home/WorkspaceConnectionTitle";
 import { WorkspaceRootScreen } from "./features/workspace/WorkspaceRootScreen";
+import {
+  recordHomeFocus,
+  recordHomeTransitionEnd,
+  recordHomeTransitionStart,
+} from "./features/home/home-route-visibility";
 import { AndroidWorkspaceTabsProvider } from "./features/workspace/AndroidWorkspaceTabsProvider";
 import {
   PullRequestRouteScreen,
@@ -42,9 +47,7 @@ import {
   type RenderFailureProps,
 } from "./components/RenderErrorBoundary";
 import { ArchivedThreadsRouteScreen } from "./features/archive/ArchivedThreadsRouteScreen";
-import { useAgentNotificationNavigation } from "./features/agent-awareness/notificationNavigation";
 import { ConnectOnboardingRouteScreen } from "./features/cloud/ConnectOnboardingRouteScreen";
-import { useConnectOnboardingNavigation } from "./features/cloud/connectOnboardingNavigation";
 import { AttachmentFileScreen } from "./features/files/AttachmentFileScreen";
 import { ThreadFilesTreeScreen, ThreadFileScreen } from "./features/files/ThreadFilesRouteScreen";
 import { AdaptiveWorkspaceLayout } from "./features/layout/AdaptiveWorkspaceLayout";
@@ -141,7 +144,6 @@ import {
   SettingsLegalDocumentCloseHeaderButton,
   SettingsLegalDocumentExternalHeaderButton,
 } from "./features/settings/components/SettingsLegalDocumentRouteScreen";
-import { useAppShortcuts } from "./features/shortcuts/useAppShortcuts";
 import { NATIVE_LIQUID_GLASS_SUPPORTED } from "./native/native-glass";
 import { deriveLayout } from "./lib/layout";
 import { useNativeLayoutMetrics } from "./native/native-layout-metrics";
@@ -484,7 +486,7 @@ const SETTINGS_SCREENS = {
 // iOS 26 header morphing requires one UINavigationBar; nested stacks make the whole screen slide.
 const THREAD_LINKING_PREFIX = "threads/:environmentId/:threadId";
 
-function workspaceLocationFromState(state: NavigationState) {
+export function workspaceLocationFromState(state: NavigationState) {
   const routes = state.routes.filter((route) => !isWorkspaceOverlayRoute(route.name));
   const effectiveState =
     routes.length > 0 && routes.length !== state.routes.length
@@ -516,9 +518,6 @@ function RootStackLayout(props: {
   const routeDraftId = Array.isArray(draftParams?.draftId)
     ? draftParams.draftId[0]
     : draftParams?.draftId;
-  useAgentNotificationNavigation(workspaceLocation.pathname);
-  useConnectOnboardingNavigation();
-  useAppShortcuts(props.state);
 
   return (
     <NewTaskFlowProvider active={isDraftThreadRoute(draftRoute)} routeDraftId={routeDraftId}>
@@ -603,6 +602,11 @@ const RootStackConfig = createWorkspaceStackNavigator({
     Home: createNativeStackScreen({
       screen: WorkspaceRootScreen,
       linking: "",
+      listeners: {
+        transitionStart: ({ data }) => recordHomeTransitionStart(data.closing),
+        transitionEnd: ({ data }) => recordHomeTransitionEnd(data.closing),
+        focus: recordHomeFocus,
+      },
       options: {
         ...GLASS_HEADER_OPTIONS,
         ...FIXED_DUO_HEADER,

apps/mobile/src/features/agent-awareness/notificationNavigation.ts

@@ -1,50 +1,42 @@
-import { useEffect, useLayoutEffect, useRef } from "react";
 import * as Notifications from "expo-notifications";
-import { useLinkTo } from "@react-navigation/native";
 
 import { setAndroidThreadOnScreen } from "./androidNotifications";
 import { foregroundNotificationBehavior } from "./foregroundNotificationBehavior";
 import { routeAgentNotificationResponseOnce, threadDeepLinkOnScreen } from "./notificationPayload";
 import { consumeLastAgentNotificationResponse } from "./notificationResponseConsumer";
 
-export function useAgentNotificationNavigation(pathname: string): void {
-  const linkTo = useLinkTo();
-  const handledResponseIds = useRef(new Set<string>());
-  const deepLinkOnScreen = useRef<string | null>(null);
-  useLayoutEffect(() => {
-    const thread = threadDeepLinkOnScreen(pathname);
-    deepLinkOnScreen.current = thread;
-    setAndroidThreadOnScreen(thread);
-  }, [pathname]);
+let deepLinkOnScreen: string | null = null;
 
-  useEffect(() => {
-    Notifications.setNotificationHandler({
-      handleNotification: (notification) =>
-        Promise.resolve(foregroundNotificationBehavior(notification, deepLinkOnScreen.current)),
-    });
-    return () => {
-      Notifications.setNotificationHandler(null);
-    };
-  }, []);
+/** Called with the workspace pathname on every root navigation state change. */
+export function setAgentNotificationPathname(pathname: string): void {
+  deepLinkOnScreen = threadDeepLinkOnScreen(pathname);
+  setAndroidThreadOnScreen(deepLinkOnScreen);
+}
 
-  useEffect(() => {
-    const handleResponse = (response: Notifications.NotificationResponse): void => {
-      routeAgentNotificationResponseOnce({
-        handledResponseIds: handledResponseIds.current,
-        response,
-        navigate: linkTo,
-      });
-    };
+/**
+ * App-lifetime notification routing: foreground presentation suppresses the
+ * thread already on screen, and taps (including the cold-start tap) open the
+ * notification's deep link through `navigate`.
+ */
+export function installAgentNotificationNavigation(navigate: (href: string) => void): () => void {
+  const handledResponseIds = new Set<string>();
+  Notifications.setNotificationHandler({
+    handleNotification: (notification) =>
+      Promise.resolve(foregroundNotificationBehavior(notification, deepLinkOnScreen)),
+  });
 
-    const subscription = Notifications.addNotificationResponseReceivedListener(handleResponse);
-    void consumeLastAgentNotificationResponse({
-      getLastResponse: () => Notifications.getLastNotificationResponseAsync(),
-      clearLastResponse: () => Notifications.clearLastNotificationResponseAsync(),
-      handleResponse,
-    });
+  const handleResponse = (response: Notifications.NotificationResponse): void => {
+    routeAgentNotificationResponseOnce({ handledResponseIds, response, navigate });
+  };
+  const subscription = Notifications.addNotificationResponseReceivedListener(handleResponse);
+  void consumeLastAgentNotificationResponse({
+    getLastResponse: () => Notifications.getLastNotificationResponseAsync(),
+    clearLastResponse: () => Notifications.clearLastNotificationResponseAsync(),
+    handleResponse,
+  });
 
-    return () => {
-      subscription.remove();
-    };
-  }, [linkTo]);
+  return () => {
+    subscription.remove();
+    Notifications.setNotificationHandler(null);
+  };
 }

apps/mobile/src/features/cloud/connectOnboarding.test.ts

@@ -0,0 +1,74 @@
+import { afterEach, describe, expect, it, vi } from "vite-plus/test";
+
+const navigation = vi.hoisted(() => ({
+  navigate: vi.fn(),
+  ready: true,
+  queue: [] as Array<() => void>,
+}));
+const optOut = vi.hoisted(() => ({ optedOut: new Set<string>() }));
+
+vi.mock("../../lib/rootNavigation", () => ({
+  rootNavigationRef: navigation,
+  whenRootNavigationReady: (navigate: () => void) =>
+    navigation.ready ? navigate() : navigation.queue.push(navigate),
+}));
+vi.mock("./connectOnboardingOptOut", () => ({
+  isConnectOnboardingOptedOut: (accountId: string) =>
+    Promise.resolve(optOut.optedOut.has(accountId)),
+}));
+
+import { clearConnectOnboardingRequest, requestConnectOnboarding } from "./connectOnboarding";
+
+afterEach(() => {
+  clearConnectOnboardingRequest();
+  optOut.optedOut.clear();
+  navigation.navigate.mockReset();
+  navigation.ready = true;
+  navigation.queue.length = 0;
+  vi.useRealTimers();
+});
+
+describe("requestConnectOnboarding", () => {
+  it("presents the sheet after the settle delay", async () => {
+    vi.useFakeTimers();
+    requestConnectOnboarding("account-1");
+    await vi.advanceTimersByTimeAsync(599);
+    expect(navigation.navigate).not.toHaveBeenCalled();
+    await vi.advanceTimersByTimeAsync(1);
+    expect(navigation.navigate).toHaveBeenCalledExactlyOnceWith("ConnectOnboarding");
+  });
+
+  it("drops a request cleared by sign-out before it fires", async () => {
+    vi.useFakeTimers();
+    requestConnectOnboarding("account-1");
+    clearConnectOnboardingRequest();
+    await vi.runAllTimersAsync();
+    expect(navigation.navigate).not.toHaveBeenCalled();
+  });
+
+  it("skips accounts that opted out", async () => {
+    vi.useFakeTimers();
+    optOut.optedOut.add("account-1");
+    requestConnectOnboarding("account-1");
+    await vi.runAllTimersAsync();
+    expect(navigation.navigate).not.toHaveBeenCalled();
+  });
+
+  it("presents once when a newer request replaces a pending one", async () => {
+    vi.useFakeTimers();
+    requestConnectOnboarding("account-1");
+    requestConnectOnboarding("account-2");
+    await vi.runAllTimersAsync();
+    expect(navigation.navigate).toHaveBeenCalledOnce();
+  });
+
+  it("drops a request cleared while it waits for navigation to be ready", async () => {
+    vi.useFakeTimers();
+    navigation.ready = false;
+    requestConnectOnboarding("account-1");
+    await vi.runAllTimersAsync();
+    clearConnectOnboardingRequest();
+    for (const navigate of navigation.queue.splice(0)) navigate();
+    expect(navigation.navigate).not.toHaveBeenCalled();
+  });
+});