diff --git a/apps/mobile/src/features/home/HomeScreen.tsx b/apps/mobile/src/features/home/HomeScreen.tsx
index d1d108d3bed0..c57ac15b1ee5 100644
--- a/apps/mobile/src/features/home/HomeScreen.tsx
+++ b/apps/mobile/src/features/home/HomeScreen.tsx
@@ -1,7 +1,7 @@
 import { useAndroidControlSizing } from "../../components/useAndroidControlSizing";
 import type { ThreadMoveDestination } from "../threads/threadOrder";
 import { computeThreadMoveAvailability } from "../threads/threadOrder";
-import { LegendList } from "@legendapp/list/react-native";
+import { LegendList, type LegendListRef } from "@legendapp/list/react-native";
 import {
   type EnvironmentProject,
   type EnvironmentThreadShell,
@@ -18,7 +18,14 @@ import {
 import { useAtomValue } from "@effect/atom-react";
 import { useFocusEffect } from "@react-navigation/native";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { ActivityIndicator, Platform, View } from "react-native";
+import {
+  ActivityIndicator,
+  Platform,
+  View,
+  type GestureResponderEvent,
+  type NativeScrollEvent,
+  type NativeSyntheticEvent,
+} from "react-native";
 import type { SwipeableMethods } from "react-native-gesture-handler/ReanimatedSwipeable";
 import { useSafeAreaInsets } from "react-native-safe-area-context";
 
@@ -59,6 +66,7 @@ import {
   sortHomeProjectScopes,
   type HomeProjectSortOrder,
 } from "./homeThreadList";
+import { createSwipeRowActivation } from "./swipe-row-activation";
 import { SwipeableScrollGateProvider, useSwipeableScrollGate } from "./thread-swipe-actions";
 import { useMaterialFabScroll } from "./MaterialFabScrollContext";
 
@@ -266,8 +274,45 @@ export function HomeScreen(props: HomeScreenProps) {
     openSwipeableRef.current?.close();
   }, []);
   const onMaterialFabScroll = useMaterialFabScroll();
+  const listRef = useRef<LegendListRef>(null);
+  const swipeRowActivation = useMemo(() => createSwipeRowActivation(), []);
+  const activateVisibleRows = useCallback(
+    (rows: ReadonlyArray<ThreadListV2ListItem>) => {
+      const state = listRef.current?.getState();
+      if (state === undefined || !(state.end >= 0)) return;
+      swipeRowActivation.activate(
+        rows.slice(Math.max(0, state.start - 2), state.end + 3).map((row) => row.key),
+      );
+    },
+    [swipeRowActivation],
+  );
+  // Status-bar, accessibility and programmatic scrolls never arm the scroll
+  // gate, so every scroll also activates the visible rows once it settles.
+  const activationTimerRef = useRef<ReturnType<typeof setTimeout> | undefined>(undefined);
+  useEffect(() => () => clearTimeout(activationTimerRef.current), []);
+  const handleListScroll = useCallback(
+    (event: NativeSyntheticEvent<NativeScrollEvent>) => {
+      onMaterialFabScroll?.(event);
+      clearTimeout(activationTimerRef.current);
+      activationTimerRef.current = setTimeout(
+        () => activateVisibleRows(listRef.current?.getState().data ?? []),
+        200,
+      );
+    },
+    [activateVisibleRows, onMaterialFabScroll],
+  );
+  const trackListTouches = useCallback(
+    (event: GestureResponderEvent, started: boolean) => {
+      const { changedTouches, touches } = event.nativeEvent;
+      swipeRowActivation.trackTouches(
+        started ? changedTouches.map((touch) => touch.identifier) : [],
+        touches.map((touch) => touch.identifier),
+      );
+    },
+    [swipeRowActivation],
+  );
   const { swipeEnabled, scrollGateHandlers } = useSwipeableScrollGate({
-    onScroll: onMaterialFabScroll,
+    onScroll: handleListScroll,
     onScrollBeginDrag: handleScrollBeginDrag,
   });
 
@@ -657,6 +702,9 @@ export function HomeScreen(props: HomeScreenProps) {
   );
 
   useThreadJumpShortcuts(threadListV2Items, props.onSelectThread);
+  useEffect(() => {
+    if (swipeEnabled) activateVisibleRows(threadListV2Items);
+  }, [activateVisibleRows, swipeEnabled, threadListV2Items]);
 
   const renderV2Item = useCallback(
     ({ item }: { readonly item: ThreadListV2ListItem }) => {
@@ -764,6 +812,7 @@ export function HomeScreen(props: HomeScreenProps) {
           onMoveThread={handleMoveThread}
           onSwipeableClose={handleSwipeableClose}
           onSwipeableWillOpen={handleSwipeableWillOpen}
+          activationKey={item.key}
         />
       );
     },
@@ -952,8 +1001,13 @@ export function HomeScreen(props: HomeScreenProps) {
         {/* Shared with the iPad sidebar: cells are reused across data
             rebuilds and `itemsAreEqual` keeps a minute tick (or an unrelated
             shell update) from re-rendering untouched rows. */}
-        <SwipeableScrollGateProvider enabled={swipeEnabled}>
+        <SwipeableScrollGateProvider enabled={swipeEnabled} activation={swipeRowActivation}>
           <LegendList
+            ref={listRef}
+            onLoad={() => activateVisibleRows(threadListV2Items)}
+            onTouchStart={(event) => trackListTouches(event, true)}
+            onTouchEnd={(event) => trackListTouches(event, false)}
+            onTouchCancel={(event) => trackListTouches(event, false)}
             data={threadListV2Items}
             renderItem={renderV2Item}
             keyExtractor={v2KeyExtractor}
diff --git a/apps/mobile/src/features/home/swipe-row-activation.test.ts b/apps/mobile/src/features/home/swipe-row-activation.test.ts
new file mode 100644
index 000000000000..43f8dcf0ca7e
--- /dev/null
+++ b/apps/mobile/src/features/home/swipe-row-activation.test.ts
@@ -0,0 +1,68 @@
+import { describe, expect, it, vi } from "vite-plus/test";
+
+import { createSwipeRowActivation } from "./swipe-row-activation";
+
+describe("createSwipeRowActivation", () => {
+  it("activates exactly the requested rows and notifies only on change", () => {
+    const activation = createSwipeRowActivation();
+    const listener = vi.fn();
+    activation.subscribe(listener);
+
+    activation.activate(["a", "b"]);
+    activation.activate(["b", "a"]);
+
+    expect(activation.isActive("a")).toBe(true);
+    expect(activation.isActive("c")).toBe(false);
+    expect(listener).toHaveBeenCalledTimes(1);
+
+    activation.activate(["c"]);
+    expect(activation.isActive("a")).toBe(false);
+    expect(activation.isActive("c")).toBe(true);
+    expect(listener).toHaveBeenCalledTimes(2);
+  });
+
+  it("defers changes while a finger is on the list so a press is never remounted", () => {
+    const activation = createSwipeRowActivation();
+    activation.activate(["a"]);
+
+    activation.trackTouches(["1"], ["1"]);
+    activation.activate(["b"]);
+    activation.activate(["c"]);
+    expect(activation.isActive("a")).toBe(true);
+    expect(activation.isActive("c")).toBe(false);
+
+    activation.trackTouches([], []);
+    expect(activation.isActive("a")).toBe(false);
+    expect(activation.isActive("b")).toBe(false);
+    expect(activation.isActive("c")).toBe(true);
+  });
+
+  it("ignores fingers that did not start on the list", () => {
+    const activation = createSwipeRowActivation();
+    activation.trackTouches(["1"], ["1", "2"]);
+    activation.activate(["a"]);
+
+    // The list finger lifts while finger 2 stays on another control.
+    activation.trackTouches([], ["2"]);
+    expect(activation.isActive("a")).toBe(true);
+  });
+
+  it("drops a list finger whose end event never arrived", () => {
+    const activation = createSwipeRowActivation();
+    activation.trackTouches(["1"], ["1"]);
+    activation.activate(["a"]);
+
+    activation.trackTouches(["2"], ["2"]);
+    activation.trackTouches([], []);
+    expect(activation.isActive("a")).toBe(true);
+  });
+
+  it("stops notifying after unsubscribe", () => {
+    const activation = createSwipeRowActivation();
+    const listener = vi.fn();
+    const unsubscribe = activation.subscribe(listener);
+    unsubscribe();
+    activation.activate(["a"]);
+    expect(listener).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/mobile/src/features/home/swipe-row-activation.ts b/apps/mobile/src/features/home/swipe-row-activation.ts
new file mode 100644
index 000000000000..d56d12cba56f
--- /dev/null
+++ b/apps/mobile/src/features/home/swipe-row-activation.ts
@@ -0,0 +1,62 @@
+import { createContext, use, useSyncExternalStore } from "react";
+
+/**
+ * Full swipe rows (pan gesture, animated actions, hidden action buttons) only
+ * exist around the viewport. Every other Home row renders a dormant frame that
+ * paints the same content with a fraction of the native views, so a row the
+ * list rebuilds while scrolling is cheap. The scroll gate already disables
+ * swipes while the list moves, so rows are activated once it rests.
+ */
+export function createSwipeRowActivation() {
+  let activeKeys = new Set<string>();
+  // Swapping a row's frame remounts it, which would cancel a press or long
+  // press in progress, so changes wait until every finger that started on the
+  // list has lifted.
+  const listTouches = new Set<string>();
+  let pendingKeys: ReadonlyArray<string> | null = null;
+  const listeners = new Set<() => void>();
+  const apply = (keys: ReadonlyArray<string>) => {
+    if (keys.length === activeKeys.size && keys.every((key) => activeKeys.has(key))) return;
+    activeKeys = new Set(keys);
+    for (const listener of listeners) listener();
+  };
+  return {
+    subscribe(listener: () => void) {
+      listeners.add(listener);
+      return () => void listeners.delete(listener);
+    },
+    isActive: (key: string) => activeKeys.has(key),
+    activate(keys: ReadonlyArray<string>) {
+      if (listTouches.size > 0) pendingKeys = keys;
+      else apply(keys);
+    },
+    /**
+     * `started` are touches that just began on the list; `onScreen` is every
+     * finger still down anywhere. A finger on another control never holds
+     * changes, and one whose end event went missing is dropped here.
+     */
+    trackTouches(started: ReadonlyArray<string>, onScreen: ReadonlyArray<string>) {
+      for (const id of started) listTouches.add(id);
+      for (const id of listTouches) if (!onScreen.includes(id)) listTouches.delete(id);
+      if (listTouches.size > 0 || pendingKeys === null) return;
+      const keys = pendingKeys;
+      pendingKeys = null;
+      apply(keys);
+    },
+  };
+}
+
+export type SwipeRowActivation = ReturnType<typeof createSwipeRowActivation>;
+
+export const SwipeRowActivationContext = createContext<SwipeRowActivation | null>(null);
+
+const subscribeNever = () => () => {};
+
+/** Rows outside an activation provider (e.g. the iPad sidebar) stay live. */
+export function useSwipeRowDormant(key: string | undefined): boolean {
+  const activation = use(SwipeRowActivationContext);
+  return useSyncExternalStore(
+    activation?.subscribe ?? subscribeNever,
+    () => activation !== null && key !== undefined && !activation.isActive(key),
+  );
+}
diff --git a/apps/mobile/src/features/home/thread-swipe-actions.tsx b/apps/mobile/src/features/home/thread-swipe-actions.tsx
index 44f3c36e6655..e62935c28861 100644
--- a/apps/mobile/src/features/home/thread-swipe-actions.tsx
+++ b/apps/mobile/src/features/home/thread-swipe-actions.tsx
@@ -40,6 +40,7 @@ import Animated, {
 } from "react-native-reanimated";
 
 import { AppText as Text } from "../../components/AppText";
+import { SwipeRowActivationContext, type SwipeRowActivation } from "./swipe-row-activation";
 import { registerThreadDismissal } from "./thread-dismissal";
 
 // Wide enough for the longest action label ("Unarchive").
@@ -129,11 +130,14 @@ const SwipeableScrollGateContext = createContext(true);
 
 export function SwipeableScrollGateProvider(props: {
   readonly enabled: boolean;
+  readonly activation?: SwipeRowActivation;
   readonly children: ReactNode;
 }) {
   return (
     <SwipeableScrollGateContext.Provider value={props.enabled}>
-      {props.children}
+      <SwipeRowActivationContext value={props.activation ?? null}>
+        {props.children}
+      </SwipeRowActivationContext>
     </SwipeableScrollGateContext.Provider>
   );
 }
@@ -260,13 +264,32 @@ interface ThreadSwipeableProps {
    * open/mid-drag state can't leak onto another row.
    */
   readonly resetKey?: string;
+  /** Paints the row without swipe machinery; see swipe-row-activation. */
+  readonly dormant?: boolean;
   readonly simultaneousWithExternalGesture?: ComponentProps<
     typeof ReanimatedSwipeable
   >["simultaneousWithExternalGesture"];
   readonly threadTitle: string;
 }
 
+const closeDormant = () => {};
+
 export function ThreadSwipeable(props: ThreadSwipeableProps) {
+  if (props.dormant) {
+    // Mirrors ReanimatedSwipeable's container and children views.
+    return (
+      <View
+        style={[
+          { overflow: "hidden", backgroundColor: props.backgroundColor },
+          props.containerStyle,
+        ]}
+      >
+        <View style={{ backgroundColor: props.backgroundColor }}>
+          {props.children(closeDormant)}
+        </View>
+      </View>
+    );
+  }
   // Recycled content gets fresh native and animation state. Late callbacks
   // from the previous row retain its action, never the replacement's action.
   return <ThreadSwipeableRow key={props.resetKey} {...props} />;
diff --git a/apps/mobile/src/features/threads/thread-list-v2-items.tsx b/apps/mobile/src/features/threads/thread-list-v2-items.tsx
index 31039388dc09..eb089b95060a 100644
--- a/apps/mobile/src/features/threads/thread-list-v2-items.tsx
+++ b/apps/mobile/src/features/threads/thread-list-v2-items.tsx
@@ -35,6 +35,7 @@ import { copyTextWithHaptic } from "../../lib/copyTextWithHaptic";
 import { useUniwindTheme } from "../../lib/useUniwindTheme";
 import type { PendingNewTask } from "../../state/use-pending-new-tasks";
 import { useThreadPr } from "../../state/use-thread-pr";
+import { useSwipeRowDormant } from "../home/swipe-row-activation";
 import { ThreadSwipeable } from "../home/thread-swipe-actions";
 import { buildThreadTitleRegenerationMenuItems } from "./thread-title-regeneration-menu";
 import {
@@ -518,6 +519,8 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: {
   readonly canMoveDown?: boolean;
   readonly onSwipeableWillOpen: (methods: SwipeableMethods) => void;
   readonly onSwipeableClose: (methods: SwipeableMethods) => void;
+  /** List key checked against the Home swipe row activation. */
+  readonly activationKey?: string;
   readonly searchMatch?: EnvironmentThreadSearchMatch;
   readonly searchQuery?: string;
   readonly simultaneousSwipeGesture?: ComponentProps<
@@ -545,6 +548,7 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: {
   } = props;
   const snoozedRow = props.snoozed === true;
   const pinnedRow = props.pinned === true;
+  const dormant = useSwipeRowDormant(props.activationKey);
 
   const pr = useThreadPr(thread);
 
@@ -1180,6 +1184,7 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: {
         <CustomSnoozeSheet onClose={() => setCustomSnoozeOpen(false)} onSnooze={handleSnooze} />
       )}
       <ThreadSwipeable
+        dormant={dormant}
         threadKey={`${thread.environmentId}:${thread.id}`}
         backgroundColor={rowAppearance.swipeBackgroundColor}
         compactActions={variant === "slim"}