diff --git a/apps/mobile/src/components/organization/members-list-items.test.ts b/apps/mobile/src/components/organization/members-list-items.test.ts
new file mode 100644
index 0000000000..10678db35c
--- /dev/null
+++ b/apps/mobile/src/components/organization/members-list-items.test.ts
@@ -0,0 +1,100 @@
+import { describe, expect, it } from 'vitest';
+
+import { type ActiveOrgMember, type InvitedOrgMember } from '@/lib/hooks/use-organization-queries';
+
+import { buildMembersListItems } from './members-list-items';
+
+function activeMember(id: string): ActiveOrgMember {
+  return {
+    id,
+    name: `Member ${id}`,
+    email: `${id}@example.com`,
+    role: 'member',
+    status: 'active',
+    inviteDate: null,
+    dailyUsageLimitUsd: null,
+    currentDailyUsageUsd: null,
+  };
+}
+
+function invitedMember(id: string): InvitedOrgMember {
+  return {
+    email: `${id}@example.com`,
+    role: 'member',
+    inviteDate: null,
+    inviteToken: `token-${id}`,
+    inviteId: `invite-${id}`,
+    status: 'invited',
+    inviteUrl: `https://example.com/invite/${id}`,
+    emailStatus: null,
+    dailyUsageLimitUsd: null,
+    currentDailyUsageUsd: null,
+  };
+}
+
+describe('buildMembersListItems', () => {
+  it('returns [] when both lists are empty', () => {
+    expect(buildMembersListItems({ activeMembers: [], invitedMembers: [] })).toEqual([]);
+  });
+
+  it('builds members only with a Members section and a last flag', () => {
+    const items = buildMembersListItems({
+      activeMembers: [activeMember('a'), activeMember('b')],
+      invitedMembers: [],
+    });
+    expect(items).toEqual([
+      { kind: 'section', title: 'Members' },
+      { kind: 'member', member: activeMember('a'), last: false },
+      { kind: 'member', member: activeMember('b'), last: true },
+    ]);
+  });
+
+  it('builds members plus invites with both sections and correct last flags', () => {
+    const items = buildMembersListItems({
+      activeMembers: [activeMember('a')],
+      invitedMembers: [invitedMember('i1'), invitedMember('i2')],
+    });
+    expect(items).toEqual([
+      { kind: 'section', title: 'Members' },
+      { kind: 'member', member: activeMember('a'), last: true },
+      { kind: 'section', title: 'Pending invitations' },
+      { kind: 'invite', invite: invitedMember('i1'), last: false },
+      { kind: 'invite', invite: invitedMember('i2'), last: true },
+    ]);
+  });
+
+  it('omits the Pending invitations header when there are no invites', () => {
+    const items = buildMembersListItems({
+      activeMembers: [activeMember('a')],
+      invitedMembers: [],
+    });
+    expect(
+      items.some(item => item.kind === 'section' && item.title === 'Pending invitations')
+    ).toBe(false);
+    expect(items.some(item => item.kind === 'invite')).toBe(false);
+  });
+
+  it('starts with members-empty when there are no active members but invites exist', () => {
+    const items = buildMembersListItems({
+      activeMembers: [],
+      invitedMembers: [invitedMember('i1')],
+    });
+    expect(items[0]).toEqual({ kind: 'members-empty' });
+    expect(items).toEqual([
+      { kind: 'members-empty' },
+      { kind: 'section', title: 'Pending invitations' },
+      { kind: 'invite', invite: invitedMember('i1'), last: true },
+    ]);
+  });
+
+  it('flags the final row of each group as last', () => {
+    const items = buildMembersListItems({
+      activeMembers: [activeMember('a'), activeMember('b')],
+      invitedMembers: [invitedMember('i1')],
+    });
+    const members = items.filter(item => item.kind === 'member');
+    const invites = items.filter(item => item.kind === 'invite');
+    expect(members.map(item => item.last)).toEqual([false, true]);
+    expect(invites.map(item => item.last)).toEqual([true]);
+  });
+});
diff --git a/apps/mobile/src/components/organization/members-list-items.ts b/apps/mobile/src/components/organization/members-list-items.ts
new file mode 100644
index 0000000000..eb1156bb6a
--- /dev/null
+++ b/apps/mobile/src/components/organization/members-list-items.ts
@@ -0,0 +1,55 @@
+// Pure builder for the organization Members screen's FlashList items.
+//
+// One flat array drives a single FlashList. The composition rules are exact so
+// the empty state can never go missing:
+//
+//   - both lists empty        -> `[]` (the list renders `ListEmptyComponent`)
+//   - active members present  -> `section: 'Members'` + one `member` row each
+//   - no active, invites      -> `members-empty` + the invites section
+//   - invites present         -> `section: 'Pending invitations'` + one
+//                                `invite` row each
+//
+// `last` marks the final row of each group so the existing hairline rule is
+// preserved.
+
+import { type ActiveOrgMember, type InvitedOrgMember } from '@/lib/hooks/use-organization-queries';
+
+export type MembersListItem =
+  | { kind: 'section'; title: string }
+  | { kind: 'members-empty' }
+  | { kind: 'member'; member: ActiveOrgMember; last: boolean }
+  | { kind: 'invite'; invite: InvitedOrgMember; last: boolean };
+
+export function buildMembersListItems(args: {
+  activeMembers: ActiveOrgMember[];
+  invitedMembers: InvitedOrgMember[];
+}): MembersListItem[] {
+  const { activeMembers, invitedMembers } = args;
+  const items: MembersListItem[] = [];
+
+  if (activeMembers.length > 0) {
+    items.push({ kind: 'section', title: 'Members' });
+    for (const [index, member] of activeMembers.entries()) {
+      items.push({
+        kind: 'member',
+        member,
+        last: index === activeMembers.length - 1,
+      });
+    }
+  } else if (invitedMembers.length > 0) {
+    items.push({ kind: 'members-empty' });
+  }
+
+  if (invitedMembers.length > 0) {
+    items.push({ kind: 'section', title: 'Pending invitations' });
+    for (const [index, invite] of invitedMembers.entries()) {
+      items.push({
+        kind: 'invite',
+        invite,
+        last: index === invitedMembers.length - 1,
+      });
+    }
+  }
+
+  return items;
+}
diff --git a/apps/mobile/src/components/organization/members-screen.mounted.test.tsx b/apps/mobile/src/components/organization/members-screen.mounted.test.tsx
new file mode 100644
index 0000000000..e9684dcd36
--- /dev/null
+++ b/apps/mobile/src/components/organization/members-screen.mounted.test.tsx
@@ -0,0 +1,169 @@
+/* eslint-disable typescript-eslint/no-deprecated -- react-test-renderer is the DOM-free renderer used to mount React/RN trees under vitest (node env, no jsdom); same pattern as src/test/render-with-providers.tsx. */
+
+// Screen-level empty-state precedence regression: when the member query errors
+// with no data, both member arrays are empty, so the list's empty component
+// must render the QueryError — not "No members yet". The item builder and the
+// error selector are unit-tested separately; this proves the loading → error →
+// empty precedence in the screen JSX itself.
+
+import { type ComponentType, createElement, type ReactElement } from 'react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { renderWithProviders } from '@/test/render-with-providers';
+
+import { OrganizationMembersScreen } from './members-screen';
+
+const withMembersQuery = vi.hoisted(() => ({
+  data: undefined as unknown,
+  isLoading: false,
+  isFetching: false,
+  isError: false,
+  error: null as unknown,
+  refetch: vi.fn(),
+}));
+
+vi.mock('@/lib/hooks/use-organization-queries', () => ({
+  isMoneyRole: () => true,
+  useOrgBoundary: () => ({
+    organizationId: 'org-1',
+    role: 'owner',
+    org: { organizationId: 'org-1', role: 'owner' },
+    isResolving: false,
+  }),
+  useOrgWithMembers: () => withMembersQuery,
+}));
+
+vi.mock('@shopify/flash-list', () => ({
+  FlashList: (props: {
+    data?: unknown[];
+    ListEmptyComponent?: ComponentType | ReactElement | null;
+  }) => {
+    const data = props.data ?? [];
+    if (data.length === 0) {
+      const Empty = props.ListEmptyComponent;
+      if (typeof Empty === 'function') {
+        return createElement(Empty);
+      }
+      return Empty ?? null;
+    }
+    return null;
+  },
+}));
+
+vi.mock('expo-router', () => ({
+  useRouter: () => ({ push: vi.fn() }),
+}));
+
+vi.mock('@/components/ui/icons', () => ({
+  UserPlus: 'UserPlus',
+  Users: 'Users',
+}));
+
+vi.mock('@/components/empty-state', () => ({
+  EmptyState: ({ title }: { title: string }) => `EMPTY_STATE:${title}`,
+}));
+
+vi.mock('@/components/organization/invited-member-row', () => ({
+  InvitedMemberRow: () => null,
+}));
+
+vi.mock('@/components/organization/member-row', () => ({
+  MemberRow: () => null,
+}));
+
+vi.mock('@/components/organization/organization-boundary', () => ({
+  OrganizationBoundary: () => null,
+}));
+
+vi.mock('@/components/query-error', () => ({
+  QueryError: () => 'QUERY_ERROR',
+}));
+
+vi.mock('@/components/screen-header', () => ({
+  ScreenHeader: () => null,
+}));
+
+vi.mock('@/components/ui/button', () => ({
+  Button: 'Button',
+}));
+
+vi.mock('@/components/ui/skeleton', () => ({
+  Skeleton: 'Skeleton',
+}));
+
+vi.mock('@/components/ui/text', () => ({
+  Text: 'Text',
+}));
+
+vi.mock('@/components/tab-screen', () => ({
+  useTabBarBottomPadding: () => 0,
+}));
+
+vi.mock('@/lib/hooks/use-current-user-id', () => ({
+  useCurrentUserId: () => ({ userId: 'user-1' }),
+}));
+
+vi.mock('@/lib/hooks/use-theme-colors', () => ({
+  useThemeColors: () => ({ foreground: '#000000' }),
+}));
+
+vi.mock('@/lib/utils', () => ({
+  cn: (...args: unknown[]) => args.filter(Boolean).join(' '),
+  firstNonEmpty: (...args: (string | null | undefined)[]) =>
+    args.find(value => value != null && value !== '') ?? '',
+  parseTimestamp: (value: string) => new Date(value),
+}));
+
+vi.mock('react-native', () => ({
+  Pressable: 'Pressable',
+  View: 'View',
+}));
+
+function collectText(node: unknown): string[] {
+  if (node == null) {
+    return [];
+  }
+  if (typeof node === 'string') {
+    return [node];
+  }
+  if (Array.isArray(node)) {
+    return node.flatMap(item => collectText(item));
+  }
+  if (typeof node === 'object' && 'children' in node) {
+    return collectText((node as { children?: unknown }).children);
+  }
+  return [];
+}
+
+async function renderScreen(): Promise<string[]> {
+  const { renderer } = await renderWithProviders(createElement(OrganizationMembersScreen));
+  return collectText(renderer.toJSON());
+}
+
+beforeEach(() => {
+  withMembersQuery.data = undefined;
+  withMembersQuery.isLoading = false;
+  withMembersQuery.isFetching = false;
+  withMembersQuery.isError = false;
+  withMembersQuery.error = null;
+  withMembersQuery.refetch.mockClear();
+});
+
+describe('OrganizationMembersScreen empty-state precedence', () => {
+  it('renders QueryError, not "No members yet", when an error leaves both member arrays empty', async () => {
+    withMembersQuery.isError = true;
+    withMembersQuery.error = { data: { code: 'INTERNAL_SERVER_ERROR' } };
+
+    const texts = await renderScreen();
+
+    expect(texts).toContain('QUERY_ERROR');
+    expect(texts).not.toContain('No members yet');
+  });
+
+  it('renders "No members yet" when there is no error and both member arrays are empty', async () => {
+    const texts = await renderScreen();
+
+    expect(texts).not.toContain('QUERY_ERROR');
+    expect(texts).toContain('EMPTY_STATE:No members yet');
+  });
+});
diff --git a/apps/mobile/src/components/organization/members-screen.tsx b/apps/mobile/src/components/organization/members-screen.tsx
index b7650d4008..37d54789ae 100644
--- a/apps/mobile/src/components/organization/members-screen.tsx
+++ b/apps/mobile/src/components/organization/members-screen.tsx
@@ -1,8 +1,8 @@
+import { FlashList } from '@shopify/flash-list';
 import { type Href, useRouter } from 'expo-router';
 import { UserPlus, Users } from '@/components/ui/icons';
-import { type ReactNode } from 'react';
-import { Pressable, View } from 'react-native';
-import Animated, { FadeIn, FadeOut, LinearTransition } from 'react-native-reanimated';
+import { useMemo } from 'react';
+import { Pressable, View, type ViewStyle } from 'react-native';
 
 import { EmptyState } from '@/components/empty-state';
 import { InvitedMemberRow } from '@/components/organization/invited-member-row';
@@ -13,7 +13,7 @@ import { ScreenHeader } from '@/components/screen-header';
 import { Button } from '@/components/ui/button';
 import { Skeleton } from '@/components/ui/skeleton';
 import { Text } from '@/components/ui/text';
-import { TabScreenScrollView } from '@/components/tab-screen';
+import { useTabBarBottomPadding } from '@/components/tab-screen';
 import { useCurrentUserId } from '@/lib/hooks/use-current-user-id';
 import {
   type ActiveOrgMember,
@@ -23,7 +23,10 @@ import {
   useOrgWithMembers,
 } from '@/lib/hooks/use-organization-queries';
 import { useThemeColors } from '@/lib/hooks/use-theme-colors';
-import { firstNonEmpty, parseTimestamp } from '@/lib/utils';
+import { cn, firstNonEmpty, parseTimestamp } from '@/lib/utils';
+
+import { buildMembersListItems, type MembersListItem } from './members-list-items';
+import { selectOrgListErrorView } from './org-list-error-view';
 
 function sortActiveMembers(members: ActiveOrgMember[]): ActiveOrgMember[] {
   // eslint-disable-next-line unicorn/no-array-sort -- toSorted() is not available in Hermes
@@ -56,12 +59,28 @@ function MemberRowSkeleton({ last }: Readonly<{ last?: boolean }>) {
   );
 }
 
+const listStyle = { flex: 1 } satisfies ViewStyle;
+const listContentContainerStyle = { paddingTop: 16, flexGrow: 1 } satisfies ViewStyle;
+
 export function OrganizationMembersScreen() {
   const router = useRouter();
   const colors = useThemeColors();
   const { organizationId, role, org, isResolving } = useOrgBoundary();
   const orgWithMembers = useOrgWithMembers(organizationId);
   const { userId: currentUserId } = useCurrentUserId();
+  const paddingBottom = useTabBarBottomPadding();
+
+  const activeMembers = sortActiveMembers(
+    orgWithMembers.data?.members.filter(m => m.status === 'active') ?? []
+  );
+  const invitedMembers = sortInvitedMembers(
+    orgWithMembers.data?.members.filter(m => m.status === 'invited') ?? []
+  );
+
+  const items = useMemo(
+    () => buildMembersListItems({ activeMembers, invitedMembers }),
+    [activeMembers, invitedMembers]
+  );
 
   if (isResolving || organizationId == null || org == null) {
     return <OrganizationBoundary title="Members" />;
@@ -73,70 +92,115 @@ export function OrganizationMembersScreen() {
   const canInvite = isMoneyRole(role);
   const isOwner = role === 'owner';
 
-  const activeMembers = sortActiveMembers(
-    orgWithMembers.data?.members.filter(m => m.status === 'active') ?? []
-  );
-  const invitedMembers = sortInvitedMembers(
-    orgWithMembers.data?.members.filter(m => m.status === 'invited') ?? []
+  const errorView = isError ? selectOrgListErrorView(orgWithMembers.error) : null;
+
+  const emptyState = (
+    <EmptyState
+      icon={Users}
+      placement="top"
+      title="No members yet"
+      description={
+        canInvite
+          ? 'Invite teammates to start collaborating in this organization.'
+          : 'Ask an owner or billing manager to invite teammates.'
+      }
+      action={
+        canInvite ? (
+          <Button
+            onPress={() => {
+              router.push('/(app)/(tabs)/(3_profile)/organization/invite-member' as Href);
+            }}
+          >
+            <Text className="text-primary-foreground">Invite member</Text>
+          </Button>
+        ) : undefined
+      }
+    />
   );
 
-  let membersBody: ReactNode = null;
-  if (isLoading) {
-    membersBody = (
-      <Animated.View exiting={FadeOut.duration(150)} className="rounded-lg bg-secondary">
-        <MemberRowSkeleton />
-        <MemberRowSkeleton />
-        <MemberRowSkeleton last />
-      </Animated.View>
-    );
-  } else if (isError) {
-    membersBody = (
-      <QueryError
-        onRetry={() => void orgWithMembers.refetch()}
-        isRetrying={orgWithMembers.isFetching}
-        placement="top"
-      />
-    );
-  } else if (activeMembers.length === 0) {
-    membersBody = (
-      <EmptyState
-        icon={Users}
-        placement="top"
-        title="No members yet"
-        description={
-          canInvite
-            ? 'Invite teammates to start collaborating in this organization.'
-            : 'Ask an owner or billing manager to invite teammates.'
-        }
-        action={
-          canInvite ? (
-            <Button
-              onPress={() => {
-                router.push('/(app)/(tabs)/(3_profile)/organization/invite-member' as Href);
-              }}
-            >
-              <Text className="text-primary-foreground">Invite member</Text>
-            </Button>
-          ) : undefined
-        }
-      />
-    );
-  } else {
-    membersBody = (
-      <Animated.View entering={FadeIn.duration(200)} className="rounded-lg bg-secondary">
-        {activeMembers.map((member, index) => (
-          <MemberRow
-            key={member.id}
-            member={member}
-            canManage={isOwner && member.id !== currentUserId}
-            enableUsageLimits={enableUsageLimits}
-            organizationId={organizationId}
-            last={index === activeMembers.length - 1}
-          />
-        ))}
-      </Animated.View>
-    );
-  }
+  // Loading, error, and empty are mutually exclusive and evaluated in this
+  // order. An error leaves both member arrays empty, so it must be checked
+  // before the empty branch — otherwise a 500 renders "No members yet".
+  const renderListEmpty = () => {
+    if (isLoading) {
+      return (
+        <View className="mx-6 rounded-lg bg-secondary">
+          <MemberRowSkeleton />
+          <MemberRowSkeleton />
+          <MemberRowSkeleton last />
+        </View>
+      );
+    }
+    if (errorView) {
+      return (
+        <QueryError
+          variant={errorView.variant}
+          onRetry={errorView.showRetry ? () => void orgWithMembers.refetch() : undefined}
+          isRetrying={orgWithMembers.isFetching}
+          placement="top"
+        />
+      );
+    }
+    return emptyState;
+  };
+
+  const renderItem = ({ item, index }: { item: MembersListItem; index: number }) => {
+    switch (item.kind) {
+      case 'section': {
+        return (
+          <View className="bg-background px-6 pb-2 pt-4">
+            <Text variant="eyebrow">{item.title}</Text>
+          </View>
+        );
+      }
+      case 'members-empty': {
+        return emptyState;
+      }
+      case 'member': {
+        const isFirst = index === 0 || items[index - 1]?.kind === 'section';
+        return (
+          <View
+            className={cn(
+              'mx-6 bg-secondary',
+              isFirst && 'rounded-t-lg',
+              item.last && 'rounded-b-lg'
+            )}
+          >
+            <MemberRow
+              member={item.member}
+              canManage={isOwner && item.member.id !== currentUserId}
+              enableUsageLimits={enableUsageLimits}
+              organizationId={organizationId}
+              last={item.last}
+            />
+          </View>
+        );
+      }
+      case 'invite': {
+        const isFirst = index === 0 || items[index - 1]?.kind === 'section';
+        return (
+          <View
+            className={cn(
+              'mx-6 bg-secondary',
+              isFirst && 'rounded-t-lg',
+              item.last && 'rounded-b-lg'
+            )}
+          >
+            <InvitedMemberRow
+              invite={item.invite}
+              canManage={isOwner}
+              organizationId={organizationId}
+              last={item.last}
+            />
+          </View>
+        );
+      }
+      default: {
+        const _exhaustive: never = item;
+        return _exhaustive;
+      }
+    }
+  };
 
   return (
     <View className="flex-1 bg-background">
@@ -158,37 +222,36 @@ export function OrganizationMembersScreen() {
           ) : undefined
         }
       />
-      <TabScreenScrollView
-        className="flex-1 px-6"
-        contentContainerClassName="gap-6 pt-4"
+      <FlashList
+        style={listStyle}
+        data={items}
+        renderItem={renderItem}
+        keyExtractor={item => {
+          switch (item.kind) {
+            case 'section': {
+              return `section:${item.title}`;
+            }
+            case 'members-empty': {
+              return 'members-empty';
+            }
+            case 'member': {
+              return item.member.id;
+            }
+            case 'invite': {
+              return item.invite.inviteId;
+            }
+            default: {
+              const _exhaustive: never = item;
+              return _exhaustive;
+            }
+          }
+        }}
+        getItemType={item => item.kind}
+        ListEmptyComponent={renderListEmpty}
+        ListFooterComponent={<View style={{ height: paddingBottom }} pointerEvents="none" />}
         showsVerticalScrollIndicator={false}
-      >
-        <Animated.View layout={LinearTransition} className="gap-2">
-          <Text variant="eyebrow">Members</Text>
-          {membersBody}
-        </Animated.View>
-
-        {!isLoading && !isError && invitedMembers.length > 0 && (
-          <Animated.View
-            entering={FadeIn.duration(200)}
-            layout={LinearTransition}
-            className="gap-2"
-          >
-            <Text variant="eyebrow">Pending invitations</Text>
-            <View className="rounded-lg bg-secondary">
-              {invitedMembers.map((invite, index) => (
-                <InvitedMemberRow
-                  key={invite.inviteId}
-                  invite={invite}
-                  canManage={isOwner}
-                  organizationId={organizationId}
-                  last={index === invitedMembers.length - 1}
-                />
-              ))}
-            </View>
-          </Animated.View>
-        )}
-      </TabScreenScrollView>
+        contentContainerStyle={listContentContainerStyle}
+      />
     </View>
   );
 }
diff --git a/apps/mobile/src/components/organization/org-list-error-view.test.ts b/apps/mobile/src/components/organization/org-list-error-view.test.ts
new file mode 100644
index 0000000000..0a5e434ff0
--- /dev/null
+++ b/apps/mobile/src/components/organization/org-list-error-view.test.ts
@@ -0,0 +1,59 @@
+import { describe, expect, it } from 'vitest';
+
+import { selectOrgListErrorView } from './org-list-error-view';
+
+function makeTrpcError(code: string): unknown {
+  return { data: { code } };
+}
+
+describe('selectOrgListErrorView', () => {
+  it('maps FORBIDDEN to permission with no retry', () => {
+    expect(selectOrgListErrorView(makeTrpcError('FORBIDDEN'))).toEqual({
+      variant: 'permission',
+      showRetry: false,
+    });
+  });
+
+  it('maps UNAUTHORIZED to permission with no retry', () => {
+    expect(selectOrgListErrorView(makeTrpcError('UNAUTHORIZED'))).toEqual({
+      variant: 'permission',
+      showRetry: false,
+    });
+  });
+
+  it('maps NOT_FOUND to not-found with no retry', () => {
+    expect(selectOrgListErrorView(makeTrpcError('NOT_FOUND'))).toEqual({
+      variant: 'not-found',
+      showRetry: false,
+    });
+  });
+
+  it('maps BAD_REQUEST to server with no retry (terminal code)', () => {
+    expect(selectOrgListErrorView(makeTrpcError('BAD_REQUEST'))).toEqual({
+      variant: 'server',
+      showRetry: false,
+    });
+  });
+
+  it('maps UNAUTHORIZED-style UNPROCESSABLE_CONTENT to server with no retry', () => {
+    expect(selectOrgListErrorView(makeTrpcError('UNPROCESSABLE_CONTENT'))).toEqual({
+      variant: 'server',
+      showRetry: false,
+    });
+  });
+
+  it('maps a 500-class code to server with retry', () => {
+    expect(selectOrgListErrorView(makeTrpcError('INTERNAL_SERVER_ERROR'))).toEqual({
+      variant: 'server',
+      showRetry: true,
+    });
+  });
+
+  it('maps an unknown non-tRPC error to server with retry', () => {
+    expect(selectOrgListErrorView(new Error('network down'))).toEqual({
+      variant: 'server',
+      showRetry: true,
+    });
+    expect(selectOrgListErrorView(null)).toEqual({ variant: 'server', showRetry: true });
+  });
+});
diff --git a/apps/mobile/src/components/organization/org-list-error-view.ts b/apps/mobile/src/components/organization/org-list-error-view.ts
new file mode 100644
index 0000000000..de88f446d2
--- /dev/null
+++ b/apps/mobile/src/components/organization/org-list-error-view.ts
@@ -0,0 +1,27 @@
+// Pure error-view selector for the organization Members list.
+//
+// Unlike the PR Review classifier, this does NOT treat PRECONDITION_FAILED as
+// a reconnect state: an org list has no connect gate. The variant comes from
+// the tRPC code, and the retry decision is `!isTerminalTrpcCode(code)` — which
+// also covers BAD_REQUEST and UNPROCESSABLE_CONTENT, so a Retry is never
+// offered on a permanent error.
+
+import { isTerminalTrpcCode, readTrpcErrorField } from '@/lib/trpc-error';
+
+export type OrgListErrorView = {
+  variant: 'permission' | 'not-found' | 'server';
+  showRetry: boolean;
+};
+
+export function selectOrgListErrorView(error: unknown): OrgListErrorView {
+  const code = readTrpcErrorField(error, 'code');
+
+  let variant: 'permission' | 'not-found' | 'server' = 'server';
+  if (code === 'FORBIDDEN' || code === 'UNAUTHORIZED') {
+    variant = 'permission';
+  } else if (code === 'NOT_FOUND') {
+    variant = 'not-found';
+  }
+
+  return { variant, showRetry: !isTerminalTrpcCode(code) };
+}
diff --git a/apps/mobile/src/components/pr-review/diff/pr-diff-file-navigator.test.tsx b/apps/mobile/src/components/pr-review/diff/pr-diff-file-navigator.test.tsx
new file mode 100644
index 0000000000..3230438c1e
--- /dev/null
+++ b/apps/mobile/src/components/pr-review/diff/pr-diff-file-navigator.test.tsx
@@ -0,0 +1,455 @@
+// File-navigator repair coverage (S4 r1): the three impl-review findings.
+//
+//   1. A failed later page with no active search shows a retry CTA that
+//      re-fetches just the failed page (`query.fetchNextPage`).
+//   2. The memoized row receives identity-stable `onSelect`/`onToggleViewed`
+//      callbacks, so a search keystroke does not re-render recycled cells.
+//   3. `onEndReached` is gated to "no active search", so during a search only
+//      fetch-to-completion loads the remaining pages.
+
+/* eslint-disable max-lines -- cohesive component-test suite for the navigator fetch rules */
+/* eslint-disable typescript-eslint/no-deprecated -- react-test-renderer is the DOM-free renderer used to mount React/RN trees under vitest (same pattern as src/test/render-with-providers.tsx) */
+import { createElement, Fragment, type ReactElement } from 'react';
+import { act } from 'react-test-renderer';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { PrDiffFileNavigator } from '@/components/pr-review/diff/pr-diff-file-navigator';
+import { type PrReviewFile } from '@/lib/pr-review/diff/pr-review-file-types';
+import { renderWithProviders } from '@/test/render-with-providers';
+
+// ── Hoisted mocks ──────────────────────────────────────────────────────────
+
+const fetchNextPageMock = vi.hoisted(() => vi.fn());
+const fetchAllRunMock = vi.hoisted(() => vi.fn());
+
+// Records every `NavigatorFileRow` render. Because the navigator wraps the row
+// in `memo`, a memo hit (stable callbacks) does NOT push a new entry.
+const rowRenders = vi.hoisted(
+  () => [] as { path: string; onSelect: () => void; onToggleViewed: () => void }[]
+);
+
+// Captures the latest FlashList props so tests can read `onEndReached`.
+const flashListProps = vi.hoisted(() => ({ current: null as null | Record<string, unknown> }));
+
+vi.mock('@shopify/flash-list', () => ({
+  FlashList: (props: Record<string, unknown>) => {
+    flashListProps.current = props;
+    const data = (props.data ?? []) as PrReviewFile[];
+    const renderItem = props.renderItem as (args: {
+      item: PrReviewFile;
+      index: number;
+    }) => ReactElement;
+    return createElement(
+      Fragment,
+      null,
+      data.map((item, index) => renderItem({ item, index }))
+    );
+  },
+}));
+
+vi.mock('expo-router', () => ({
+  useRouter: () => ({ canGoBack: () => false, back: vi.fn() }),
+}));
+
+vi.mock('@/components/ui/icons', () => ({ Search: 'Search' }));
+vi.mock('@/components/empty-state', () => ({ EmptyState: 'EmptyState' }));
+vi.mock('@/components/ui/skeleton', () => ({ Skeleton: 'Skeleton' }));
+vi.mock('@/components/ui/text', () => ({ Text: 'Text' }));
+vi.mock('@/lib/hooks/use-theme-colors', () => ({
+  useThemeColors: () => ({ mutedForeground: '#888888' }),
+}));
+vi.mock('@/lib/pr-review/file-navigator-bridge', () => ({
+  requestScrollToFile: vi.fn(),
+}));
+
+vi.mock('react-native', () => ({
+  View: 'View',
+  Pressable: 'Pressable',
+  TextInput: 'TextInput',
+  ActivityIndicator: 'ActivityIndicator',
+}));
+
+vi.mock('@/components/pr-review/diff/pr-diff-navigator-file-row', () => ({
+  NavigatorFileRow: (props: {
+    file: PrReviewFile;
+    viewed: boolean;
+    onSelect: () => void;
+    onToggleViewed: () => void;
+  }) => {
+    rowRenders.push({
+      path: props.file.path,
+      onSelect: props.onSelect,
+      onToggleViewed: props.onToggleViewed,
+    });
+    return null;
+  },
+}));
+
+// ── Hook mocks (module-level mutable state, reset per test) ────────────────
+
+type ListQueryResult = {
+  query: {
+    isLoading: boolean;
+    isFetching: boolean;
+    isFetchingNextPage: boolean;
+    hasNextPage: boolean;
+    fetchNextPage: () => unknown;
+    refetch: () => unknown;
+  };
+  files: PrReviewFile[];
+  firstPageErrorState: null;
+  laterPageError: boolean;
+};
+
+type ViewedResult = {
+  isViewed: (path: string) => boolean;
+  toggle: (path: string) => void;
+  isLoading: boolean;
+};
+
+type FetchAllResult = {
+  run: () => unknown;
+  isRunning: boolean;
+  loadedFiles: number;
+  totalFiles: null;
+  error: unknown;
+};
+
+let listQueryResult: ListQueryResult = {
+  query: {
+    isLoading: false,
+    isFetching: false,
+    isFetchingNextPage: false,
+    hasNextPage: false,
+    fetchNextPage: fetchNextPageMock,
+    refetch: vi.fn(),
+  },
+  files: [],
+  firstPageErrorState: null,
+  laterPageError: false,
+};
+let viewedResult: ViewedResult = {
+  isViewed: () => false,
+  toggle: () => undefined,
+  isLoading: false,
+};
+let fetchAllResult: FetchAllResult = {
+  run: fetchAllRunMock,
+  isRunning: false,
+  loadedFiles: 0,
+  totalFiles: null,
+  error: null,
+};
+
+vi.mock('@/lib/pr-review/diff/pr-review-file-list-state', () => ({
+  usePrReviewFileListQuery: () => listQueryResult,
+  usePrReviewViewedFiles: () => viewedResult,
+  useFetchToCompletion: () => fetchAllResult,
+}));
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+
+function makeFile(path: string): PrReviewFile {
+  return {
+    path,
+    previousPath: null,
+    status: 'modified',
+    additions: 0,
+    deletions: 0,
+    patch: null,
+    patchMissing: false,
+  };
+}
+
+const BASE_PROPS = {
+  owner: 'octocat',
+  repo: 'hello-world',
+  number: 7,
+  headSha: 'sha',
+  changedFiles: 1,
+};
+
+async function mountNavigator() {
+  const result = await renderWithProviders(createElement(PrDiffFileNavigator, BASE_PROPS));
+  return result;
+}
+
+function findSearchInput(renderer: Awaited<ReturnType<typeof mountNavigator>>['renderer']) {
+  return renderer.root.findByProps({ accessibilityLabel: 'Filter files by path' });
+}
+
+function typeSearch(
+  renderer: Awaited<ReturnType<typeof mountNavigator>>['renderer'],
+  text: string
+) {
+  const input = findSearchInput(renderer);
+  act(() => {
+    (input.props.onChangeText as (value: string) => void)(text);
+  });
+}
+
+function findRetryButton(renderer: Awaited<ReturnType<typeof mountNavigator>>['renderer']) {
+  return renderer.root.findByProps({ accessibilityLabel: 'Retry loading more files' });
+}
+
+// ── Tests ──────────────────────────────────────────────────────────────────
+
+describe('PrDiffFileNavigator later-page retry (finding 1)', () => {
+  beforeEach(() => {
+    fetchNextPageMock.mockReset();
+    fetchAllRunMock.mockReset();
+    rowRenders.length = 0;
+    flashListProps.current = null;
+    listQueryResult = {
+      query: {
+        isLoading: false,
+        isFetching: false,
+        isFetchingNextPage: false,
+        hasNextPage: true,
+        fetchNextPage: fetchNextPageMock,
+        refetch: vi.fn(),
+      },
+      files: [makeFile('src/a.ts')],
+      firstPageErrorState: null,
+      laterPageError: true,
+    };
+    viewedResult = { isViewed: () => false, toggle: vi.fn(() => undefined), isLoading: false };
+    fetchAllResult = {
+      run: fetchAllRunMock,
+      isRunning: false,
+      loadedFiles: 0,
+      totalFiles: null,
+      error: null,
+    };
+  });
+
+  it('shows a retry CTA for a failed later page with no active search', async () => {
+    const { renderer } = await mountNavigator();
+
+    expect(findRetryButton(renderer)).toBeTruthy();
+  });
+
+  it('retries the failed page via fetchNextPage when the CTA is pressed', async () => {
+    const { renderer } = await mountNavigator();
+
+    const button = findRetryButton(renderer);
+    act(() => {
+      (button.props.onPress as () => void)();
+    });
+
+    expect(fetchNextPageMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not show the later-page CTA when a search is active', async () => {
+    const { renderer } = await mountNavigator();
+
+    typeSearch(renderer, 'src');
+
+    expect(
+      renderer.root.findAllByProps({ accessibilityLabel: 'Retry loading more files' })
+    ).toHaveLength(0);
+  });
+});
+
+describe('PrDiffFileNavigator stable row callbacks (finding 2)', () => {
+  beforeEach(() => {
+    fetchNextPageMock.mockReset();
+    fetchAllRunMock.mockReset();
+    rowRenders.length = 0;
+    flashListProps.current = null;
+    listQueryResult = {
+      query: {
+        isLoading: false,
+        isFetching: false,
+        isFetchingNextPage: false,
+        hasNextPage: false,
+        fetchNextPage: fetchNextPageMock,
+        refetch: vi.fn(),
+      },
+      files: [makeFile('src/a.ts')],
+      firstPageErrorState: null,
+      laterPageError: false,
+    };
+    viewedResult = { isViewed: () => false, toggle: vi.fn(() => undefined), isLoading: false };
+    fetchAllResult = {
+      run: fetchAllRunMock,
+      isRunning: false,
+      loadedFiles: 0,
+      totalFiles: null,
+      error: null,
+    };
+  });
+
+  it('does not re-render the memoized row on a search keystroke', async () => {
+    const { renderer } = await mountNavigator();
+
+    expect(rowRenders).toHaveLength(1);
+
+    typeSearch(renderer, 'src');
+
+    // The file still matches the search, so the row stays mounted. Stable
+    // callbacks make the memo hit, so the row does not render again.
+    expect(rowRenders).toHaveLength(1);
+  });
+});
+
+describe('PrDiffFileNavigator onEndReached gating (finding 3)', () => {
+  beforeEach(() => {
+    fetchNextPageMock.mockReset();
+    fetchAllRunMock.mockReset();
+    rowRenders.length = 0;
+    flashListProps.current = null;
+    listQueryResult = {
+      query: {
+        isLoading: false,
+        isFetching: false,
+        isFetchingNextPage: false,
+        hasNextPage: true,
+        fetchNextPage: fetchNextPageMock,
+        refetch: vi.fn(),
+      },
+      files: [makeFile('src/a.ts')],
+      firstPageErrorState: null,
+      laterPageError: false,
+    };
+    viewedResult = { isViewed: () => false, toggle: vi.fn(() => undefined), isLoading: false };
+    fetchAllResult = {
+      run: fetchAllRunMock,
+      isRunning: false,
+      loadedFiles: 0,
+      totalFiles: null,
+      error: null,
+    };
+  });
+
+  it('loads the next page on end-reached with no active search', async () => {
+    await mountNavigator();
+
+    const onEndReached = flashListProps.current?.onEndReached as () => void;
+    onEndReached();
+
+    expect(fetchNextPageMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not load the next page on end-reached during an active search', async () => {
+    const { renderer } = await mountNavigator();
+
+    typeSearch(renderer, 'src');
+
+    const onEndReached = flashListProps.current?.onEndReached as () => void;
+    onEndReached();
+
+    expect(fetchNextPageMock).not.toHaveBeenCalled();
+  });
+});
+
+describe('PrDiffFileNavigator active-search fetch-to-completion (finding 4)', () => {
+  beforeEach(() => {
+    fetchNextPageMock.mockReset();
+    fetchAllRunMock.mockReset();
+    rowRenders.length = 0;
+    flashListProps.current = null;
+    listQueryResult = {
+      query: {
+        isLoading: false,
+        isFetching: false,
+        isFetchingNextPage: false,
+        hasNextPage: true,
+        fetchNextPage: fetchNextPageMock,
+        refetch: vi.fn(),
+      },
+      files: [makeFile('src/a.ts')],
+      firstPageErrorState: null,
+      laterPageError: false,
+    };
+    viewedResult = { isViewed: () => false, toggle: vi.fn(() => undefined), isLoading: false };
+    fetchAllResult = {
+      run: fetchAllRunMock,
+      isRunning: false,
+      loadedFiles: 0,
+      totalFiles: null,
+      error: null,
+    };
+  });
+
+  it('starts fetch-to-completion when a search becomes active', async () => {
+    const { renderer } = await mountNavigator();
+
+    // No active search yet: fetch-to-completion must not have run.
+    expect(fetchAllRunMock).not.toHaveBeenCalled();
+
+    typeSearch(renderer, 'src');
+
+    expect(fetchAllRunMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('shows the load-all retry when fetch-to-completion has an error', async () => {
+    fetchAllResult = {
+      run: fetchAllRunMock,
+      isRunning: false,
+      loadedFiles: 1,
+      totalFiles: null,
+      error: new Error('page failed'),
+    };
+    const { renderer } = await mountNavigator();
+
+    expect(
+      renderer.root.findByProps({ accessibilityLabel: 'Retry loading all files' })
+    ).toBeTruthy();
+  });
+});
+
+describe('PrDiffFileNavigator stale row callbacks (finding 5)', () => {
+  beforeEach(() => {
+    fetchNextPageMock.mockReset();
+    fetchAllRunMock.mockReset();
+    rowRenders.length = 0;
+    flashListProps.current = null;
+    listQueryResult = {
+      query: {
+        isLoading: false,
+        isFetching: false,
+        isFetchingNextPage: false,
+        hasNextPage: false,
+        fetchNextPage: fetchNextPageMock,
+        refetch: vi.fn(),
+      },
+      files: [makeFile('src/a.ts')],
+      firstPageErrorState: null,
+      laterPageError: false,
+    };
+    viewedResult = { isViewed: () => false, toggle: vi.fn(() => undefined), isLoading: false };
+    fetchAllResult = {
+      run: fetchAllRunMock,
+      isRunning: false,
+      loadedFiles: 0,
+      totalFiles: null,
+      error: null,
+    };
+  });
+
+  it('calls the latest viewed.toggle after the hook returns a new viewed object', async () => {
+    const toggleA = vi.fn(() => undefined);
+    viewedResult = { isViewed: () => false, toggle: toggleA, isLoading: false };
+
+    const { renderer } = await mountNavigator();
+
+    // The hook now returns a new `viewed` object (e.g. after a head-SHA change).
+    const toggleB = vi.fn(() => undefined);
+    viewedResult = { isViewed: () => false, toggle: toggleB, isLoading: false };
+    typeSearch(renderer, 'src');
+
+    // The cached row callback must call the latest toggle, not the stale one.
+    const firstRender = rowRenders[0];
+    if (!firstRender) {
+      throw new Error('expected a row render');
+    }
+    const onToggleViewed = firstRender.onToggleViewed;
+    act(() => {
+      onToggleViewed();
+    });
+
+    expect(toggleB).toHaveBeenCalledTimes(1);
+    expect(toggleA).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/mobile/src/components/pr-review/diff/pr-diff-file-navigator.tsx b/apps/mobile/src/components/pr-review/diff/pr-diff-file-navigator.tsx
index fdfb32d5ab..70401a8bbb 100644
--- a/apps/mobile/src/components/pr-review/diff/pr-diff-file-navigator.tsx
+++ b/apps/mobile/src/components/pr-review/diff/pr-diff-file-navigator.tsx
@@ -7,18 +7,21 @@
 //   - share `usePrReviewFileListQuery` with the mounted Files tab so
 //     react-query dedupes by key and the navigator and the file list
 //     stay in sync
-//   - drive `useFetchToCompletion(...).run()` on mount so the full
-//     listed file set is available for search/jump
+//   - virtualize the file rows with `FlashList`; with no active search,
+//     pages load on scroll via `onEndReached`
+//   - with an active search, drive `useFetchToCompletion(...).run()` so
+//     the filter still searches the full listed set
 //   - render a search input (uncontrolled per iOS rules: ref +
 //     onChangeText, no `value`) and a list of file rows
 //   - on tap, `requestScrollToFile(...)` and dismiss
 //   - render the four states: loading, retryable (fetch-to-completion
 //     error), empty (0 listed files), happy
 
+import { FlashList } from '@shopify/flash-list';
 import { useRouter } from 'expo-router';
 import { Search } from '@/components/ui/icons';
-import { useEffect, useMemo, useRef, useState } from 'react';
-import { ActivityIndicator, Pressable, ScrollView, TextInput, View } from 'react-native';
+import { memo, useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { ActivityIndicator, Pressable, TextInput, View, type ViewStyle } from 'react-native';
 
 import { EmptyState } from '@/components/empty-state';
 import { NavigatorFileRow } from '@/components/pr-review/diff/pr-diff-navigator-file-row';
@@ -31,8 +34,21 @@ import {
   usePrReviewViewedFiles,
 } from '@/lib/pr-review/diff/pr-review-file-list-state';
 import { type PrReviewFile } from '@/lib/pr-review/diff/pr-review-file-types';
+import { filterNavigatorFiles } from '@/lib/pr-review/diff/navigator-file-filter';
 import { useThemeColors } from '@/lib/hooks/use-theme-colors';
 
+// Memoized row so recycled cells do not re-render on every keystroke: `file`
+// and `viewed` are stable across a search re-render, and the callbacks below
+// are `useCallback`-stable.
+const MemoNavigatorFileRow = memo(NavigatorFileRow);
+
+// Matches the previous ScrollView `contentContainerClassName="pb-8 pt-2"`.
+const LIST_CONTENT_STYLE: ViewStyle = { paddingBottom: 32, paddingTop: 8 };
+
+// Identity-stable per-path row callbacks (the row's `onSelect`/`onToggleViewed`
+// take no args, so the path is bound once and cached in a ref map).
+type RowCallbacks = { handleSelect: () => void; handleToggleViewed: () => void };
+
 type PrDiffFileNavigatorProps = {
   readonly owner: string;
   readonly repo: string;
@@ -43,14 +59,6 @@ type PrDiffFileNavigatorProps = {
   readonly onDismiss?: () => void;
 };
 
-function filterFiles(files: PrReviewFile[], query: string): PrReviewFile[] {
-  const needle = query.trim().toLowerCase();
-  if (needle.length === 0) {
-    return files;
-  }
-  return files.filter(file => file.path.toLowerCase().includes(needle));
-}
-
 function countViewed(files: PrReviewFile[], isViewed: (path: string) => boolean): number {
   let count = 0;
   for (const file of files) {
@@ -79,7 +87,7 @@ export function PrDiffFileNavigator({
   const [searchVersion, setSearchVersion] = useState(0);
   const inputRef = useRef<TextInput | null>(null);
 
-  const { query, files, firstPageErrorState } = usePrReviewFileListQuery({
+  const { query, files, firstPageErrorState, laterPageError } = usePrReviewFileListQuery({
     owner,
     repo,
     number,
@@ -88,21 +96,31 @@ export function PrDiffFileNavigator({
   const viewed = usePrReviewViewedFiles({ owner, repo, number }, headSha);
   const fetchAll = useFetchToCompletion(query, changedFiles);
 
-  // Drive the query to completion so search/navigation cover the full listed
-  // set. `run()` no-ops while the first page is in flight, so re-run it
-  // reactively once the query becomes eligible (first page settled, more pages
-  // remain), and stop once complete or after a surfaced error (the user can
-  // then tap the "Failed to load all files" retry to resume).
+  const hasActiveSearch = searchRef.current.trim().length > 0;
+
+  // Rule 2: an active search drives fetch-to-completion so the filter still
+  // searches the full listed set. `run()` no-ops while the first page is in
+  // flight, so re-run it reactively once the query becomes eligible (first
+  // page settled, more pages remain), and stop once complete or after a
+  // surfaced error (the user can then tap the "Failed to load all files"
+  // retry to resume). With no active search, pages load on scroll via
+  // `onEndReached` instead.
   const runRef = useRef(fetchAll.run);
   runRef.current = fetchAll.run;
   useEffect(() => {
-    if (!query.isFetching && query.hasNextPage && !fetchAll.isRunning && !fetchAll.error) {
+    if (
+      hasActiveSearch &&
+      !query.isFetching &&
+      query.hasNextPage &&
+      !fetchAll.isRunning &&
+      !fetchAll.error
+    ) {
       void runRef.current();
     }
-  }, [query.isFetching, query.hasNextPage, fetchAll.isRunning, fetchAll.error]);
+  }, [hasActiveSearch, query.isFetching, query.hasNextPage, fetchAll.isRunning, fetchAll.error]);
 
   const filtered = useMemo(
-    () => filterFiles(files, searchRef.current),
+    () => filterNavigatorFiles(files, searchRef.current),
     // `searchVersion` is the only thing that signals "the ref changed",
     // so it has to be in the dep list even though `files` is the only
     // real data input.
@@ -112,16 +130,68 @@ export function PrDiffFileNavigator({
 
   const viewedCount = useMemo(() => countViewed(files, viewed.isViewed), [files, viewed]);
 
-  const handleSelectFile = (path: string) => {
-    requestScrollToFile({ owner, repo, number, path });
-    if (onDismiss) {
-      onDismiss();
-      return;
-    }
-    if (router.canGoBack()) {
-      router.back();
+  const handleSelectFile = useCallback(
+    (path: string) => {
+      requestScrollToFile({ owner, repo, number, path });
+      if (onDismiss) {
+        onDismiss();
+        return;
+      }
+      if (router.canGoBack()) {
+        router.back();
+      }
+    },
+    [owner, repo, number, onDismiss, router]
+  );
+
+  const handleToggleViewed = useCallback(
+    (path: string) => {
+      void viewed.toggle(path);
+    },
+    [viewed]
+  );
+
+  // Cache per-path callbacks so `MemoNavigatorFileRow`'s memo hits across a
+  // search re-render. The closures read the latest handlers through refs, so
+  // they stay identity-stable (memo keeps hitting) but never go stale when
+  // `handleSelectFile` / `handleToggleViewed` change identity (e.g. a head-SHA
+  // change swaps `viewed.toggle`).
+  const handleSelectFileRef = useRef(handleSelectFile);
+  handleSelectFileRef.current = handleSelectFile;
+  const handleToggleViewedRef = useRef(handleToggleViewed);
+  handleToggleViewedRef.current = handleToggleViewed;
+
+  const rowCallbacksRef = useRef(new Map<string, RowCallbacks>());
+  const getRowCallbacks = useCallback((path: string) => {
+    let callbacks = rowCallbacksRef.current.get(path);
+    if (!callbacks) {
+      callbacks = {
+        handleSelect: () => {
+          handleSelectFileRef.current(path);
+        },
+        handleToggleViewed: () => {
+          handleToggleViewedRef.current(path);
+        },
+      };
+      rowCallbacksRef.current.set(path, callbacks);
     }
-  };
+    return callbacks;
+  }, []);
+
+  const renderItem = useCallback(
+    ({ item }: { item: PrReviewFile }) => {
+      const callbacks = getRowCallbacks(item.path);
+      return (
+        <MemoNavigatorFileRow
+          file={item}
+          viewed={viewed.isViewed(item.path)}
+          onSelect={callbacks.handleSelect}
+          onToggleViewed={callbacks.handleToggleViewed}
+        />
+      );
+    },
+    [viewed, getRowCallbacks]
+  );
 
   if (firstPageErrorState?.kind === 'not-found') {
     return (
@@ -214,6 +284,13 @@ export function PrDiffFileNavigator({
   }
 
   const showLoadAllRetry = Boolean(fetchAll.error) && !fetchAll.isRunning && query.hasNextPage;
+  // A scroll-triggered later-page failure (no search) retries just that page.
+  // `!fetchAll.error` keeps it mutually exclusive with the load-all banner.
+  const showLaterPageRetry = laterPageError && !hasActiveSearch && !fetchAll.error;
+  const showRetry = showLoadAllRetry || showLaterPageRetry;
+  const retryMessage = showLoadAllRetry ? 'Failed to load all files' : "Couldn't load more files";
+  const retryLabel = showLoadAllRetry ? 'Retry loading all files' : 'Retry loading more files';
+  const retryAction = showLoadAllRetry ? fetchAll.run : query.fetchNextPage;
   // Truncated when pagination hasn't finished, errored, or GitHub's 3,000-file
   // listing cap left fewer listed files than the overview's changed-file count.
   const isTruncated = query.hasNextPage || Boolean(fetchAll.error) || changedFiles > files.length;
@@ -255,49 +332,42 @@ export function PrDiffFileNavigator({
         ) : null}
       </View>
 
-      {showLoadAllRetry ? (
+      {showRetry ? (
         <View className="mx-4 mt-2 flex-row items-center justify-between rounded-md border border-border bg-card px-3 py-2">
-          <Text className="text-xs text-destructive">Failed to load all files</Text>
+          <Text className="text-xs text-destructive">{retryMessage}</Text>
           <Pressable
-            onPress={() => {
-              void fetchAll.run();
-            }}
+            onPress={() => void retryAction()}
             className="rounded-md border border-border bg-card px-3 py-1 active:opacity-70"
             accessibilityRole="button"
-            accessibilityLabel="Retry loading all files"
+            accessibilityLabel={retryLabel}
           >
             <Text className="text-xs font-medium text-foreground">Retry</Text>
           </Pressable>
         </View>
       ) : null}
 
-      <ScrollView
-        className="flex-1"
-        contentContainerClassName="pb-8 pt-2"
+      <FlashList
+        data={filtered}
+        renderItem={renderItem}
+        keyExtractor={file => file.path}
         keyboardShouldPersistTaps="handled"
         automaticallyAdjustKeyboardInsets
-      >
-        {filtered.length === 0 ? (
+        contentContainerStyle={LIST_CONTENT_STYLE}
+        onEndReached={() => {
+          // During a search, fetch-to-completion loads pages; a scroll fetch would race it.
+          if (!hasActiveSearch && query.hasNextPage && !query.isFetchingNextPage) {
+            void query.fetchNextPage();
+          }
+        }}
+        onEndReachedThreshold={0.5}
+        ListEmptyComponent={
           <View className="px-6 py-12">
             <Text variant="muted" className="text-center text-sm">
               No files match "{searchRef.current}"
             </Text>
           </View>
-        ) : null}
-        {filtered.map(file => (
-          <NavigatorFileRow
-            key={file.path}
-            file={file}
-            viewed={viewed.isViewed(file.path)}
-            onSelect={() => {
-              handleSelectFile(file.path);
-            }}
-            onToggleViewed={() => {
-              void viewed.toggle(file.path);
-            }}
-          />
-        ))}
-      </ScrollView>
+        }
+      />
     </View>
   );
 }
diff --git a/apps/mobile/src/components/pr-review/pr-review-discussion-tab-view.test.ts b/apps/mobile/src/components/pr-review/pr-review-discussion-tab-view.test.ts
new file mode 100644
index 0000000000..d25d35521a
--- /dev/null
+++ b/apps/mobile/src/components/pr-review/pr-review-discussion-tab-view.test.ts
@@ -0,0 +1,63 @@
+import { describe, expect, it } from 'vitest';
+
+import { selectDiscussionTabView } from './pr-review-discussion-tab-view';
+
+const base = {
+  firstPageErrorState: null,
+  isPending: false,
+  isEmpty: false,
+};
+
+describe('selectDiscussionTabView', () => {
+  it('returns permission for a permission first-page error', () => {
+    expect(
+      selectDiscussionTabView({ ...base, firstPageErrorState: { kind: 'permission' } })
+    ).toEqual({ kind: 'permission' });
+  });
+
+  it('returns not-found for a not-found first-page error', () => {
+    expect(
+      selectDiscussionTabView({ ...base, firstPageErrorState: { kind: 'not-found' } })
+    ).toEqual({ kind: 'not-found' });
+  });
+
+  it('returns reconnect for a reconnect first-page error', () => {
+    expect(
+      selectDiscussionTabView({ ...base, firstPageErrorState: { kind: 'reconnect' } })
+    ).toEqual({ kind: 'reconnect' });
+  });
+
+  it('returns retryable for a retryable first-page error', () => {
+    expect(
+      selectDiscussionTabView({ ...base, firstPageErrorState: { kind: 'retryable' } })
+    ).toEqual({ kind: 'retryable' });
+  });
+
+  it('returns loading while the first page is pending', () => {
+    expect(selectDiscussionTabView({ ...base, isPending: true })).toEqual({ kind: 'loading' });
+  });
+
+  it('returns empty when there is no error, no pending, and no items', () => {
+    expect(selectDiscussionTabView({ ...base, isEmpty: true })).toEqual({ kind: 'empty' });
+  });
+
+  it('returns happy when there is no error, no pending, and items exist', () => {
+    expect(selectDiscussionTabView(base)).toEqual({ kind: 'happy' });
+  });
+
+  it('prioritizes the error state over pending and empty', () => {
+    expect(
+      selectDiscussionTabView({
+        firstPageErrorState: { kind: 'permission' },
+        isPending: true,
+        isEmpty: true,
+      })
+    ).toEqual({ kind: 'permission' });
+  });
+
+  it('prioritizes pending over empty', () => {
+    expect(selectDiscussionTabView({ ...base, isPending: true, isEmpty: true })).toEqual({
+      kind: 'loading',
+    });
+  });
+});
diff --git a/apps/mobile/src/components/pr-review/pr-review-discussion-tab-view.ts b/apps/mobile/src/components/pr-review/pr-review-discussion-tab-view.ts
new file mode 100644
index 0000000000..326b006f9c
--- /dev/null
+++ b/apps/mobile/src/components/pr-review/pr-review-discussion-tab-view.ts
@@ -0,0 +1,28 @@
+// Pure state selector for the PR Review Discussion tab.
+//
+// Extracts the tab's existing branch chain (unchanged in behaviour) so the
+// seven outcomes can be unit-tested. The tab renders exactly what it rendered
+// before; this module only owns the decision.
+
+export type DiscussionTabView = {
+  kind: 'permission' | 'not-found' | 'reconnect' | 'retryable' | 'loading' | 'empty' | 'happy';
+};
+
+export function selectDiscussionTabView(args: {
+  firstPageErrorState: { kind: 'permission' | 'not-found' | 'reconnect' | 'retryable' } | null;
+  isPending: boolean;
+  isEmpty: boolean;
+}): DiscussionTabView {
+  const { firstPageErrorState, isPending, isEmpty } = args;
+
+  if (firstPageErrorState) {
+    return { kind: firstPageErrorState.kind };
+  }
+  if (isPending) {
+    return { kind: 'loading' };
+  }
+  if (isEmpty) {
+    return { kind: 'empty' };
+  }
+  return { kind: 'happy' };
+}
diff --git a/apps/mobile/src/components/pr-review/pr-review-discussion-tab.tsx b/apps/mobile/src/components/pr-review/pr-review-discussion-tab.tsx
index 1beacfe796..c024270bf1 100644
--- a/apps/mobile/src/components/pr-review/pr-review-discussion-tab.tsx
+++ b/apps/mobile/src/components/pr-review/pr-review-discussion-tab.tsx
@@ -68,6 +68,7 @@ import {
   toggleThreadExpanded,
 } from '@/lib/pr-review/discussion/thread-expansion';
 import { usePrReviewDiscussionThreads } from '@/lib/pr-review/discussion/use-pr-review-discussion-threads';
+import { selectDiscussionTabView } from '@/components/pr-review/pr-review-discussion-tab-view';
 
 type PrReviewDiscussionTabProps = {
   readonly owner: string;
@@ -200,33 +201,38 @@ export function PrReviewDiscussionTab({
   };
 
   // ── First-page error / terminal states ─────────────────────────────
-  if (firstPageErrorState) {
-    if (firstPageErrorState.kind === 'permission') {
-      return (
-        <QueryError
-          variant="permission"
-          title="Access denied"
-          message="You don't have permission to view this PR's discussion."
-        />
-      );
-    }
-    if (firstPageErrorState.kind === 'not-found') {
-      return (
-        <QueryError
-          variant="not-found"
-          title="Discussion unavailable"
-          message="This pull request may have been removed."
-        />
-      );
-    }
-    if (firstPageErrorState.kind === 'reconnect') {
-      return (
-        <View className="flex-1 items-center justify-center px-6 py-12">
-          <PrReviewReconnectNotice />
-        </View>
-      );
-    }
-    // retryable
+  const view = selectDiscussionTabView({
+    firstPageErrorState,
+    isPending: query.isPending,
+    isEmpty: isDiscussionEmpty(threads, conversation),
+  });
+
+  if (view.kind === 'permission') {
+    return (
+      <QueryError
+        variant="permission"
+        title="Access denied"
+        message="You don't have permission to view this PR's discussion."
+      />
+    );
+  }
+  if (view.kind === 'not-found') {
+    return (
+      <QueryError
+        variant="not-found"
+        title="Discussion unavailable"
+        message="This pull request may have been removed."
+      />
+    );
+  }
+  if (view.kind === 'reconnect') {
+    return (
+      <View className="flex-1 items-center justify-center px-6 py-12">
+        <PrReviewReconnectNotice />
+      </View>
+    );
+  }
+  if (view.kind === 'retryable') {
     return (
       <QueryError
         variant="server"
@@ -241,7 +247,7 @@ export function PrReviewDiscussionTab({
   }
 
   // ── Loading (first page in flight) ─────────────────────────────────
-  if (query.isPending) {
+  if (view.kind === 'loading') {
     return (
       <View accessibilityLabel="Loading discussion" className="flex-1 gap-3 px-4 pb-6 pt-3">
         {Array.from({ length: SKELETON_ROW_COUNT }).map((_, index) => (
@@ -258,7 +264,7 @@ export function PrReviewDiscussionTab({
   }
 
   // ── Empty (neither threads nor conversation comments) ──────────────
-  if (isDiscussionEmpty(threads, conversation)) {
+  if (view.kind === 'empty') {
     return (
       <View className="flex-1 px-4 pb-6">
         <EmptyState
diff --git a/apps/mobile/src/components/pr-review/pr-review-entry-screen.tsx b/apps/mobile/src/components/pr-review/pr-review-entry-screen.tsx
index 0694184cbe..6daff3da15 100644
--- a/apps/mobile/src/components/pr-review/pr-review-entry-screen.tsx
+++ b/apps/mobile/src/components/pr-review/pr-review-entry-screen.tsx
@@ -1,17 +1,12 @@
 import * as Clipboard from 'expo-clipboard';
 import { useFocusEffect, useRouter } from 'expo-router';
-import {
-  ChevronRight,
-  Clipboard as ClipboardIcon,
-  Clock,
-  Link2,
-  SearchX,
-  X,
-} from '@/components/ui/icons';
+import { ChevronRight, Clipboard as ClipboardIcon, Link2, SearchX, X } from '@/components/ui/icons';
 import { type ReactNode, useCallback, useRef, useState } from 'react';
-import { ActivityIndicator, Pressable, ScrollView, TextInput, View } from 'react-native';
+import { ActivityIndicator, Alert, Pressable, TextInput, View } from 'react-native';
 
 import { EmptyState } from '@/components/empty-state';
+import { PrReviewInboxList } from '@/components/pr-review/pr-review-inbox-list';
+import { selectRecentPrRowState } from '@/components/pr-review/recent-pr-row-state';
 import { ScreenHeader } from '@/components/screen-header';
 import { Button } from '@/components/ui/button';
 import { Text } from '@/components/ui/text';
@@ -26,7 +21,7 @@ import {
   PR_LINK_TOAST_INVALID_COPY,
   selectPrLinkClearButtonVisible,
 } from '@/lib/pr-review/pr-link-paste';
-import { getRecentPrs, type RecentPr, upsertRecentPr } from '@/lib/pr-review/recent-prs';
+import { getRecentPrs, type RecentPr, removeRecentPr } from '@/lib/pr-review/recent-prs';
 
 const URL_PLACEHOLDER = 'https://github.com/owner/repo/pull/123';
 
@@ -72,21 +67,16 @@ export function PrReviewEntryScreen() {
     setHasInput(text.length > 0);
   };
 
-  const handleSubmit = async () => {
+  const handleSubmit = () => {
     const raw = inputValueRef.current;
     const parsed = parseGitHubPrUrl(raw.trim());
     if (!parsed) {
       announcingToast.error(PR_LINK_TOAST_INVALID_COPY);
       return;
     }
-    // Title is backfilled on first successful load (S5).
-    await upsertRecentPr({
-      owner: parsed.owner,
-      repo: parsed.repo,
-      number: parsed.number,
-      title: '',
-      lastOpenedAt: Date.now(),
-    });
+    // Navigate straight to the PR route. Recents are written only after an
+    // authorized payload (the PR screen's backfill effect), so a failed or
+    // unauthorized open never persists an entry.
     router.push(getPrReviewPath(parsed.owner, parsed.repo, parsed.number));
   };
 
@@ -103,21 +93,36 @@ export function PrReviewEntryScreen() {
       announcingToast.error(PR_LINK_TOAST_INVALID_COPY);
       return;
     }
-    await handleSubmit();
+    handleSubmit();
   };
 
   const focusInput = () => {
     inputRef.current?.focus();
   };
 
-  const handleRecentPress = async (entry: RecentPr) => {
-    await upsertRecentPr({
-      ...entry,
-      lastOpenedAt: Date.now(),
-    });
+  const handleRecentPress = (entry: RecentPr) => {
+    // Navigate only. The PR screen's backfill effect updates `lastOpenedAt`
+    // (and `lastResult`) once an authorized payload loads.
     router.push(getPrReviewPath(entry.owner, entry.repo, entry.number));
   };
 
+  const handleRemoveRecent = (entry: RecentPr) => {
+    Alert.alert('Remove from recents?', 'This pull request will be removed from your recents.', [
+      { text: 'Cancel', style: 'cancel' },
+      {
+        text: 'Remove',
+        style: 'destructive',
+        onPress: () => {
+          void (async () => {
+            await removeRecentPr(entry);
+            const list = await getRecentPrs();
+            setRecent(list);
+          })();
+        },
+      },
+    ]);
+  };
+
   const showClearButton = selectPrLinkClearButtonVisible({ hasInput });
 
   let recentsBody: ReactNode = null;
@@ -142,148 +147,163 @@ export function PrReviewEntryScreen() {
       <View className="rounded-lg bg-secondary">
         {recent.map((entry, index) => {
           const isLast = index === recent.length - 1;
+          const rowState = selectRecentPrRowState(entry);
+          const removeLabel = `Remove ${entry.owner}/${entry.repo}#${entry.number} from recents`;
           return (
-            <Pressable
+            <View
               key={`${entry.owner}/${entry.repo}#${entry.number}`}
-              onPress={() => {
-                void handleRecentPress(entry);
-              }}
-              className={`flex-row items-center gap-3 px-3 py-3 active:opacity-70 ${
-                isLast ? '' : 'border-b-[0.5px] border-hair-soft'
-              }`}
+              className={isLast ? '' : 'border-b-[0.5px] border-hair-soft'}
             >
-              <View className="flex-1">
-                <Text className="text-sm font-medium" numberOfLines={1}>
-                  {entry.title || `${entry.owner}/${entry.repo}#${entry.number}`}
-                </Text>
-                <Text variant="muted" className="text-xs">
-                  {entry.owner}/{entry.repo}#{entry.number}
-                </Text>
+              <Pressable
+                onPress={() => {
+                  handleRecentPress(entry);
+                }}
+                className="flex-row items-center gap-3 px-3 py-3 active:opacity-70"
+              >
+                <View className="flex-1 gap-1">
+                  <Text className="text-sm font-medium" numberOfLines={1}>
+                    {rowState.primary}
+                  </Text>
+                  {rowState.secondary ? (
+                    <Text variant="muted" className="text-xs">
+                      {rowState.secondary}
+                    </Text>
+                  ) : null}
+                </View>
+                <ChevronRight size={16} color={colors.mutedForeground} />
+              </Pressable>
+              <View className="flex-row items-center justify-between gap-2 px-3 pb-3">
+                {rowState.failed ? (
+                  <Text variant="muted" className="text-xs">
+                    Couldn&apos;t load
+                  </Text>
+                ) : (
+                  <View />
+                )}
+                <View className="flex-row items-center gap-2">
+                  {rowState.failed ? (
+                    <Button
+                      size="sm"
+                      variant="outline"
+                      onPress={() => {
+                        handleRecentPress(entry);
+                      }}
+                      accessibilityLabel="Retry"
+                    >
+                      <Text>Retry</Text>
+                    </Button>
+                  ) : null}
+                  <Button
+                    size="sm"
+                    variant="outline"
+                    onPress={() => {
+                      handleRemoveRecent(entry);
+                    }}
+                    accessibilityLabel={removeLabel}
+                  >
+                    <Text>Remove</Text>
+                  </Button>
+                </View>
               </View>
-              <ChevronRight size={16} color={colors.mutedForeground} />
-            </Pressable>
+            </View>
           );
         })}
       </View>
     );
   }
 
-  return (
-    <View className="flex-1 bg-background">
-      <ScreenHeader title="PR Review" eyebrow="Open a pull request by URL" />
-      <ScrollView
-        className="flex-1"
-        contentContainerClassName="gap-6 px-6 pb-12 pt-4"
-        keyboardShouldPersistTaps="handled"
-        automaticallyAdjustKeyboardInsets
-      >
-        <View className="gap-2">
-          <View className="flex-row items-center gap-2">
-            <Link2 size={16} color={colors.mutedForeground} />
-            <Text variant="small" className="uppercase tracking-wide text-muted-foreground">
-              Paste a PR link
-            </Text>
-          </View>
-          <View className="gap-3">
-            <View className="flex-row items-center gap-2">
-              <View
-                className="min-h-14 min-w-0 flex-1 flex-row items-center rounded-md border border-border bg-card"
-                testID="pr-link-input-row"
-                collapsable={false}
-              >
-                <TextInput
-                  ref={inputRef}
-                  defaultValue=""
-                  placeholder={URL_PLACEHOLDER}
-                  placeholderTextColor={colors.mutedForeground}
-                  autoCapitalize="none"
-                  autoCorrect={false}
-                  keyboardType="url"
-                  onChangeText={value => {
-                    // Don't setState on every keystroke; track only whether the
-                    // input has any text. The raw value lives in the ref so
-                    // handleSubmit reads the latest text without re-rendering.
-                    const decision = consumePrLinkInputEcho(
-                      pendingProgrammaticTextsRef.current,
-                      value
-                    );
-                    pendingProgrammaticTextsRef.current = [...decision.pending];
-                    if (decision.kind === 'echo') {
-                      // Echo of setNativeProps: inputValueRef already holds the
-                      // intentional value from applyFieldText — do not clobber it
-                      // with a delayed/stale echo.
-                      return;
-                    }
-                    inputValueRef.current = value;
-                    setHasInput(value.length > 0);
-                  }}
-                  // leading-[normal] so no lineHeight reaches the style: an explicit lineHeight
-                  // makes iOS draw the placeholder lower than the typed text (see AGENTS.md).
-                  className="min-w-0 flex-1 bg-transparent py-3 pl-3 pr-1 text-base text-foreground leading-[normal]"
-                  accessibilityLabel="GitHub pull request URL"
-                  returnKeyType="go"
-                  onSubmitEditing={() => {
-                    void handleSubmit();
-                  }}
-                />
-                {showClearButton ? (
-                  // h-13 w-13 measures 45×45pt on device; h-12 is 42pt and h-11 is
-                  // 38pt in this app — do not "simplify" back to h-11/w-11.
-                  <Pressable
-                    onPress={() => {
-                      // clear() is the iOS-safe native empty after real typing.
-                      // setNativeProps({ text: '' }) loses the most-recent-event-count
-                      // race and leaves the typed text visible while React state
-                      // thinks the field is empty. Do not route through
-                      // applyFieldText('') (paste-only path) and do not push an
-                      // echo for '' — a non-arriving echo would stale the FIFO.
-                      inputValueRef.current = '';
-                      setHasInput(false);
-                      inputRef.current?.clear();
-                      inputRef.current?.focus();
-                    }}
-                    accessibilityRole="button"
-                    accessibilityLabel="Clear pull request link"
-                    className="h-13 w-13 items-center justify-center active:opacity-70"
-                  >
-                    <X size={16} color={colors.mutedForeground} />
-                  </Pressable>
-                ) : null}
-              </View>
+  const pasteBlock = (
+    <View className="gap-2">
+      <View className="flex-row items-center gap-2">
+        <Link2 size={16} color={colors.mutedForeground} />
+        <Text variant="small" className="uppercase tracking-wide text-muted-foreground">
+          Paste a PR link
+        </Text>
+      </View>
+      <View className="gap-3">
+        <View className="flex-row items-center gap-2">
+          <View
+            className="min-h-14 min-w-0 flex-1 flex-row items-center rounded-md border border-border bg-card"
+            testID="pr-link-input-row"
+            collapsable={false}
+          >
+            <TextInput
+              ref={inputRef}
+              defaultValue=""
+              placeholder={URL_PLACEHOLDER}
+              placeholderTextColor={colors.mutedForeground}
+              autoCapitalize="none"
+              autoCorrect={false}
+              keyboardType="url"
+              onChangeText={value => {
+                // Don't setState on every keystroke; track only whether the
+                // input has any text. The raw value lives in the ref so
+                // handleSubmit reads the latest text without re-rendering.
+                const decision = consumePrLinkInputEcho(pendingProgrammaticTextsRef.current, value);
+                pendingProgrammaticTextsRef.current = [...decision.pending];
+                if (decision.kind === 'echo') {
+                  // Echo of setNativeProps: inputValueRef already holds the
+                  // intentional value from applyFieldText — do not clobber it
+                  // with a delayed/stale echo.
+                  return;
+                }
+                inputValueRef.current = value;
+                setHasInput(value.length > 0);
+              }}
+              // leading-[normal] so no lineHeight reaches the style: an explicit lineHeight
+              // makes iOS draw the placeholder lower than the typed text (see AGENTS.md).
+              className="min-w-0 flex-1 bg-transparent py-3 pl-3 pr-1 text-base text-foreground leading-[normal]"
+              accessibilityLabel="GitHub pull request URL"
+              returnKeyType="go"
+              onSubmitEditing={handleSubmit}
+            />
+            {showClearButton ? (
+              // h-13 w-13 measures 45×45pt on device; h-12 is 42pt and h-11 is
+              // 38pt in this app — do not "simplify" back to h-11/w-11.
               <Pressable
                 onPress={() => {
-                  void handlePaste();
+                  // clear() is the iOS-safe native empty after real typing.
+                  // setNativeProps({ text: '' }) loses the most-recent-event-count
+                  // race and leaves the typed text visible while React state
+                  // thinks the field is empty. Do not route through
+                  // applyFieldText('') (paste-only path) and do not push an
+                  // echo for '' — a non-arriving echo would stale the FIFO.
+                  inputValueRef.current = '';
+                  setHasInput(false);
+                  inputRef.current?.clear();
+                  inputRef.current?.focus();
                 }}
                 accessibilityRole="button"
-                accessibilityLabel="Paste pull request link"
-                hitSlop={4}
-                className="h-11 w-11 items-center justify-center rounded-md border border-border bg-card active:opacity-70"
+                accessibilityLabel="Clear pull request link"
+                className="h-13 w-13 items-center justify-center active:opacity-70"
               >
-                <ClipboardIcon size={18} color={colors.mutedForeground} />
+                <X size={16} color={colors.mutedForeground} />
               </Pressable>
-            </View>
-            <Button
-              disabled={!hasInput}
-              onPress={() => {
-                void handleSubmit();
-              }}
-              accessibilityLabel="Open pull request"
-            >
-              <Text>Open</Text>
-            </Button>
+            ) : null}
           </View>
+          <Pressable
+            onPress={() => {
+              void handlePaste();
+            }}
+            accessibilityRole="button"
+            accessibilityLabel="Paste pull request link"
+            hitSlop={4}
+            className="h-11 w-11 items-center justify-center rounded-md border border-border bg-card active:opacity-70"
+          >
+            <ClipboardIcon size={18} color={colors.mutedForeground} />
+          </Pressable>
         </View>
+        <Button disabled={!hasInput} onPress={handleSubmit} accessibilityLabel="Open pull request">
+          <Text>Open</Text>
+        </Button>
+      </View>
+    </View>
+  );
 
-        <View className="gap-2">
-          <View className="flex-row items-center gap-2">
-            <Clock size={16} color={colors.mutedForeground} />
-            <Text variant="small" className="uppercase tracking-wide text-muted-foreground">
-              Recent
-            </Text>
-          </View>
-          {recentsBody}
-        </View>
-      </ScrollView>
+  return (
+    <View className="flex-1 bg-background">
+      <ScreenHeader title="PR Review" eyebrow="Open a pull request by URL" />
+      <PrReviewInboxList header={pasteBlock} recents={recentsBody} />
     </View>
   );
 }
diff --git a/apps/mobile/src/components/pr-review/pr-review-inbox-list.tsx b/apps/mobile/src/components/pr-review/pr-review-inbox-list.tsx
new file mode 100644
index 0000000000..53fbd23c91
--- /dev/null
+++ b/apps/mobile/src/components/pr-review/pr-review-inbox-list.tsx
@@ -0,0 +1,224 @@
+// PR inbox list: the entry screen's single scroll container.
+//
+// The screen keeps its ScreenHeader and the paste-a-link + recents
+// state; this component owns the ONE FlashList that composes the whole
+// body. The paste block and recents are passed in and rendered in the
+// list header/footer so they stay mounted in every inbox state (E4/E5
+// depend on reaching Recents right after a failed open). Inbox states
+// render inside `ListEmptyComponent` — never as a replacement for the
+// screen.
+
+import { FlashList } from '@shopify/flash-list';
+import { useRouter } from 'expo-router';
+import { type ReactNode } from 'react';
+import { Pressable, View } from 'react-native';
+
+import { EmptyState } from '@/components/empty-state';
+import { QueryError } from '@/components/query-error';
+import { PrReviewReconnectNotice } from '@/components/pr-review/pr-review-reconnect-notice';
+import { type PrInboxView, selectPrInboxView } from '@/components/pr-review/pr-review-inbox-view';
+import { Button } from '@/components/ui/button';
+import { ChevronRight, Clock, GitPullRequest, Inbox } from '@/components/ui/icons';
+import { Skeleton } from '@/components/ui/skeleton';
+import { Text } from '@/components/ui/text';
+import { useThemeColors } from '@/lib/hooks/use-theme-colors';
+import { getPrReviewPath } from '@/lib/profile-agent-navigation';
+import { usePrInbox } from '@/lib/pr-review/use-pr-inbox';
+import { parseTimestamp, timeAgo } from '@/lib/utils';
+
+const SKELETON_ROW_COUNT = 5;
+
+type InboxItem = ReturnType<typeof usePrInbox>['items'][number];
+
+type PrReviewInboxListProps = {
+  /** The "Paste a PR link" block, rendered above the Inbox eyebrow. */
+  header: ReactNode;
+  /** The recents body, rendered below the pagination footer. */
+  recents: ReactNode;
+};
+
+export function PrReviewInboxList({ header, recents }: Readonly<PrReviewInboxListProps>) {
+  const { query, items, firstPageErrorState, laterPageError } = usePrInbox(true);
+  const view = selectPrInboxView({
+    isLoading: query.isPending,
+    itemCount: items.length,
+    firstPageErrorState,
+    laterPageError,
+  });
+
+  return (
+    <FlashList
+      data={view.kind === 'happy' ? items : []}
+      keyExtractor={item => `${item.owner}/${item.repo}#${item.number}`}
+      renderItem={({ item }) => <InboxRow item={item} />}
+      ListHeaderComponent={
+        <View className="gap-6 px-6 pt-4">
+          {header}
+          <InboxEyebrow />
+        </View>
+      }
+      ListEmptyComponent={
+        <InboxEmpty
+          view={view}
+          onRetry={() => {
+            void query.refetch();
+          }}
+          isRetrying={query.isFetching}
+        />
+      }
+      ListFooterComponent={
+        <View className="gap-6 px-6 pb-12 pt-4">
+          {view.showLoadMoreRetry ? (
+            <LoadMoreRetry
+              onRetry={() => {
+                void query.fetchNextPage();
+              }}
+            />
+          ) : null}
+          <RecentEyebrow />
+          {recents}
+        </View>
+      }
+      onEndReached={() => {
+        if (query.hasNextPage && !query.isFetchingNextPage) {
+          void query.fetchNextPage();
+        }
+      }}
+      onEndReachedThreshold={0.5}
+      keyboardShouldPersistTaps="handled"
+      automaticallyAdjustKeyboardInsets
+    />
+  );
+}
+
+function InboxEyebrow() {
+  const colors = useThemeColors();
+  return (
+    <View className="flex-row items-center gap-2">
+      <Inbox size={16} color={colors.mutedForeground} />
+      <Text variant="small" className="uppercase tracking-wide text-muted-foreground">
+        Inbox
+      </Text>
+    </View>
+  );
+}
+
+function RecentEyebrow() {
+  const colors = useThemeColors();
+  return (
+    <View className="flex-row items-center gap-2">
+      <Clock size={16} color={colors.mutedForeground} />
+      <Text variant="small" className="uppercase tracking-wide text-muted-foreground">
+        Recent
+      </Text>
+    </View>
+  );
+}
+
+function InboxRow({ item }: Readonly<{ item: InboxItem }>) {
+  const router = useRouter();
+  const colors = useThemeColors();
+  const updatedLabel = timeAgo(parseTimestamp(item.updatedAt));
+
+  return (
+    <Pressable
+      onPress={() => {
+        router.push(getPrReviewPath(item.owner, item.repo, item.number));
+      }}
+      accessibilityRole="button"
+      accessibilityLabel={`${item.owner}/${item.repo}#${item.number}`}
+      className="flex-row items-center gap-3 border-b-[0.5px] border-hair-soft px-6 py-3 active:opacity-70"
+    >
+      <View className="flex-1 gap-1">
+        <Text className="text-sm font-medium" numberOfLines={1}>
+          {item.title}
+        </Text>
+        <View className="flex-row items-center gap-2">
+          <Text variant="muted" className="text-xs">
+            {item.owner}/{item.repo}#{item.number} · {updatedLabel}
+          </Text>
+          {item.isDraft ? (
+            <View className="rounded-full bg-secondary px-2 py-0.5">
+              <Text variant="muted" className="text-[10px] font-medium">
+                Draft
+              </Text>
+            </View>
+          ) : null}
+        </View>
+      </View>
+      <ChevronRight size={16} color={colors.mutedForeground} />
+    </Pressable>
+  );
+}
+
+function InboxEmpty({
+  view,
+  onRetry,
+  isRetrying,
+}: Readonly<{ view: PrInboxView; onRetry: () => void; isRetrying: boolean }>) {
+  if (view.kind === 'loading') {
+    return (
+      <View accessibilityLabel="Loading inbox">
+        {Array.from({ length: SKELETON_ROW_COUNT }).map((_, index) => (
+          // eslint-disable-next-line react/no-array-index-key -- skeleton placeholders have no stable id
+          <View key={index} className="gap-2 border-b-[0.5px] border-hair-soft px-6 py-3">
+            <Skeleton className="h-3.5 w-2/3" />
+            <Skeleton className="h-3 w-1/3" />
+          </View>
+        ))}
+      </View>
+    );
+  }
+
+  if (view.kind === 'empty') {
+    return (
+      <EmptyState
+        icon={GitPullRequest}
+        title="No review requests"
+        description="Pull requests waiting on your review show up here. You can still paste any PR link above."
+        placement="top"
+      />
+    );
+  }
+
+  if (view.kind === 'permission') {
+    return <QueryError variant="permission" placement="top" />;
+  }
+
+  if (view.kind === 'not-found') {
+    return <QueryError variant="not-found" placement="top" />;
+  }
+
+  if (view.kind === 'reconnect') {
+    return (
+      <View className="px-6 py-6">
+        <PrReviewReconnectNotice />
+      </View>
+    );
+  }
+
+  // retryable
+  return (
+    <QueryError
+      variant="server"
+      title="Could not load inbox"
+      message="Something went wrong on our end. Please try again."
+      placement="top"
+      onRetry={onRetry}
+      isRetrying={isRetrying}
+    />
+  );
+}
+
+function LoadMoreRetry({ onRetry }: Readonly<{ onRetry: () => void }>) {
+  return (
+    <View className="items-center gap-2">
+      <Text variant="muted" className="text-center text-xs">
+        Couldn&apos;t load more
+      </Text>
+      <Button size="sm" variant="outline" onPress={onRetry} accessibilityLabel="Retry loading more">
+        <Text>Retry</Text>
+      </Button>
+    </View>
+  );
+}
diff --git a/apps/mobile/src/components/pr-review/pr-review-inbox-view.test.ts b/apps/mobile/src/components/pr-review/pr-review-inbox-view.test.ts
new file mode 100644
index 0000000000..0367fe7b0e
--- /dev/null
+++ b/apps/mobile/src/components/pr-review/pr-review-inbox-view.test.ts
@@ -0,0 +1,108 @@
+import { describe, expect, it } from 'vitest';
+
+import { selectPrInboxView } from './pr-review-inbox-view';
+
+function state(kind: 'retryable' | 'permission' | 'not-found' | 'reconnect') {
+  return { kind };
+}
+
+describe('selectPrInboxView', () => {
+  it('selects loading when the first page is still in flight', () => {
+    expect(
+      selectPrInboxView({
+        isLoading: true,
+        itemCount: 0,
+        firstPageErrorState: null,
+        laterPageError: false,
+      })
+    ).toEqual({ kind: 'loading', showLoadMoreRetry: false });
+  });
+
+  it('selects happy when rows are loaded', () => {
+    expect(
+      selectPrInboxView({
+        isLoading: false,
+        itemCount: 3,
+        firstPageErrorState: null,
+        laterPageError: false,
+      })
+    ).toEqual({ kind: 'happy', showLoadMoreRetry: false });
+  });
+
+  it('selects empty when no rows and no error', () => {
+    expect(
+      selectPrInboxView({
+        isLoading: false,
+        itemCount: 0,
+        firstPageErrorState: null,
+        laterPageError: false,
+      })
+    ).toEqual({ kind: 'empty', showLoadMoreRetry: false });
+  });
+
+  it('selects retryable for a transient first-page error', () => {
+    expect(
+      selectPrInboxView({
+        isLoading: false,
+        itemCount: 0,
+        firstPageErrorState: state('retryable'),
+        laterPageError: false,
+      })
+    ).toEqual({ kind: 'retryable', showLoadMoreRetry: false });
+  });
+
+  it('selects permission for a FORBIDDEN first-page error', () => {
+    expect(
+      selectPrInboxView({
+        isLoading: false,
+        itemCount: 0,
+        firstPageErrorState: state('permission'),
+        laterPageError: false,
+      })
+    ).toEqual({ kind: 'permission', showLoadMoreRetry: false });
+  });
+
+  it('selects not-found for a NOT_FOUND first-page error', () => {
+    expect(
+      selectPrInboxView({
+        isLoading: false,
+        itemCount: 0,
+        firstPageErrorState: state('not-found'),
+        laterPageError: false,
+      })
+    ).toEqual({ kind: 'not-found', showLoadMoreRetry: false });
+  });
+
+  it('selects reconnect for a PRECONDITION_FAILED first-page error', () => {
+    expect(
+      selectPrInboxView({
+        isLoading: false,
+        itemCount: 0,
+        firstPageErrorState: state('reconnect'),
+        laterPageError: false,
+      })
+    ).toEqual({ kind: 'reconnect', showLoadMoreRetry: false });
+  });
+
+  it('flags the load-more retry row only on a later-page failure with rows loaded', () => {
+    expect(
+      selectPrInboxView({
+        isLoading: false,
+        itemCount: 5,
+        firstPageErrorState: null,
+        laterPageError: true,
+      })
+    ).toEqual({ kind: 'happy', showLoadMoreRetry: true });
+  });
+
+  it('never flags the load-more retry row outside the happy state', () => {
+    expect(
+      selectPrInboxView({
+        isLoading: true,
+        itemCount: 0,
+        firstPageErrorState: null,
+        laterPageError: true,
+      })
+    ).toEqual({ kind: 'loading', showLoadMoreRetry: false });
+  });
+});
diff --git a/apps/mobile/src/components/pr-review/pr-review-inbox-view.ts b/apps/mobile/src/components/pr-review/pr-review-inbox-view.ts
new file mode 100644
index 0000000000..49a34bbfab
--- /dev/null
+++ b/apps/mobile/src/components/pr-review/pr-review-inbox-view.ts
@@ -0,0 +1,46 @@
+// Pure state selection for the PR inbox list. Kept out of JSX so every
+// branch is unit-tested. The inbox has the same four-state matrix as the
+// rest of the PR Review surface, plus a later-page failure that keeps
+// already-loaded rows and offers an inline retry.
+
+import { type classifyPrReviewQueryState } from '@/lib/pr-review/classify-pr-review-query-state';
+
+type PrReviewQueryState = ReturnType<typeof classifyPrReviewQueryState>;
+
+type PrInboxViewKind =
+  | 'loading'
+  | 'happy'
+  | 'empty'
+  | 'retryable'
+  | 'permission'
+  | 'not-found'
+  | 'reconnect';
+
+export type PrInboxView = {
+  kind: PrInboxViewKind;
+  /** Show the inline "Couldn't load more" + Retry footer row. */
+  showLoadMoreRetry: boolean;
+};
+
+export function selectPrInboxView(args: {
+  isLoading: boolean;
+  itemCount: number;
+  firstPageErrorState: PrReviewQueryState | null;
+  laterPageError: boolean;
+}): PrInboxView {
+  const { isLoading, itemCount, firstPageErrorState, laterPageError } = args;
+
+  if (firstPageErrorState) {
+    return { kind: firstPageErrorState.kind, showLoadMoreRetry: false };
+  }
+
+  if (isLoading) {
+    return { kind: 'loading', showLoadMoreRetry: false };
+  }
+
+  if (itemCount === 0) {
+    return { kind: 'empty', showLoadMoreRetry: false };
+  }
+
+  return { kind: 'happy', showLoadMoreRetry: laterPageError };
+}
diff --git a/apps/mobile/src/components/pr-review/pr-review-pending-comment-row.tsx b/apps/mobile/src/components/pr-review/pr-review-pending-comment-row.tsx
index 1a820802a3..95461a347f 100644
--- a/apps/mobile/src/components/pr-review/pr-review-pending-comment-row.tsx
+++ b/apps/mobile/src/components/pr-review/pr-review-pending-comment-row.tsx
@@ -18,6 +18,8 @@ type PrReviewPendingCommentRowProps = Readonly<{
   onPress: () => void;
   onDelete: () => void;
   disabled?: boolean;
+  /** True when the comment was written against an older commit than the PR head. */
+  stale?: boolean;
 }>;
 
 export function PrReviewPendingCommentRow({
@@ -25,6 +27,7 @@ export function PrReviewPendingCommentRow({
   onPress,
   onDelete,
   disabled = false,
+  stale = false,
 }: PrReviewPendingCommentRowProps) {
   const colors = useThemeColors();
   const location = pendingCommentLocationLabel(item);
@@ -35,7 +38,11 @@ export function PrReviewPendingCommentRow({
         onPress={onPress}
         disabled={disabled}
         accessibilityRole="button"
-        accessibilityLabel={`Edit pending comment on ${location}`}
+        accessibilityLabel={
+          stale
+            ? `Edit outdated pending comment on ${location}`
+            : `Edit pending comment on ${location}`
+        }
         className="min-h-9 flex-1 gap-0.5 active:opacity-70"
       >
         <Text className="font-mono-medium text-[11px] text-muted-foreground" numberOfLines={1}>
@@ -44,6 +51,18 @@ export function PrReviewPendingCommentRow({
         <Text className="text-xs leading-4 text-foreground" numberOfLines={1}>
           {item.body.trim().length > 0 ? item.body : '(empty)'}
         </Text>
+        {stale ? (
+          <View className="flex-row items-center gap-1.5">
+            <View className="rounded-full border border-warn-tile-border bg-warn-tile-bg px-2 py-0.5">
+              <Text className="text-[10px] font-medium uppercase tracking-wide text-warn">
+                Outdated
+              </Text>
+            </View>
+            <Text className="flex-1 text-[10px] text-muted-foreground">
+              the PR moved since you wrote this.
+            </Text>
+          </View>
+        ) : null}
       </Pressable>
       <Pressable
         onPress={onDelete}
@@ -90,17 +109,17 @@ function pendingCommentLocationLabel(item: {
 
 export function PendingQueueHint({
   queuedCount,
-  hasStaleItems,
+  staleCount,
 }: {
   queuedCount: number;
-  hasStaleItems: boolean;
+  staleCount: number;
 }) {
   let message = '';
   if (queuedCount === 0) {
     message = 'No comments queued. The review will be submitted with just the event above.';
-  } else if (hasStaleItems) {
+  } else if (staleCount > 0) {
     message =
-      'Some comments may be outdated because the PR head changed after they were queued. Submission will use the current head.';
+      'Comments written against an older commit are not sent. They stay in your queue so you can edit or delete them.';
   } else {
     message = 'All comments will be sent in a single batched request.';
   }
diff --git a/apps/mobile/src/components/pr-review/pr-review-screen.tsx b/apps/mobile/src/components/pr-review/pr-review-screen.tsx
index 253d792d27..d060aabe43 100644
--- a/apps/mobile/src/components/pr-review/pr-review-screen.tsx
+++ b/apps/mobile/src/components/pr-review/pr-review-screen.tsx
@@ -1,7 +1,7 @@
 import { useQuery, useQueryClient } from '@tanstack/react-query';
 import { type Href, useFocusEffect, useRouter } from 'expo-router';
 import { Check, Share as ShareIcon } from '@/components/ui/icons';
-import { type ReactNode, useCallback, useEffect, useState } from 'react';
+import { type ReactNode, useCallback, useEffect, useRef, useState } from 'react';
 import { Pressable, RefreshControl, ScrollView, Share, View } from 'react-native';
 
 import { PrMergePartialSuccessBanner } from '@/components/pr-review/merge/pr-merge-partial-success-banner';
@@ -17,7 +17,7 @@ import { Button } from '@/components/ui/button';
 import { Text } from '@/components/ui/text';
 import { consumeMergePartialSuccess } from '@/lib/pr-review/merge/merge-result-banner-store';
 import { useThemeColors } from '@/lib/hooks/use-theme-colors';
-import { upsertRecentPr } from '@/lib/pr-review/recent-prs';
+import { markRecentPrFailed, upsertRecentPr } from '@/lib/pr-review/recent-prs';
 import { useTRPC } from '@/lib/trpc';
 import { cn } from '@/lib/utils';
 
@@ -84,9 +84,10 @@ export function PrReviewScreen({ owner, repo, number }: PrReviewScreenProps) {
   // a single network round-trip even though both components subscribe.
   const pr = useQuery(trpc.githubPrReview.getPullRequest.queryOptions({ owner, repo, number }));
 
-  // Recents title backfill. S4b left the title empty so the recents row
-  // can be written before the PR loads. Once we have the real title,
-  // upsert it so the recents list shows it next time.
+  // Recents backfill. This is the ONLY writer that creates an entry: a
+  // successful load upserts the real title with `lastResult: 'ok'`, which
+  // also clears any previous `'failed'` marker. A never-authorized PR
+  // (no successful load) never gets an entry.
   useEffect(() => {
     const data = pr.data;
     if (!data?.title) {
@@ -98,9 +99,28 @@ export function PrReviewScreen({ owner, repo, number }: PrReviewScreenProps) {
       number,
       title: data.title,
       lastOpenedAt: Date.now(),
+      lastResult: 'ok',
     });
   }, [pr.data, owner, repo, number]);
 
+  // Mark an existing recents entry as failed exactly once per error. The
+  // ref guards against re-writing on re-render; `markRecentPrFailed` is a
+  // no-op when no entry exists, so a never-authorized PR stays out of
+  // recents. A success (isError false) or a PR identity change resets the
+  // guard so a later error marks the entry failed again.
+  const markedFailedRef = useRef(false);
+  useEffect(() => {
+    if (!pr.isError) {
+      markedFailedRef.current = false;
+      return;
+    }
+    if (markedFailedRef.current) {
+      return;
+    }
+    markedFailedRef.current = true;
+    void markRecentPrFailed({ owner, repo, number });
+  }, [pr.isError, owner, repo, number]);
+
   // Share the PR's public GitHub URL via the native share sheet. The URL comes
   // from the route params, so this works before the PR query resolves; the title
   // is added once it is known. Fire-and-forget, like the invite-link share in
diff --git a/apps/mobile/src/components/pr-review/pr-review-submit-view.test.ts b/apps/mobile/src/components/pr-review/pr-review-submit-view.test.ts
new file mode 100644
index 0000000000..0e9a6893a0
--- /dev/null
+++ b/apps/mobile/src/components/pr-review/pr-review-submit-view.test.ts
@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  selectPartialSubmitMessage,
+  selectSubmitCtaLabel,
+} from '@/components/pr-review/pr-review-submit-view';
+
+describe('selectSubmitCtaLabel', () => {
+  it('uses the plain label when nothing is stale', () => {
+    expect(selectSubmitCtaLabel({ freshCount: 3, totalCount: 3 })).toBe('Submit review');
+  });
+
+  it('uses the partial label when some items are stale', () => {
+    expect(selectSubmitCtaLabel({ freshCount: 2, totalCount: 5 })).toBe('Submit 2 of 5 comments');
+  });
+
+  it('uses the partial label even when no item is fresh', () => {
+    expect(selectSubmitCtaLabel({ freshCount: 0, totalCount: 4 })).toBe('Submit 0 of 4 comments');
+  });
+});
+
+describe('selectPartialSubmitMessage', () => {
+  it('returns null when nothing is stale', () => {
+    expect(selectPartialSubmitMessage({ freshCount: 3, staleCount: 0 })).toBeNull();
+  });
+
+  it('reports the posted and kept counts when some items are stale', () => {
+    expect(selectPartialSubmitMessage({ freshCount: 2, staleCount: 3 })).toBe(
+      'Posted 2 comment(s). 3 comment(s) point at an older commit and stayed in your queue.'
+    );
+  });
+
+  it('reports zero posted comments when every item is stale', () => {
+    expect(selectPartialSubmitMessage({ freshCount: 0, staleCount: 4 })).toBe(
+      'Posted 0 comment(s). 4 comment(s) point at an older commit and stayed in your queue.'
+    );
+  });
+});
diff --git a/apps/mobile/src/components/pr-review/pr-review-submit-view.ts b/apps/mobile/src/components/pr-review/pr-review-submit-view.ts
new file mode 100644
index 0000000000..33ed2e2712
--- /dev/null
+++ b/apps/mobile/src/components/pr-review/pr-review-submit-view.ts
@@ -0,0 +1,22 @@
+/**
+ * Pure copy selectors for the review-submit sheet's stale-head path. Kept
+ * out of the component so the submit CTA label and the partial-result
+ * message are unit-testable without mounting the sheet.
+ */
+
+export function selectSubmitCtaLabel(args: { freshCount: number; totalCount: number }): string {
+  if (args.totalCount > args.freshCount) {
+    return `Submit ${args.freshCount} of ${args.totalCount} comments`;
+  }
+  return 'Submit review';
+}
+
+export function selectPartialSubmitMessage(args: {
+  freshCount: number;
+  staleCount: number;
+}): string | null {
+  if (args.staleCount === 0) {
+    return null;
+  }
+  return `Posted ${args.freshCount} comment(s). ${args.staleCount} comment(s) point at an older commit and stayed in your queue.`;
+}
diff --git a/apps/mobile/src/components/pr-review/pr-review-submit.test.tsx b/apps/mobile/src/components/pr-review/pr-review-submit.test.tsx
new file mode 100644
index 0000000000..2e599d130f
--- /dev/null
+++ b/apps/mobile/src/components/pr-review/pr-review-submit.test.tsx
@@ -0,0 +1,215 @@
+/* eslint-disable typescript-eslint/no-deprecated -- react-test-renderer is the DOM-free renderer used to mount React/RN trees under vitest (node env, no jsdom); see src/lib/pr-review/pending-review-provider.mounted.test.tsx */
+/* eslint-disable require-await, @typescript-eslint/require-await -- the fake mutation and drafts factories settle without await because they resolve immediately */
+import TestRenderer, { act } from 'react-test-renderer';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { PrReviewSubmit } from './pr-review-submit';
+import {
+  type PendingReviewItem,
+  PendingReviewProvider,
+  usePendingReview,
+} from '@/lib/pr-review/pending-review-provider';
+
+const submitMutationMock = vi.hoisted(() => ({
+  mutateAsync: vi.fn(async (): Promise<unknown> => undefined),
+}));
+
+vi.mock('@/lib/pr-review/use-pr-review-mutations', () => ({
+  useSubmitReviewMutation: () => ({
+    mutateAsync: submitMutationMock.mutateAsync,
+    isPending: false,
+    error: null,
+  }),
+}));
+
+vi.mock('@/components/pr-review/discussion/reply-input', () => ({
+  ensureTermsAcceptedOutcome: vi.fn(async () => ({ kind: 'accepted' as const })),
+  TERMS_CHECK_RETRY_COPY: 'terms-check-retry',
+  TERMS_OUTDATED_COPY: 'terms-outdated',
+}));
+
+vi.mock('@sentry/react-native', () => ({ captureException: vi.fn() }));
+
+vi.mock('@/lib/persist/drafts', () => ({
+  loadDraft: vi.fn(async (): Promise<unknown> => null),
+  saveDraft: vi.fn(async (): Promise<void> => undefined),
+  clearDraft: vi.fn(async (): Promise<void> => undefined),
+  prReviewDraftKey: (owner: string, repo: string, number: number) =>
+    `pr-review:${owner}/${repo}#${number}`,
+}));
+
+vi.mock('@/lib/persist/use-draft-flush', () => ({
+  useDraftFlushOnBackground: vi.fn(),
+}));
+
+// `mutation-error-display` imports the PR operation-ledger helpers, which
+// import `expo-crypto` (and transitively expo-modules-core). Mock it so this
+// suite stays node-only, same as the other ledger pure tests.
+vi.mock('expo-crypto', () => ({
+  randomUUID: () => 'not-used-in-pure-tests',
+}));
+
+vi.mock('expo-haptics', () => ({
+  notificationAsync: vi.fn(),
+}));
+
+vi.mock('expo-router', () => ({
+  useRouter: () => ({ push: vi.fn() }),
+}));
+
+vi.mock('react-native', () => ({
+  Alert: { alert: vi.fn() },
+  Keyboard: { addListener: () => ({ remove: vi.fn() }) },
+  ScrollView: 'ScrollView',
+  TextInput: 'TextInput',
+  View: 'View',
+}));
+
+vi.mock('@/components/pr-review/pr-form-sheet-chrome', () => ({
+  PrFormSheetFooter: 'PrFormSheetFooter',
+  PrFormSheetHeader: 'PrFormSheetHeader',
+  useFormSheetKeyboardVisible: () => false,
+}));
+vi.mock('@/components/pr-review/review-event-chips', () => ({
+  ReviewEventChips: 'ReviewEventChips',
+}));
+vi.mock('@/components/ui/button', () => ({ Button: 'Button' }));
+vi.mock('@/components/ui/accessible-status', () => ({ AccessibleStatus: 'AccessibleStatus' }));
+vi.mock('@/components/ui/text', () => ({ Text: 'Text' }));
+vi.mock('@/components/pr-review/pr-review-pending-comment-row', () => ({
+  focusAfterPendingCommentRemoval: vi.fn(),
+  PendingQueueHint: 'PendingQueueHint',
+  PrReviewPendingCommentRow: 'PrReviewPendingCommentRow',
+  ReviewSummaryField: 'ReviewSummaryField',
+}));
+vi.mock('@/components/pr-review/pr-review-reconnect-notice', () => ({
+  PrReviewReconnectNotice: 'PrReviewReconnectNotice',
+}));
+
+const ITEM_FRESH_A: PendingReviewItem = {
+  id: 'fresh-a',
+  path: 'src/a.ts',
+  side: 'RIGHT',
+  line: 1,
+  body: 'A',
+  commitSha: 'head-1',
+};
+const ITEM_FRESH_B: PendingReviewItem = {
+  id: 'fresh-b',
+  path: 'src/b.ts',
+  side: 'RIGHT',
+  line: 2,
+  body: 'B',
+  commitSha: 'head-1',
+};
+const ITEM_STALE: PendingReviewItem = {
+  id: 'stale-c',
+  path: 'src/c.ts',
+  side: 'RIGHT',
+  line: 3,
+  body: 'C',
+  commitSha: 'head-0',
+};
+
+let latestItems: PendingReviewItem[] = [];
+let addCommentFn: ((item: PendingReviewItem) => void) | null = null;
+
+function Consumer() {
+  const value = usePendingReview();
+  latestItems = value.items;
+  addCommentFn = value.addComment;
+  return null;
+}
+
+function mount(): TestRenderer.ReactTestRenderer {
+  let renderer: TestRenderer.ReactTestRenderer | undefined = undefined;
+  act(() => {
+    renderer = TestRenderer.create(
+      <PendingReviewProvider>
+        <Consumer />
+        <PrReviewSubmit
+          owner="acme"
+          repo="kilo"
+          number={42}
+          headSha="head-1"
+          title="Submit review"
+          eyebrow="acme/kilo#42"
+          onDismiss={vi.fn(() => undefined)}
+        />
+      </PendingReviewProvider>
+    );
+  });
+  // eslint-disable-next-line typescript-eslint/no-unnecessary-condition
+  if (!renderer) {
+    throw new Error('Failed to mount PrReviewSubmit');
+  }
+  return renderer;
+}
+
+async function flush(): Promise<void> {
+  await act(async () => {
+    await new Promise(resolve => {
+      setTimeout(resolve, 0);
+    });
+  });
+}
+
+function submitOnPress(renderer: TestRenderer.ReactTestRenderer): () => void {
+  const button = renderer.root.findAll(
+    node => node.props.accessibilityLabel === 'Submit 2 of 3 comments'
+  )[0];
+  if (!button) {
+    throw new Error('Submit button not found');
+  }
+  return button.props.onPress as () => void;
+}
+
+beforeEach(() => {
+  latestItems = [];
+  addCommentFn = null;
+  submitMutationMock.mutateAsync.mockReset();
+  submitMutationMock.mutateAsync.mockResolvedValue(undefined);
+});
+
+describe('PrReviewSubmit queue retention', () => {
+  it('keeps every queued item when a submit fails', async () => {
+    submitMutationMock.mutateAsync.mockRejectedValueOnce(new Error('network down'));
+    const renderer = mount();
+
+    act(() => {
+      addCommentFn?.(ITEM_FRESH_A);
+      addCommentFn?.(ITEM_FRESH_B);
+      addCommentFn?.(ITEM_STALE);
+    });
+    expect(latestItems.map(item => item.id)).toEqual(['fresh-a', 'fresh-b', 'stale-c']);
+
+    act(() => {
+      submitOnPress(renderer)();
+    });
+    await flush();
+
+    // A failed submit reaches the catch path, which drains nothing: the fresh
+    // and stale items all stay queued, with no optimistic removal.
+    expect(submitMutationMock.mutateAsync).toHaveBeenCalledTimes(1);
+    expect(latestItems.map(item => item.id)).toEqual(['fresh-a', 'fresh-b', 'stale-c']);
+  });
+
+  it('removes only the fresh items on success, leaving stale items queued', async () => {
+    const renderer = mount();
+
+    act(() => {
+      addCommentFn?.(ITEM_FRESH_A);
+      addCommentFn?.(ITEM_FRESH_B);
+      addCommentFn?.(ITEM_STALE);
+    });
+
+    act(() => {
+      submitOnPress(renderer)();
+    });
+    await flush();
+
+    // Success removes exactly the fresh ids; the stale item stays queued.
+    expect(submitMutationMock.mutateAsync).toHaveBeenCalledTimes(1);
+    expect(latestItems.map(item => item.id)).toEqual(['stale-c']);
+  });
+});
diff --git a/apps/mobile/src/components/pr-review/pr-review-submit.tsx b/apps/mobile/src/components/pr-review/pr-review-submit.tsx
index 7955d1c8e4..8d25053eb2 100644
--- a/apps/mobile/src/components/pr-review/pr-review-submit.tsx
+++ b/apps/mobile/src/components/pr-review/pr-review-submit.tsx
@@ -1,6 +1,8 @@
+/* eslint-disable max-lines -- the submit sheet composes the event radio, summary, pending-comments list, and the stale/fresh partition in one cohesive surface. */
 // Review-submit content: event radio, optional summary, pending-comments
-// list (view/edit/delete), and one batched submitReview call. Queue is
-// cleared on success and retained on failure.
+// list (view/edit/delete), and one batched submitReview call. On success the
+// fresh comments are removed and stale comments stay queued; on failure the
+// whole queue is retained.
 //
 // Disable lifetime: bad-request clears on event/summary change; forbidden
 // stays for the rest of the sheet session. Toasts paint behind formSheets
@@ -40,7 +42,12 @@ import {
 import { classifyPrReviewMutationError } from '@/lib/pr-review/classify-pr-review-query-state';
 import { mutationErrorDisplay } from '@/lib/pr-review/mutation-error-display';
 import { type PendingReviewItem, usePendingReview } from '@/lib/pr-review/pending-review-provider';
+import { partitionPendingItems } from '@/lib/pr-review/partition-pending-items';
 import { useSubmitReviewMutation } from '@/lib/pr-review/use-pr-review-mutations';
+import {
+  selectPartialSubmitMessage,
+  selectSubmitCtaLabel,
+} from '@/components/pr-review/pr-review-submit-view';
 
 const COMMENT_COMPOSER_PATH = '/(app)/pr-review/[owner]/[repo]/[number]/comment-composer' as const;
 
@@ -66,6 +73,7 @@ export function PrReviewSubmit(props: PrReviewSubmitProps) {
   const [inlineErrorKind, setInlineErrorKind] = useState<
     'retryable' | 'bad-request' | 'forbidden' | 'reconnect' | null
   >(null);
+  const [partialResult, setPartialResult] = useState<string | null>(null);
 
   const bodyRef = useRef<string>('');
   const bodyInputRef = useRef<TextInput | null>(null);
@@ -73,11 +81,16 @@ export function PrReviewSubmit(props: PrReviewSubmitProps) {
 
   const isSubmitting = submitReview.isPending;
   const queuedCount = pending.items.length;
-  const hasStaleItems = pending.items.some(item => item.commitSha !== headSha);
+  const { fresh, stale } = partitionPendingItems(pending.items, headSha);
+  const staleIds = new Set(stale.map(item => item.id));
   const blockReason = reviewSubmitBlockReason({
     event,
     hasSummary,
-    commentCount: queuedCount,
+    commentCount: fresh.length,
+  });
+  const submitLabel = selectSubmitCtaLabel({
+    freshCount: fresh.length,
+    totalCount: pending.items.length,
   });
 
   useEffect(() => {
@@ -130,6 +143,7 @@ export function PrReviewSubmit(props: PrReviewSubmitProps) {
   async function handleSubmit() {
     setInlineError(null);
     setInlineErrorKind(null);
+    setPartialResult(null);
     const outcome = await ensureTermsAcceptedOutcome();
     if (outcome.kind === 'outdated') {
       setInlineError(TERMS_OUTDATED_COPY);
@@ -149,12 +163,20 @@ export function PrReviewSubmit(props: PrReviewSubmitProps) {
           event,
           ...(body.length > 0 ? { body } : {}),
           commitSha: headSha,
-          items: pending.items,
+          items: fresh,
         })
       );
-      pending.clear();
+      pending.removeComments(fresh.map(item => item.id));
       void Haptics.notificationAsync(Haptics.NotificationFeedbackType.Success);
-      onDismiss();
+      if (stale.length > 0) {
+        // Stale items stay queued: keep the sheet open and report the partial
+        // result instead of dismissing, so the user can edit or delete them.
+        setPartialResult(
+          selectPartialSubmitMessage({ freshCount: fresh.length, staleCount: stale.length })
+        );
+      } else {
+        onDismiss();
+      }
     } catch {
       // Classified into inlineError by the effect above.
     }
@@ -212,8 +234,8 @@ export function PrReviewSubmit(props: PrReviewSubmitProps) {
   let queueHint: ReactNode = null;
   if (blockReason !== null) {
     queueHint = <AccessibleStatus message={blockReason} tone="status" className="text-xs" />;
-  } else if (!keyboardVisible && (queuedCount === 0 || hasStaleItems)) {
-    queueHint = <PendingQueueHint queuedCount={queuedCount} hasStaleItems={hasStaleItems} />;
+  } else if (!keyboardVisible && (queuedCount === 0 || stale.length > 0)) {
+    queueHint = <PendingQueueHint queuedCount={queuedCount} staleCount={stale.length} />;
   }
 
   // PickerSheet invariant: [header, ScrollView]; footer is trailing content.
@@ -262,6 +284,7 @@ export function PrReviewSubmit(props: PrReviewSubmitProps) {
                   <PrReviewPendingCommentRow
                     key={item.id}
                     item={item}
+                    stale={staleIds.has(item.id)}
                     disabled={isSubmitting}
                     onPress={() => {
                       openEditComposer(item);
@@ -274,6 +297,10 @@ export function PrReviewSubmit(props: PrReviewSubmitProps) {
               : null}
           </View>
 
+          {partialResult ? (
+            <AccessibleStatus message={partialResult} tone="status" className="text-xs" />
+          ) : null}
+
           {inlineError && inlineErrorKind !== 'reconnect' ? (
             <View className="rounded-md border border-destructive bg-red-50 dark:bg-red-950 px-2.5 py-2">
               {/* Mutation-classified errors are toast-owned (announcingToast);
@@ -300,9 +327,9 @@ export function PrReviewSubmit(props: PrReviewSubmitProps) {
             }}
             loading={isSubmitting}
             disabled={submitDisabled}
-            accessibilityLabel="Submit review"
+            accessibilityLabel={submitLabel}
           >
-            <Text>Submit review</Text>
+            <Text>{submitLabel}</Text>
           </Button>
           <Button
             variant="ghost"
diff --git a/apps/mobile/src/components/pr-review/recent-pr-row-state.test.ts b/apps/mobile/src/components/pr-review/recent-pr-row-state.test.ts
new file mode 100644
index 0000000000..9a16af0c47
--- /dev/null
+++ b/apps/mobile/src/components/pr-review/recent-pr-row-state.test.ts
@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'vitest';
+
+import { selectRecentPrRowState } from './recent-pr-row-state';
+import { type RecentPr } from '@/lib/pr-review/recent-prs';
+
+function makeRecent(overrides: Partial<RecentPr> = {}): RecentPr {
+  return {
+    owner: 'octocat',
+    repo: 'hello-world',
+    number: 42,
+    title: 'Hello PR',
+    lastOpenedAt: 1_700_000_000_000,
+    ...overrides,
+  };
+}
+
+describe('selectRecentPrRowState', () => {
+  it('uses the title as primary and the identity as secondary', () => {
+    expect(selectRecentPrRowState(makeRecent({ title: 'Hello PR' }))).toEqual({
+      primary: 'Hello PR',
+      secondary: 'octocat/hello-world#42',
+      failed: false,
+    });
+  });
+
+  it('drops the secondary line when the title is empty (no duplicate)', () => {
+    expect(selectRecentPrRowState(makeRecent({ title: '' }))).toEqual({
+      primary: 'octocat/hello-world#42',
+      secondary: null,
+      failed: false,
+    });
+  });
+
+  it('marks a failed entry', () => {
+    expect(selectRecentPrRowState(makeRecent({ lastResult: 'failed' }))).toEqual({
+      primary: 'Hello PR',
+      secondary: 'octocat/hello-world#42',
+      failed: true,
+    });
+  });
+
+  it('treats a missing lastResult as ok', () => {
+    expect(selectRecentPrRowState(makeRecent()).failed).toBe(false);
+  });
+});
diff --git a/apps/mobile/src/components/pr-review/recent-pr-row-state.ts b/apps/mobile/src/components/pr-review/recent-pr-row-state.ts
new file mode 100644
index 0000000000..806037cfb1
--- /dev/null
+++ b/apps/mobile/src/components/pr-review/recent-pr-row-state.ts
@@ -0,0 +1,24 @@
+// Pure row-state selection for a recents entry. Extracted so the
+// duplicated fallback line (title-less entries printing the identity
+// twice) and the failed-entry marker are unit-tested.
+
+import { type RecentPr } from '@/lib/pr-review/recent-prs';
+
+export type RecentPrRowState = {
+  /** Title when non-empty, else the identity line. */
+  primary: string;
+  /** The identity line, or null when it would repeat `primary`. */
+  secondary: string | null;
+  /** True when the entry's last load attempt failed. */
+  failed: boolean;
+};
+
+export function selectRecentPrRowState(entry: RecentPr): RecentPrRowState {
+  const identity = `${entry.owner}/${entry.repo}#${entry.number}`;
+  const primary = entry.title.length > 0 ? entry.title : identity;
+  return {
+    primary,
+    secondary: primary === identity ? null : identity,
+    failed: entry.lastResult === 'failed',
+  };
+}
diff --git a/apps/mobile/src/components/ui/icons.ts b/apps/mobile/src/components/ui/icons.ts
index fea320ce0c..da158db460 100644
--- a/apps/mobile/src/components/ui/icons.ts
+++ b/apps/mobile/src/components/ui/icons.ts
@@ -70,6 +70,7 @@ export { default as HelpCircle } from 'lucide-react-native/icons/circle-question
 export { default as History } from 'lucide-react-native/icons/history';
 export { default as House } from 'lucide-react-native/icons/house';
 export { default as ImageOff } from 'lucide-react-native/icons/image-off';
+export { default as Inbox } from 'lucide-react-native/icons/inbox';
 export { default as Info } from 'lucide-react-native/icons/info';
 export { default as KeyRound } from 'lucide-react-native/icons/key-round';
 export { default as LifeBuoy } from 'lucide-react-native/icons/life-buoy';
diff --git a/apps/mobile/src/lib/notification-path.ts b/apps/mobile/src/lib/notification-path.ts
index 34351b8955..09ed680ae4 100644
--- a/apps/mobile/src/lib/notification-path.ts
+++ b/apps/mobile/src/lib/notification-path.ts
@@ -1,42 +1,29 @@
 import { type PushData } from '@kilocode/notifications';
-import { type Href } from 'expo-router';
 
 import { chatConversationRoute, chatSandboxRoute } from './kilo-chat-routes';
 import { getSecurityAgentPath } from './security-agent';
 
-/** String-form `Href` so callers can store the path as a string and still pass it to the router. */
-type NotificationHref = Extract<Href, string>;
-
-/** Widen string paths built from helpers into the typed-route string union. */
-function toNotificationHref(path: string): NotificationHref {
-  return path;
-}
-
-export function notificationPathForData(data: PushData): NotificationHref {
+export function notificationPathForData(data: PushData): string {
   // `via=push` marks the resulting session_viewed analytics event as
   // push-originated.
   switch (data.type) {
     case 'cloud_agent_session': {
-      return toNotificationHref(`/(app)/agent-chat/${data.cliSessionId}?via=push`);
+      return `/(app)/agent-chat/${data.cliSessionId}?via=push`;
     }
     case 'chat.message': {
-      return toNotificationHref(
-        `${chatConversationRoute(data.sandboxId, data.conversationId)}?via=push`
-      );
+      return `${chatConversationRoute(data.sandboxId, data.conversationId)}?via=push`;
     }
     case 'low_balance': {
-      return toNotificationHref(
-        `/(app)/(tabs)/(3_profile)/organization/credit-activity?org=${data.organizationId}&via=push`
-      );
+      return `/(app)/(tabs)/(3_profile)/organization/credit-activity?org=${data.organizationId}&via=push`;
     }
     case 'security_finding': {
       // getSecurityAgentPath returns Href; coerce to string for query append (cast style of security-agent.ts).
       const base = getSecurityAgentPath(data.scope, `findings/${data.findingId}`) as string;
-      return toNotificationHref(`${base}?via=push`);
+      return `${base}?via=push`;
     }
     case 'instance-lifecycle':
     case 'scheduled-action': {
-      return toNotificationHref(chatSandboxRoute(data.sandboxId));
+      return chatSandboxRoute(data.sandboxId);
     }
     default: {
       // Exhaustiveness: new PushData variants must be handled above.
diff --git a/apps/mobile/src/lib/pr-review/build-submit-review-input.test.ts b/apps/mobile/src/lib/pr-review/build-submit-review-input.test.ts
index b6a2ac082a..81b5b50518 100644
--- a/apps/mobile/src/lib/pr-review/build-submit-review-input.test.ts
+++ b/apps/mobile/src/lib/pr-review/build-submit-review-input.test.ts
@@ -4,6 +4,7 @@ import {
   buildSubmitReviewInput,
   reviewSubmitBlockReason,
 } from '@/lib/pr-review/build-submit-review-input';
+import { partitionPendingItems } from '@/lib/pr-review/partition-pending-items';
 import { type PendingReviewItem } from '@/lib/pr-review/pending-review-provider';
 
 function makeItem(overrides: Partial<PendingReviewItem> = {}): PendingReviewItem {
@@ -144,6 +145,25 @@ describe('buildSubmitReviewInput', () => {
     // without mutating them.
     expect(items).toHaveLength(2);
   });
+
+  it('maps a fresh-only comment list so stale bodies never reach the input', () => {
+    // The submit sheet partitions the queue and passes only the fresh subset
+    // here; a stale body must never appear in the submitted input.
+    const freshItems = [
+      makeItem({ id: 'a', path: 'a.ts', line: 1, body: 'fresh-a' }),
+      makeItem({ id: 'b', path: 'b.ts', line: 2, body: 'fresh-b' }),
+    ];
+    const input = buildSubmitReviewInput({
+      owner: 'kilocode',
+      repo: 'kilo',
+      number: 42,
+      event: 'COMMENT',
+      commitSha: 'head-2',
+      items: freshItems,
+    });
+    expect(input.comments?.map(comment => comment.body)).toEqual(['fresh-a', 'fresh-b']);
+    expect(input.comments).toHaveLength(2);
+  });
 });
 
 describe('reviewSubmitBlockReason', () => {
@@ -215,4 +235,23 @@ describe('reviewSubmitBlockReason', () => {
       reviewSubmitBlockReason({ event: 'COMMENT', hasSummary: false, commentCount: 1 })
     ).toBeNull();
   });
+
+  it('blocks when every queued comment is stale and there is no summary', () => {
+    // The submit sheet passes `commentCount: fresh.length`, so an all-stale
+    // queue (fresh.length === 0) still blocks a COMMENT/REQUEST_CHANGES
+    // submit even though the queue itself is non-empty.
+    const items = [
+      makeItem({ id: 'a', commitSha: 'old-head' }),
+      makeItem({ id: 'b', commitSha: 'old-head' }),
+    ];
+    const { fresh } = partitionPendingItems(items, 'new-head');
+    expect(fresh).toHaveLength(0);
+
+    const reason = reviewSubmitBlockReason({
+      event: 'COMMENT',
+      hasSummary: false,
+      commentCount: fresh.length,
+    });
+    expect(reason).toBe('Add a summary or at least one comment to post a comment review.');
+  });
 });
diff --git a/apps/mobile/src/lib/pr-review/build-submit-review-input.ts b/apps/mobile/src/lib/pr-review/build-submit-review-input.ts
index 3a47606060..b05bfc12f7 100644
--- a/apps/mobile/src/lib/pr-review/build-submit-review-input.ts
+++ b/apps/mobile/src/lib/pr-review/build-submit-review-input.ts
@@ -46,8 +46,8 @@ type BuildSubmitReviewInputArgs = {
 
 /**
  * Pure mapper from the pending-review queue + review event to the
- * `submitReview` tRPC input. The submission always uses the latest head SHA;
- * queued `commitSha` values are only used for the "may be outdated" hint.
+ * `submitReview` tRPC input. The caller passes only the fresh items (those
+ * whose `commitSha` matches the current head); stale items are never sent.
  *
  * Per the S3 contract, `startLine` and `startSide` must be supplied together
  * or omitted together.
diff --git a/apps/mobile/src/lib/pr-review/diff/context-window.test.ts b/apps/mobile/src/lib/pr-review/diff/context-window.test.ts
new file mode 100644
index 0000000000..78ab701491
--- /dev/null
+++ b/apps/mobile/src/lib/pr-review/diff/context-window.test.ts
@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildContextWindow } from './context-window';
+
+describe('buildContextWindow', () => {
+  it('builds the first window from the gap start', () => {
+    expect(
+      buildContextWindow({ startLine: 10, endLine: 100, alreadyLoaded: 0, windowSize: 20 })
+    ).toEqual({ startLine: 10, endLine: 29 });
+  });
+
+  it('builds a continuation window after already-loaded lines', () => {
+    expect(
+      buildContextWindow({ startLine: 10, endLine: 100, alreadyLoaded: 20, windowSize: 20 })
+    ).toEqual({ startLine: 30, endLine: 49 });
+  });
+
+  it('clamps the window by the gap endLine', () => {
+    expect(
+      buildContextWindow({ startLine: 90, endLine: 100, alreadyLoaded: 0, windowSize: 20 })
+    ).toEqual({ startLine: 90, endLine: 100 });
+  });
+});
diff --git a/apps/mobile/src/lib/pr-review/diff/context-window.ts b/apps/mobile/src/lib/pr-review/diff/context-window.ts
new file mode 100644
index 0000000000..ace3b76fee
--- /dev/null
+++ b/apps/mobile/src/lib/pr-review/diff/context-window.ts
@@ -0,0 +1,21 @@
+// Pure window arithmetic for context expansion. A gap is loaded in
+// `windowSize`-line slices; `alreadyLoaded` is the number of lines a
+// previous slice already fetched, so the next slice starts right after
+// them. The end is clamped by the gap's own `endLine` so the last slice
+// never overshoots the gap.
+
+export type ContextWindow = {
+  startLine: number;
+  endLine: number;
+};
+
+export function buildContextWindow(args: {
+  startLine: number;
+  endLine: number;
+  alreadyLoaded: number;
+  windowSize: number;
+}): ContextWindow {
+  const nextStartLine = args.startLine + args.alreadyLoaded;
+  const nextEndLine = Math.min(args.endLine, nextStartLine + args.windowSize - 1);
+  return { startLine: nextStartLine, endLine: nextEndLine };
+}
diff --git a/apps/mobile/src/lib/pr-review/diff/navigator-file-filter.test.ts b/apps/mobile/src/lib/pr-review/diff/navigator-file-filter.test.ts
new file mode 100644
index 0000000000..43ca79a676
--- /dev/null
+++ b/apps/mobile/src/lib/pr-review/diff/navigator-file-filter.test.ts
@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+
+import { filterNavigatorFiles } from './navigator-file-filter';
+import { type PrReviewFile } from './pr-review-file-types';
+
+function makeFile(path: string): PrReviewFile {
+  return {
+    path,
+    previousPath: null,
+    status: 'modified',
+    additions: 0,
+    deletions: 0,
+    patch: null,
+    patchMissing: false,
+  };
+}
+
+describe('filterNavigatorFiles', () => {
+  it('returns the input for an empty query', () => {
+    const files = [makeFile('a.ts'), makeFile('b.ts')];
+    expect(filterNavigatorFiles(files, '')).toEqual(files);
+  });
+
+  it('matches case-insensitively by substring', () => {
+    const files = [makeFile('src/App.tsx'), makeFile('src/util.ts')];
+    expect(filterNavigatorFiles(files, 'APP')).toEqual([files[0]]);
+  });
+
+  it('returns [] when nothing matches', () => {
+    const files = [makeFile('a.ts'), makeFile('b.ts')];
+    expect(filterNavigatorFiles(files, 'zzz')).toEqual([]);
+  });
+});
diff --git a/apps/mobile/src/lib/pr-review/diff/navigator-file-filter.ts b/apps/mobile/src/lib/pr-review/diff/navigator-file-filter.ts
new file mode 100644
index 0000000000..91f5785df4
--- /dev/null
+++ b/apps/mobile/src/lib/pr-review/diff/navigator-file-filter.ts
@@ -0,0 +1,14 @@
+// Pure file-filter helpers for the PR file navigator. Extracted from
+// `pr-diff-file-navigator.tsx` so the filter and the "load all" decision
+// are testable without mounting the sheet.
+
+import { type PrReviewFile } from '@/lib/pr-review/diff/pr-review-file-types';
+
+/** Case-insensitive substring filter over file paths. An empty query returns the input unchanged. */
+export function filterNavigatorFiles(files: PrReviewFile[], query: string): PrReviewFile[] {
+  const needle = query.trim().toLowerCase();
+  if (needle.length === 0) {
+    return files;
+  }
+  return files.filter(file => file.path.toLowerCase().includes(needle));
+}
diff --git a/apps/mobile/src/lib/pr-review/diff/pr-review-file-list-state.ts b/apps/mobile/src/lib/pr-review/diff/pr-review-file-list-state.ts
index 1bb64f64ee..7fb63195db 100644
--- a/apps/mobile/src/lib/pr-review/diff/pr-review-file-list-state.ts
+++ b/apps/mobile/src/lib/pr-review/diff/pr-review-file-list-state.ts
@@ -204,6 +204,14 @@ export function useFetchToCompletion(
       while (queryRef.current.hasNextPage) {
         // eslint-disable-next-line no-await-in-loop -- sequential cursor pagination
         const result = await queryRef.current.fetchNextPage();
+        // fetchNextPage resolves (does not throw) on a failed page while
+        // keeping prior pages and hasNextPage. Route that through the
+        // catch so the load-all retry can render.
+        if (result.error) {
+          throw result.error instanceof Error
+            ? result.error
+            : new Error('Failed to load next page');
+        }
         if (!result.data || !result.hasNextPage) {
           break;
         }
diff --git a/apps/mobile/src/lib/pr-review/diff/use-fetch-to-completion.mounted.test.tsx b/apps/mobile/src/lib/pr-review/diff/use-fetch-to-completion.mounted.test.tsx
new file mode 100644
index 0000000000..ca4a948d86
--- /dev/null
+++ b/apps/mobile/src/lib/pr-review/diff/use-fetch-to-completion.mounted.test.tsx
@@ -0,0 +1,81 @@
+/* eslint-disable typescript-eslint/no-deprecated -- react-test-renderer is the DOM-free renderer used to mount React/RN trees under vitest (same pattern as src/test/render-with-providers.tsx) */
+import { createElement } from 'react';
+import { act } from 'react-test-renderer';
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+  type FetchToCompletionResult,
+  useFetchToCompletion,
+} from '@/lib/pr-review/diff/pr-review-file-list-state';
+import { renderWithProviders } from '@/test/render-with-providers';
+
+vi.mock('@/lib/trpc', () => ({
+  useTRPC: () => ({
+    githubPrReview: {
+      listFiles: {
+        infiniteQueryOptions: () => ({}),
+      },
+    },
+  }),
+}));
+
+vi.mock('@/lib/pr-review/viewed-files', () => ({
+  getViewedFiles: vi.fn(),
+  toggleViewedFile: vi.fn(),
+}));
+
+type QueryStub = Parameters<typeof useFetchToCompletion>[0];
+
+function Probe({
+  query,
+  holder,
+}: {
+  query: QueryStub;
+  holder: { current: FetchToCompletionResult | null };
+}) {
+  holder.current = useFetchToCompletion(query, 200);
+  return null;
+}
+
+async function mountProbe(query: QueryStub): Promise<{ current: FetchToCompletionResult | null }> {
+  const holder: { current: FetchToCompletionResult | null } = { current: null };
+  await renderWithProviders(createElement(Probe, { query, holder }));
+  return holder;
+}
+
+function current(holder: { current: FetchToCompletionResult | null }): FetchToCompletionResult {
+  const result = holder.current;
+  if (!result) {
+    throw new Error('probe did not render');
+  }
+  return result;
+}
+
+describe('useFetchToCompletion resolved error', () => {
+  it('stops after one request when fetchNextPage resolves with an error and hasNextPage stays true', async () => {
+    const pageError = new Error('later page failed');
+    const fetchNextPage = vi.fn(async () => {
+      await Promise.resolve();
+      return {
+        data: { pages: [{ files: [{ path: 'a.ts' }] }] },
+        hasNextPage: true,
+        error: pageError,
+      };
+    });
+    const query = {
+      isFetching: false,
+      hasNextPage: true,
+      fetchNextPage,
+      data: { pages: [{ files: [{ path: 'a.ts' }] }] },
+    } as unknown as QueryStub;
+
+    const holder = await mountProbe(query);
+    await act(async () => {
+      await current(holder).run();
+    });
+
+    expect(fetchNextPage).toHaveBeenCalledTimes(1);
+    expect(current(holder).error).toBe(pageError);
+    expect(current(holder).isRunning).toBe(false);
+  });
+});
diff --git a/apps/mobile/src/lib/pr-review/diff/use-pr-diff-context-loader.mounted.test.tsx b/apps/mobile/src/lib/pr-review/diff/use-pr-diff-context-loader.mounted.test.tsx
new file mode 100644
index 0000000000..388a2de054
--- /dev/null
+++ b/apps/mobile/src/lib/pr-review/diff/use-pr-diff-context-loader.mounted.test.tsx
@@ -0,0 +1,80 @@
+/* eslint-disable typescript-eslint/no-deprecated -- react-test-renderer is the DOM-free renderer used to mount React/RN trees under vitest (same pattern as src/test/render-with-providers.tsx) */
+import { createElement } from 'react';
+import { act } from 'react-test-renderer';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { type ExpandSeparatorItem } from '@/lib/pr-review/diff/pr-diff-list-items';
+import { usePrDiffContextLoader } from '@/lib/pr-review/diff/use-pr-diff-context-loader';
+import { renderWithProviders, waitFor } from '@/test/render-with-providers';
+
+// ── Hoisted mocks ──────────────────────────────────────────────────────────
+
+const queryFnMock = vi.hoisted(() => vi.fn());
+
+vi.mock('@/lib/trpc', () => ({
+  useTRPC: () => ({
+    githubPrReview: {
+      getFileLines: {
+        queryOptions: (input: unknown, opts: object) => ({
+          ...opts,
+          queryKey: ['githubPrReview', 'getFileLines', input],
+          queryFn: queryFnMock,
+        }),
+      },
+    },
+  }),
+}));
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+
+type LoaderResult = ReturnType<typeof usePrDiffContextLoader>;
+
+function Probe({ holder }: { holder: { current: LoaderResult | null } }) {
+  const result = usePrDiffContextLoader({ owner: 'octocat', repo: 'hello-world', headSha: 'sha' });
+  holder.current = result;
+  return null;
+}
+
+async function mountProbe(): Promise<{ current: LoaderResult | null }> {
+  const holder: { current: LoaderResult | null } = { current: null };
+  await renderWithProviders(createElement(Probe, { holder }));
+  return holder;
+}
+
+function current(holder: { current: LoaderResult | null }): LoaderResult {
+  const result = holder.current;
+  if (!result) {
+    throw new Error('probe did not render');
+  }
+  return result;
+}
+
+const ITEM: ExpandSeparatorItem = {
+  kind: 'expand-separator',
+  key: 'expand:0',
+  filePath: 'src/index.ts',
+  ref: { owner: 'octocat', repo: 'hello-world', number: 1, ref: 'sha' },
+  context: { gapIndex: 0, startLine: 10, endLine: 50 },
+  state: 'idle',
+};
+
+// ── Tests ──────────────────────────────────────────────────────────────────
+
+describe('usePrDiffContextLoader', () => {
+  beforeEach(() => {
+    queryFnMock.mockReset();
+    queryFnMock.mockResolvedValue({ lines: ['line-a'], totalLines: 1 });
+  });
+
+  it('re-expanding the same gap is a react-query cache hit (queryFn runs once)', async () => {
+    const holder = await mountProbe();
+
+    act(() => {
+      current(holder).handleLoadContext(ITEM, 20);
+      current(holder).handleLoadContext(ITEM, 20);
+    });
+
+    await waitFor(() => current(holder).expandedContext['src/index.ts']?.[0]?.status === 'partial');
+    expect(queryFnMock).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/apps/mobile/src/lib/pr-review/diff/use-pr-diff-context-loader.ts b/apps/mobile/src/lib/pr-review/diff/use-pr-diff-context-loader.ts
index beb86cce83..85d80dcfe3 100644
--- a/apps/mobile/src/lib/pr-review/diff/use-pr-diff-context-loader.ts
+++ b/apps/mobile/src/lib/pr-review/diff/use-pr-diff-context-loader.ts
@@ -2,6 +2,7 @@
 // expandedContext state and the progressive window fetch so the list
 // component stays under the max-lines limit.
 
+import { useQueryClient } from '@tanstack/react-query';
 import { useCallback, useRef, useState } from 'react';
 
 import {
@@ -10,7 +11,8 @@ import {
   type ListItem,
   setContextLines,
 } from '@/lib/pr-review/diff/pr-diff-list-items';
-import { trpcClient } from '@/lib/trpc';
+import { buildContextWindow } from '@/lib/pr-review/diff/context-window';
+import { useTRPC } from '@/lib/trpc';
 import { readTrpcErrorField } from '@/lib/trpc-error';
 
 type UsePrDiffContextLoaderResult = {
@@ -30,6 +32,8 @@ export function usePrDiffContextLoader(args: {
   headSha: string;
 }): UsePrDiffContextLoaderResult {
   const { owner, repo, headSha } = args;
+  const queryClient = useQueryClient();
+  const trpc = useTRPC();
   const [expandedContext, setExpandedContext] = useState<
     Record<string, Record<number, ExpandSeparatorState>>
   >({});
@@ -45,8 +49,12 @@ export function usePrDiffContextLoader(args: {
         existingState?.status === 'error'
           ? existingState.lines.length
           : 0;
-      const startLine = item.context.startLine + alreadyLoaded;
-      const endLine = Math.min(item.context.endLine, startLine + windowSize - 1);
+      const { startLine, endLine } = buildContextWindow({
+        startLine: item.context.startLine,
+        endLine: item.context.endLine,
+        alreadyLoaded,
+        windowSize,
+      });
 
       setExpandedContext(prev =>
         addContextLoadState({
@@ -58,14 +66,19 @@ export function usePrDiffContextLoader(args: {
       );
       void (async () => {
         try {
-          const result = await trpcClient.githubPrReview.getFileLines.query({
-            owner: item.ref.owner || owner,
-            repo: item.ref.repo || repo,
-            ref: item.ref.ref || headSha,
-            path: item.filePath,
-            startLine,
-            endLine,
-          });
+          const result = await queryClient.fetchQuery(
+            trpc.githubPrReview.getFileLines.queryOptions(
+              {
+                owner: item.ref.owner || owner,
+                repo: item.ref.repo || repo,
+                ref: item.ref.ref || headSha,
+                path: item.filePath,
+                startLine,
+                endLine,
+              },
+              { staleTime: 5 * 60_000, gcTime: 10 * 60_000 }
+            )
+          );
           if (result.lines.length === 0) {
             setExpandedContext(prev =>
               addContextLoadState({
@@ -100,7 +113,7 @@ export function usePrDiffContextLoader(args: {
         }
       })();
     },
-    [owner, repo, headSha]
+    [owner, repo, headSha, queryClient, trpc]
   );
 
   return { expandedContext, setExpandedContext, handleLoadContext };
diff --git a/apps/mobile/src/lib/pr-review/partition-pending-items.test.ts b/apps/mobile/src/lib/pr-review/partition-pending-items.test.ts
new file mode 100644
index 0000000000..715169c44d
--- /dev/null
+++ b/apps/mobile/src/lib/pr-review/partition-pending-items.test.ts
@@ -0,0 +1,66 @@
+import { describe, expect, it } from 'vitest';
+
+import { partitionPendingItems } from '@/lib/pr-review/partition-pending-items';
+import { type PendingReviewItem } from '@/lib/pr-review/pending-review-provider';
+
+function makeItem(overrides: Partial<PendingReviewItem> = {}): PendingReviewItem {
+  return {
+    id: 'id-1',
+    path: 'src/lib.ts',
+    side: 'RIGHT',
+    line: 7,
+    body: 'Looks good.',
+    commitSha: 'head-1',
+    ...overrides,
+  };
+}
+
+describe('partitionPendingItems', () => {
+  it('marks every item fresh when all commit SHAs match the head', () => {
+    const items = [
+      makeItem({ id: 'a', commitSha: 'head-1' }),
+      makeItem({ id: 'b', commitSha: 'head-1' }),
+    ];
+    const { fresh, stale } = partitionPendingItems(items, 'head-1');
+    expect(fresh.map(item => item.id)).toEqual(['a', 'b']);
+    expect(stale).toEqual([]);
+  });
+
+  it('marks every item stale when none match the head', () => {
+    const items = [
+      makeItem({ id: 'a', commitSha: 'head-0' }),
+      makeItem({ id: 'b', commitSha: 'head-0' }),
+    ];
+    const { fresh, stale } = partitionPendingItems(items, 'head-1');
+    expect(fresh).toEqual([]);
+    expect(stale.map(item => item.id)).toEqual(['a', 'b']);
+  });
+
+  it('splits a mixed queue by commit SHA, preserving order within each side', () => {
+    const items = [
+      makeItem({ id: 'a', commitSha: 'head-1' }),
+      makeItem({ id: 'b', commitSha: 'head-0' }),
+      makeItem({ id: 'c', commitSha: 'head-1' }),
+      makeItem({ id: 'd', commitSha: 'head-0' }),
+    ];
+    const { fresh, stale } = partitionPendingItems(items, 'head-1');
+    expect(fresh.map(item => item.id)).toEqual(['a', 'c']);
+    expect(stale.map(item => item.id)).toEqual(['b', 'd']);
+  });
+
+  it('treats an empty headSha as all fresh (overview not loaded)', () => {
+    const items = [
+      makeItem({ id: 'a', commitSha: 'head-0' }),
+      makeItem({ id: 'b', commitSha: 'head-1' }),
+    ];
+    const { fresh, stale } = partitionPendingItems(items, '');
+    expect(fresh.map(item => item.id)).toEqual(['a', 'b']);
+    expect(stale).toEqual([]);
+  });
+
+  it('returns two empty lists for an empty queue', () => {
+    const { fresh, stale } = partitionPendingItems([], 'head-1');
+    expect(fresh).toEqual([]);
+    expect(stale).toEqual([]);
+  });
+});
diff --git a/apps/mobile/src/lib/pr-review/partition-pending-items.ts b/apps/mobile/src/lib/pr-review/partition-pending-items.ts
new file mode 100644
index 0000000000..312f761b4d
--- /dev/null
+++ b/apps/mobile/src/lib/pr-review/partition-pending-items.ts
@@ -0,0 +1,32 @@
+import { type PendingReviewItem } from '@/lib/pr-review/pending-review-provider';
+
+/**
+ * Splits the queued pending-review comments by whether each was written
+ * against the PR's current head. `fresh` items submit; `stale` items stay
+ * queued so the user can edit or delete them. An empty `headSha` (the
+ * overview has not loaded yet) makes every item fresh — do not invent
+ * staleness before the head is known.
+ */
+export type PendingItemPartition = {
+  fresh: PendingReviewItem[];
+  stale: PendingReviewItem[];
+};
+
+export function partitionPendingItems(
+  items: readonly PendingReviewItem[],
+  headSha: string
+): PendingItemPartition {
+  if (headSha === '') {
+    return { fresh: [...items], stale: [] };
+  }
+  const fresh: PendingReviewItem[] = [];
+  const stale: PendingReviewItem[] = [];
+  for (const item of items) {
+    if (item.commitSha === headSha) {
+      fresh.push(item);
+    } else {
+      stale.push(item);
+    }
+  }
+  return { fresh, stale };
+}
diff --git a/apps/mobile/src/lib/pr-review/pending-review-provider.mounted.test.tsx b/apps/mobile/src/lib/pr-review/pending-review-provider.mounted.test.tsx
index 2f2bbf8c11..e3805bb92e 100644
--- a/apps/mobile/src/lib/pr-review/pending-review-provider.mounted.test.tsx
+++ b/apps/mobile/src/lib/pr-review/pending-review-provider.mounted.test.tsx
@@ -1,5 +1,6 @@
 /* eslint-disable typescript-eslint/no-deprecated -- react-test-renderer is the DOM-free renderer used to mount React/RN trees under vitest (node env, no jsdom); see src/lib/persist/cache-persistence-mount.test.ts */
 /* eslint-disable require-await, @typescript-eslint/require-await -- the fake drafts factories settle without await because they resolve immediately */
+/* eslint-disable max-lines -- the persistence, hydration-race, and submit-retention suites share one drafts-mock harness in this file */
 import TestRenderer, { act } from 'react-test-renderer';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
@@ -267,6 +268,80 @@ describe('PendingReviewProvider persistence', () => {
     );
   });
 
+  it('removeComments drops exactly the named ids and persists the remainder', async () => {
+    draftsMock.loadDraft.mockResolvedValue([ITEM_A, ITEM_B, ITEM_C]);
+    const { renders } = mountProvider({ userId: 'u1', draftEntityKey: 'pr-review:acme/kilo#42' });
+    await flushMicrotasks();
+    expect(latest(renders).items).toHaveLength(3);
+
+    draftsMock.saveDraft.mockClear();
+    act(() => {
+      latest(renders).removeComments(['a', 'c']);
+    });
+    expect(latest(renders).items.map(item => item.id)).toEqual(['b']);
+    expect(draftsMock.saveDraft).toHaveBeenCalledWith('u1', 'pr-review:acme/kilo#42', [ITEM_B]);
+    expect(draftsMock.clearDraft).not.toHaveBeenCalled();
+  });
+
+  it('removeComments with every id clears the stored draft through the empty branch', async () => {
+    draftsMock.loadDraft.mockResolvedValue([ITEM_A, ITEM_B]);
+    const { renders } = mountProvider({ userId: 'u1', draftEntityKey: 'pr-review:acme/kilo#42' });
+    await flushMicrotasks();
+
+    act(() => {
+      latest(renders).removeComments(['a', 'b']);
+    });
+    expect(latest(renders).items).toEqual([]);
+    expect(draftsMock.clearDraft).toHaveBeenCalledWith('u1', 'pr-review:acme/kilo#42');
+  });
+
+  it('empty removeComments before hydration is a no-op and retains the stored draft', async () => {
+    // APPROVE with an empty in-memory queue calls removeComments([]). That
+    // must not invalidate hydration or mark the provider hydrated, or the
+    // empty-state persistence effect would clear the stored draft and the
+    // delayed load would be discarded.
+    const gate = deferred<PendingReviewItem[] | null>();
+    draftsMock.loadDraft.mockReturnValue(gate.promise);
+    const { renders } = mountProvider({ userId: 'u1', draftEntityKey: 'pr-review:acme/kilo#42' });
+
+    act(() => {
+      latest(renders).removeComments([]);
+    });
+    expect(latest(renders).items).toEqual([]);
+
+    await act(async () => {
+      gate.resolve([ITEM_A, ITEM_B]);
+    });
+    await flushMicrotasks();
+    expect(latest(renders).items).toEqual([ITEM_A, ITEM_B]);
+    expect(draftsMock.clearDraft).not.toHaveBeenCalled();
+    expect(draftsMock.saveDraft).toHaveBeenCalledWith('u1', 'pr-review:acme/kilo#42', [
+      ITEM_A,
+      ITEM_B,
+    ]);
+  });
+
+  it('removeComments before hydration resolves wins over a late hydration result', async () => {
+    // A submit lands while hydration is still in flight: the posted ids are
+    // removed, and the late load must not merge them back into the queue.
+    const gate = deferred<PendingReviewItem[] | null>();
+    draftsMock.loadDraft.mockReturnValue(gate.promise);
+    const { renders } = mountProvider({ userId: 'u1', draftEntityKey: 'pr-review:acme/kilo#42' });
+
+    act(() => {
+      latest(renders).addComment(ITEM_A);
+      latest(renders).removeComments(['a']);
+    });
+    expect(latest(renders).items).toEqual([]);
+
+    await act(async () => {
+      gate.resolve([ITEM_A, ITEM_B]);
+    });
+    await flushMicrotasks();
+    expect(latest(renders).items).toEqual([]);
+    expect(draftsMock.saveDraft).not.toHaveBeenCalled();
+  });
+
   it('runs memory-only with no hydrate or persist when the userId is unknown', async () => {
     const { renders } = mountProvider({
       userId: undefined,
diff --git a/apps/mobile/src/lib/pr-review/pending-review-provider.tsx b/apps/mobile/src/lib/pr-review/pending-review-provider.tsx
index 74b2a4804d..e39c57966e 100644
--- a/apps/mobile/src/lib/pr-review/pending-review-provider.tsx
+++ b/apps/mobile/src/lib/pr-review/pending-review-provider.tsx
@@ -14,14 +14,14 @@ import { clearDraft, loadDraft, prReviewDraftKey, saveDraft } from '@/lib/persis
 import { useDraftFlushOnBackground } from '@/lib/persist/use-draft-flush';
 
 // One queued inline comment in the pending review. The composer fills
-// this in when the user taps "Add to review"; the submit sheet drains
-// the whole list into one `submitReview` batch call.
+// this in when the user taps "Add to review"; the submit sheet submits
+// only the fresh items in one `submitReview` batch call.
 //
 // `commitSha` records the PR head SHA at the time the comment was
-// queued so the submit sheet can flag "may be outdated" if the head
-// moves between queue and submit. Submission itself always uses the
-// LATEST head SHA (per the S3 contract) — a per-item 422 surfaces
-// inline so the user can decide whether to retry or drop the comment.
+// queued so the submit sheet can flag it "outdated" if the head moves
+// between queue and submit. Stale items are never sent: the submit
+// sheet partitions the queue and submits only the fresh items, leaving
+// stale items queued for the user to edit or delete.
 const PendingReviewItemSchema = z.object({
   id: z.string(),
   path: z.string(),
@@ -81,6 +81,7 @@ type PendingReviewContextValue = {
   addComment: (item: PendingReviewItem) => void;
   updateComment: (id: string, body: string) => void;
   removeComment: (id: string) => void;
+  removeComments: (ids: readonly string[]) => void;
   clear: () => void;
 };
 
@@ -125,9 +126,10 @@ export function PendingReviewProvider({
   // Guards hydration against a result that resolves after unmount, after a
   // key change, or after an explicit clear: every effect run captures the
   // current generation and every cleanup (unmount or a superseding run) bumps
-  // it, so a stale load never applies. `clear()` bumps the generation too, so
-  // a late hydration can never merge old stored comments back into the queue
-  // after a successful submit or discard (refs dodge the flow narrowing that
+  // it, so a stale load never applies. `removeComments()` (submit) and
+  // `clear()` (discard) bump the generation too, so a late hydration can never
+  // merge old stored comments back into the queue after a successful submit or
+  // discard (refs dodge the flow narrowing that
   // makes a local `let active` read as always-truthy to type-aware lint).
   const hydrationGenerationRef = useRef(0);
   useEffect(() => {
@@ -164,7 +166,7 @@ export function PendingReviewProvider({
   // First-write guard: the persistence effect writes only once `hydrated`
   // is true. An empty queue clears the persisted entry (an empty list has
   // nothing worth storing) — this is what makes `removeComment`-to-empty
-  // and the submit-success `clear()` durable.
+  // and the submit-success `removeComments`-to-empty durable.
   useEffect(() => {
     if (!hydrated || !userId || !draftEntityKey) {
       return;
@@ -192,26 +194,45 @@ export function PendingReviewProvider({
     setItems(previous => previous.filter(item => item.id !== id));
   }, []);
 
+  const removeComments = useCallback((ids: readonly string[]) => {
+    // An empty id list is a true no-op. APPROVE with no fresh comments
+    // calls this before hydration; bumping the generation or marking
+    // hydrated would discard the in-flight load and let the empty-state
+    // persistence effect clear the stored draft.
+    if (ids.length === 0) {
+      return;
+    }
+    const idSet = new Set(ids);
+    setItems(previous => previous.filter(item => !idSet.has(item.id)));
+    // Same guard `clear()` carries: invalidate any in-flight hydration so a
+    // late load cannot merge the just-posted comments back into the queue
+    // after a successful submit. Mark hydration settled too, so the remaining
+    // items persist even when the invalidated load never resolves. The
+    // persistence effect writes the remainder (an empty remainder clears the
+    // stored entry through its empty-state branch), so no direct clearDraft.
+    hydrationGenerationRef.current += 1;
+    setHydrated(true);
+  }, []);
+
   const clear = useCallback(() => {
     setItems([]);
     // A successful clear invalidates any in-flight hydration: a late load
     // must not merge the old stored comments back into the queue after the
-    // user submitted the review or discarded the queue. Mark hydration
-    // settled too, so a later addComment persists even when the invalidated
-    // load never resolves.
+    // user discarded the queue. Mark hydration settled too, so a later
+    // addComment persists even when the invalidated load never resolves.
     hydrationGenerationRef.current += 1;
     setHydrated(true);
-    // Clear the persisted entry directly (submit success / explicit discard):
-    // the persistence effect would also clear on the empty state, but this
-    // runs synchronously so a submit-then-navigate can never leave the entry.
+    // Clear the persisted entry directly (explicit discard): the persistence
+    // effect would also clear on the empty state, but this runs synchronously
+    // so a discard-then-navigate can never leave the entry.
     if (userId && draftEntityKey) {
       void clearDraft(userId, draftEntityKey);
     }
   }, [userId, draftEntityKey]);
 
   const value = useMemo<PendingReviewContextValue>(
-    () => ({ items, addComment, updateComment, removeComment, clear }),
-    [items, addComment, updateComment, removeComment, clear]
+    () => ({ items, addComment, updateComment, removeComment, removeComments, clear }),
+    [items, addComment, updateComment, removeComment, removeComments, clear]
   );
 
   return <PendingReviewContext value={value}>{children}</PendingReviewContext>;
diff --git a/apps/mobile/src/lib/pr-review/recent-prs.test.ts b/apps/mobile/src/lib/pr-review/recent-prs.test.ts
index bd02e1f256..62aeefc5c9 100644
--- a/apps/mobile/src/lib/pr-review/recent-prs.test.ts
+++ b/apps/mobile/src/lib/pr-review/recent-prs.test.ts
@@ -1,6 +1,13 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { clearRecentPrs, getRecentPrs, type RecentPr, upsertRecentPr } from './recent-prs';
+import {
+  clearRecentPrs,
+  getRecentPrs,
+  markRecentPrFailed,
+  type RecentPr,
+  removeRecentPr,
+  upsertRecentPr,
+} from './recent-prs';
 
 const store = new Map<string, string>();
 
@@ -120,4 +127,50 @@ describe('recent-prs', () => {
     await clearRecentPrs();
     expect(store.has('pr-review-recents')).toBe(false);
   });
+
+  it('parseRecents reads a legacy entry without lastResult as ok', async () => {
+    store.set(
+      'pr-review-recents',
+      JSON.stringify([
+        {
+          owner: 'octocat',
+          repo: 'hello',
+          number: 1,
+          title: 'Legacy',
+          lastOpenedAt: 1_700_000_000_000,
+        },
+      ])
+    );
+    await expect(getRecentPrs()).resolves.toMatchObject([{ number: 1, lastResult: 'ok' }]);
+  });
+
+  it('markRecentPrFailed is a no-op for an unknown key', async () => {
+    await upsertRecentPr(makeRecent({ repo: 'hello', number: 1, title: 'One' }));
+    await markRecentPrFailed({ owner: 'octocat', repo: 'hello', number: 999 });
+
+    await expect(getRecentPrs()).resolves.toMatchObject([{ number: 1, lastResult: 'ok' }]);
+  });
+
+  it('markRecentPrFailed flips an existing entry to failed', async () => {
+    await upsertRecentPr(makeRecent({ repo: 'hello', number: 1, title: 'One' }));
+    await markRecentPrFailed({ owner: 'octocat', repo: 'hello', number: 1 });
+
+    await expect(getRecentPrs()).resolves.toMatchObject([{ number: 1, lastResult: 'failed' }]);
+  });
+
+  it('removeRecentPr deletes one entry and keeps the rest', async () => {
+    await upsertRecentPr(makeRecent({ owner: 'octocat', repo: 'hello', number: 1, title: 'One' }));
+    await upsertRecentPr(makeRecent({ owner: 'octocat', repo: 'hello', number: 2, title: 'Two' }));
+    await removeRecentPr({ owner: 'octocat', repo: 'hello', number: 1 });
+
+    await expect(getRecentPrs()).resolves.toMatchObject([{ number: 2, title: 'Two' }]);
+  });
+
+  it('a successful backfill writes lastResult ok over a previously failed entry', async () => {
+    await upsertRecentPr(makeRecent({ repo: 'hello', number: 1, title: 'One' }));
+    await markRecentPrFailed({ owner: 'octocat', repo: 'hello', number: 1 });
+    await upsertRecentPr(makeRecent({ repo: 'hello', number: 1, title: 'One', lastResult: 'ok' }));
+
+    await expect(getRecentPrs()).resolves.toMatchObject([{ number: 1, lastResult: 'ok' }]);
+  });
 });
diff --git a/apps/mobile/src/lib/pr-review/recent-prs.ts b/apps/mobile/src/lib/pr-review/recent-prs.ts
index e79bfdd36a..f9fc29955b 100644
--- a/apps/mobile/src/lib/pr-review/recent-prs.ts
+++ b/apps/mobile/src/lib/pr-review/recent-prs.ts
@@ -10,6 +10,12 @@ export type RecentPr = {
   number: number;
   title: string;
   lastOpenedAt: number;
+  /**
+   * Outcome of the most recent load attempt. `'failed'` marks an entry
+   * whose last open did not produce an authorized payload; `'ok'` (or a
+   * missing field on a legacy stored entry) marks a successful load.
+   */
+  lastResult?: 'ok' | 'failed';
 };
 
 const recentPrSchema = z.object({
@@ -18,11 +24,18 @@ const recentPrSchema = z.object({
   number: z.number(),
   title: z.string(),
   lastOpenedAt: z.number(),
+  lastResult: z.enum(['ok', 'failed']).optional(),
 });
 
 const RECENT_PR_LIMIT = 10;
 
-function recentPrKey(item: RecentPr): string {
+type RecentPrRef = {
+  owner: string;
+  repo: string;
+  number: number;
+};
+
+function recentPrKey(item: RecentPrRef): string {
   return `${item.owner.toLowerCase()}/${item.repo.toLowerCase()}#${item.number}`;
 }
 
@@ -37,7 +50,14 @@ function parseRecents(raw: string | null): RecentPr[] {
     }
     return parsed.flatMap((entry): RecentPr[] => {
       const result = recentPrSchema.safeParse(entry);
-      return result.success ? [result.data] : [];
+      if (!result.success) {
+        return [];
+      }
+      // Legacy entries predate `lastResult`; read a missing field as 'ok'
+      // so an installed app's existing recents survive the upgrade.
+      return [
+        { ...result.data, lastResult: result.data.lastResult === 'failed' ? 'failed' : 'ok' },
+      ];
     });
   } catch {
     return [];
@@ -57,10 +77,11 @@ export async function getRecentPrs(): Promise<RecentPr[]> {
 
 /**
  * Inserts/updates a recent PR entry, moves it to the front, and trims the
- * list to the most recent RECENT_PR_LIMIT. The title is taken from the
- * caller (which may be the user-typed URL before the PR loads, or a
- * later load-time fetch that backfills the title) — the function never
- * reads or overwrites the title from disk on its own.
+ * list to the most recent RECENT_PR_LIMIT. This is the only writer that
+ * creates an entry: the caller is the authorized backfill that writes the
+ * real title on a successful load. The whole entry is replaced (no field
+ * merge), so a caller writing `lastResult: 'ok'` clears a previously
+ * failed entry.
  */
 export async function upsertRecentPr(entry: RecentPr): Promise<void> {
   await writeAccountMetadata(PR_REVIEW_RECENTS_KEY, async () => {
@@ -73,6 +94,46 @@ export async function upsertRecentPr(entry: RecentPr): Promise<void> {
   });
 }
 
+/**
+ * Removes one entry by identity. A missing key is a no-op.
+ */
+export async function removeRecentPr(ref: RecentPrRef): Promise<void> {
+  await writeAccountMetadata(PR_REVIEW_RECENTS_KEY, async () => {
+    const existingRaw = await SecureStore.getItemAsync(PR_REVIEW_RECENTS_KEY);
+    const existing = parseRecents(existingRaw);
+    const targetKey = recentPrKey(ref);
+    const next = existing.filter(item => recentPrKey(item) !== targetKey);
+    await SecureStore.setItemAsync(PR_REVIEW_RECENTS_KEY, toJsonString(next));
+  });
+}
+
+/**
+ * Marks an EXISTING entry as `'failed'`. It never creates an entry — a
+ * missing key is a no-op. This is what keeps a never-authorized PR out
+ * of recents: only a successful backfill (which writes `'ok'`) can add
+ * or clear an entry.
+ */
+export async function markRecentPrFailed(ref: RecentPrRef): Promise<void> {
+  await writeAccountMetadata(PR_REVIEW_RECENTS_KEY, async () => {
+    const existingRaw = await SecureStore.getItemAsync(PR_REVIEW_RECENTS_KEY);
+    const existing = parseRecents(existingRaw);
+    const targetKey = recentPrKey(ref);
+    // `existing` is freshly parsed (safe to mutate in place); set the marker
+    // only on the matching entry and never create one.
+    let found = false;
+    for (const item of existing) {
+      if (recentPrKey(item) === targetKey) {
+        item.lastResult = 'failed';
+        found = true;
+      }
+    }
+    if (!found) {
+      return;
+    }
+    await SecureStore.setItemAsync(PR_REVIEW_RECENTS_KEY, toJsonString(existing));
+  });
+}
+
 export async function clearRecentPrs(): Promise<void> {
   await deleteAccountMetadata(PR_REVIEW_RECENTS_KEY);
 }
diff --git a/apps/mobile/src/lib/pr-review/use-pr-inbox.test.ts b/apps/mobile/src/lib/pr-review/use-pr-inbox.test.ts
new file mode 100644
index 0000000000..656cf6c825
--- /dev/null
+++ b/apps/mobile/src/lib/pr-review/use-pr-inbox.test.ts
@@ -0,0 +1,61 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { buildPrInboxQueryOptions } from './use-pr-inbox';
+
+// `use-pr-inbox` imports `useTRPC` from `@/lib/trpc`, which pulls the whole
+// expo auth/token module graph. Mock it so the module loads under Node.
+vi.mock('@/lib/trpc', () => ({
+  useTRPC: () => ({}),
+}));
+
+type Trpc = Parameters<typeof buildPrInboxQueryOptions>[0];
+
+type InboxPage = { items: unknown[]; nextCursor: string | null };
+
+type LooseOptions = {
+  enabled?: boolean;
+  staleTime?: number;
+  maxPages?: number;
+  getNextPageParam?: (lastPage: InboxPage) => string | undefined;
+};
+
+function makeTrpc() {
+  const infiniteQueryOptions = vi.fn((input: unknown, opts: Record<string, unknown>) => ({
+    input,
+    ...opts,
+  }));
+  return {
+    githubPrReview: {
+      listInbox: { infiniteQueryOptions },
+    },
+  } as unknown as Trpc;
+}
+
+function build(enabled: boolean): LooseOptions {
+  return buildPrInboxQueryOptions(makeTrpc(), enabled) as unknown as LooseOptions;
+}
+
+describe('buildPrInboxQueryOptions', () => {
+  it('forwards enabled and sets a 30s staleTime', () => {
+    const opts = build(true);
+    expect(opts.enabled).toBe(true);
+    expect(opts.staleTime).toBe(30_000);
+  });
+
+  it('forwards a disabled flag', () => {
+    const opts = build(false);
+    expect(opts.enabled).toBe(false);
+  });
+
+  it('returns the cursor for a page with a nextCursor', () => {
+    expect(build(true).getNextPageParam?.({ items: [], nextCursor: 'abc' })).toBe('abc');
+  });
+
+  it('returns undefined for a page with nextCursor null', () => {
+    expect(build(true).getNextPageParam?.({ items: [], nextCursor: null })).toBeUndefined();
+  });
+
+  it('caps the inbox at 20 pages', () => {
+    expect(build(true).maxPages).toBe(20);
+  });
+});
diff --git a/apps/mobile/src/lib/pr-review/use-pr-inbox.ts b/apps/mobile/src/lib/pr-review/use-pr-inbox.ts
new file mode 100644
index 0000000000..d49e47ed11
--- /dev/null
+++ b/apps/mobile/src/lib/pr-review/use-pr-inbox.ts
@@ -0,0 +1,59 @@
+// Authorized, paginated PR inbox query hook.
+//
+// `usePrInbox(enabled)` wraps the tRPC `listInbox` infinite query and
+// returns the flat item list plus the same first-page / later-page
+// error split the Files and Discussion tabs use. The query string is
+// server-fixed (`review-requested:@me`), so the inbox can only ever
+// return PRs the caller's own GitHub token can already see.
+//
+// `buildPrInboxQueryOptions` is a pure builder (the pattern
+// `buildStoredSessionsQueryOptions` uses) so the pagination contract is
+// executable-tested without mounting the hook.
+
+import { useInfiniteQuery } from '@tanstack/react-query';
+import { useMemo } from 'react';
+
+import { classifyPrReviewQueryState } from '@/lib/pr-review/classify-pr-review-query-state';
+import { useTRPC } from '@/lib/trpc';
+
+// Cap at 20 pages so a pathological inbox cannot walk the GraphQL
+// `search` cursor forever (GraphQL search is rate limited more tightly
+// than REST; the 30s staleTime plus this cap keep the inbox inside it).
+const INBOX_MAX_PAGES = 20;
+
+export function buildPrInboxQueryOptions(trpc: ReturnType<typeof useTRPC>, enabled: boolean) {
+  return trpc.githubPrReview.listInbox.infiniteQueryOptions(
+    {},
+    {
+      enabled,
+      staleTime: 30_000,
+      getNextPageParam: lastPage => lastPage.nextCursor ?? undefined,
+      maxPages: INBOX_MAX_PAGES,
+    }
+  );
+}
+
+export function usePrInbox(enabled: boolean) {
+  const trpc = useTRPC();
+  const query = useInfiniteQuery(buildPrInboxQueryOptions(trpc, enabled));
+
+  const errorState = query.error ? classifyPrReviewQueryState(query.error) : null;
+  // A first-page error is one where NO page has loaded yet. A failure while
+  // fetching a LATER page (already-loaded items present) is a later-page error
+  // and must not blank the list — the caller keeps the loaded rows and offers
+  // an inline retry instead.
+  const hasLoadedPages = (query.data?.pages.length ?? 0) > 0;
+  const firstPageErrorState = hasLoadedPages ? null : errorState;
+  const laterPageError = Boolean(query.error) && hasLoadedPages;
+
+  const pages = query.data?.pages;
+  const items = useMemo(() => (pages ?? []).flatMap(page => page.items), [pages]);
+
+  return {
+    query,
+    items,
+    errorState,
+    firstPageErrorState,
+    laterPageError,
+  };
+}
diff --git a/apps/mobile/src/lib/pr-review/viewed-files.test.ts b/apps/mobile/src/lib/pr-review/viewed-files.test.ts
index 0c526d38ef..cdc7d6d3bf 100644
--- a/apps/mobile/src/lib/pr-review/viewed-files.test.ts
+++ b/apps/mobile/src/lib/pr-review/viewed-files.test.ts
@@ -1,6 +1,12 @@
+import * as SecureStore from 'expo-secure-store';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { clearViewedFiles, getViewedFiles, toggleViewedFile } from './viewed-files';
+import {
+  clearViewedFiles,
+  getViewedFiles,
+  resetViewedFilesCacheForTests,
+  toggleViewedFile,
+} from './viewed-files';
 
 const store = new Map<string, string>();
 
@@ -25,6 +31,7 @@ vi.mock('@/lib/storage-keys', () => ({
 
 beforeEach(() => {
   store.clear();
+  resetViewedFilesCacheForTests();
 });
 
 const OWNER = 'octocat';
@@ -140,4 +147,104 @@ describe('viewed-files', () => {
     await clearViewedFiles();
     expect(store.has('pr-review-viewed')).toBe(false);
   });
+
+  it('caches the map so a second read after a toggle does not re-read the store', async () => {
+    setStored({});
+    await toggleViewedFile({ ...REF, headSha: SHA1, path: 'src/index.ts' });
+
+    const getItemMock = vi.mocked(SecureStore.getItemAsync);
+    const callsBefore = getItemMock.mock.calls.length;
+
+    await expect(getViewedFiles(REF, SHA1)).resolves.toEqual(['src/index.ts']);
+    expect(getItemMock.mock.calls.length).toBe(callsBefore);
+  });
+
+  it('clearViewedFiles makes subsequent reads return empty without the prior paths', async () => {
+    setStored({ 'octocat/hello-world#42': { headSha: SHA1, viewedPaths: ['a.ts'] } });
+    await expect(getViewedFiles(REF, SHA1)).resolves.toEqual(['a.ts']);
+
+    await clearViewedFiles();
+
+    const getItemMock = vi.mocked(SecureStore.getItemAsync);
+    const callsBefore = getItemMock.mock.calls.length;
+    await expect(getViewedFiles(REF, SHA1)).resolves.toEqual([]);
+    expect(getItemMock.mock.calls.length).toBe(callsBefore);
+  });
+
+  it('a concurrent read during clear never returns the prior paths', async () => {
+    setStored({ 'octocat/hello-world#42': { headSha: SHA1, viewedPaths: ['a.ts'] } });
+    await expect(getViewedFiles(REF, SHA1)).resolves.toEqual(['a.ts']);
+
+    let releaseDelete: () => void = undefined as unknown as () => void;
+    const deleteGate = new Promise<void>(resolve => {
+      releaseDelete = resolve;
+    });
+    vi.mocked(SecureStore.deleteItemAsync).mockImplementationOnce(async () => {
+      await deleteGate;
+      store.delete('pr-review-viewed');
+    });
+
+    const clearPromise = clearViewedFiles();
+    await expect(getViewedFiles(REF, SHA1)).resolves.toEqual([]);
+
+    releaseDelete();
+    await clearPromise;
+    await expect(getViewedFiles(REF, SHA1)).resolves.toEqual([]);
+  });
+
+  it('a late first read does not overwrite a write', async () => {
+    // Gate the first SecureStore read so it finishes after the write.
+    let releaseRead: (value: string | null) => void = undefined as unknown as (
+      value: string | null
+    ) => void;
+    const readGate = new Promise<string | null>(resolve => {
+      releaseRead = resolve;
+    });
+    vi.mocked(SecureStore.getItemAsync).mockReturnValueOnce(readGate);
+
+    // Start a first read while the cache is empty.
+    const firstRead = getViewedFiles(REF, SHA1);
+
+    // Write before the first read resolves.
+    await toggleViewedFile({ ...REF, headSha: SHA1, path: 'src/index.ts' });
+
+    // Release the stale first read (the store was empty when it started).
+    releaseRead(null);
+    await expect(firstRead).resolves.toEqual(['src/index.ts']);
+
+    // The write must not be overwritten by the late read.
+    await expect(getViewedFiles(REF, SHA1)).resolves.toEqual(['src/index.ts']);
+  });
+
+  it('a late first read does not fill the cache after a clear', async () => {
+    setStored({ 'octocat/hello-world#42': { headSha: SHA1, viewedPaths: ['a.ts'] } });
+
+    // Gate the first SecureStore read so it finishes after the clear.
+    let releaseRead: (value: string | null) => void = undefined as unknown as (
+      value: string | null
+    ) => void;
+    const readGate = new Promise<string | null>(resolve => {
+      releaseRead = resolve;
+    });
+    vi.mocked(SecureStore.getItemAsync).mockReturnValueOnce(readGate);
+
+    // Start a first read while the cache is empty but the store has content.
+    const firstRead = getViewedFiles(REF, SHA1);
+
+    // Sign-out clears the store and the cache.
+    await clearViewedFiles();
+
+    // Release the stale read with the pre-clear content.
+    releaseRead(
+      JSON.stringify({ 'octocat/hello-world#42': { headSha: SHA1, viewedPaths: ['a.ts'] } })
+    );
+    await expect(firstRead).resolves.toEqual([]);
+
+    // The fence published an empty map; the next read must not return
+    // the prior paths and must not re-read the store.
+    const getItemMock = vi.mocked(SecureStore.getItemAsync);
+    const callsBefore = getItemMock.mock.calls.length;
+    await expect(getViewedFiles(REF, SHA1)).resolves.toEqual([]);
+    expect(getItemMock.mock.calls.length).toBe(callsBefore);
+  });
 });
diff --git a/apps/mobile/src/lib/pr-review/viewed-files.ts b/apps/mobile/src/lib/pr-review/viewed-files.ts
index 0008c79ad9..01a1143455 100644
--- a/apps/mobile/src/lib/pr-review/viewed-files.ts
+++ b/apps/mobile/src/lib/pr-review/viewed-files.ts
@@ -19,6 +19,18 @@ const rawViewedFileMapSchema = z.record(z.string(), z.unknown());
 
 const VIEWED_FILES_PR_LIMIT = 20;
 
+// Process-lifetime cache of the parsed map. `readMap` returns it when set so a
+// second read after a toggle (or any other read) does not re-read and re-parse
+// SecureStore. `clearViewedFiles` resets it so sign-out and account change drop
+// the private content (auth-context.tsx calls it).
+let cachedMap: ViewedFileMap | null = null;
+
+// Monotonic write/clear generation. `readMap` captures it before the
+// SecureStore read and only publishes the parsed map when it is unchanged, so
+// a first read that started while the cache was empty cannot overwrite a write
+// or refill the cache after a clear.
+let generation = 0;
+
 type ViewedFilePrRef = {
   owner: string;
   repo: string;
@@ -73,8 +85,21 @@ function computeNextViewedPaths(
 }
 
 async function readMap(): Promise<ViewedFileMap> {
+  const cached = cachedMap;
+  if (cached !== null) {
+    return cached;
+  }
+  const gen = generation;
   const raw = await SecureStore.getItemAsync(PR_REVIEW_VIEWED_KEY);
-  return parseMap(raw);
+  if (gen !== generation) {
+    // A write or clear happened while this read was in flight. A write
+    // publishes the fresh map to `cachedMap`; a clear nulls it. Return the
+    // authoritative current state, never the stale parse.
+    return cachedMap ?? {};
+  }
+  const parsed = parseMap(raw);
+  cachedMap = parsed;
+  return parsed;
 }
 
 export async function getViewedFiles(ref: ViewedFilePrRef, headSha: string): Promise<string[]> {
@@ -125,9 +150,24 @@ export async function toggleViewedFile(input: ToggleViewedFileInput): Promise<vo
       trimmed[trimmedKey] = value;
     }
     await SecureStore.setItemAsync(PR_REVIEW_VIEWED_KEY, toJsonString(trimmed));
+    cachedMap = trimmed;
+    generation += 1;
   });
 }
 
 export async function clearViewedFiles(): Promise<void> {
+  // Fence first: a concurrent getViewedFiles must not return the prior
+  // account's paths (or publish a SecureStore read of the not-yet-deleted
+  // value) while deletion is in flight.
+  cachedMap = {};
+  generation += 1;
   await deleteAccountMetadata(PR_REVIEW_VIEWED_KEY);
 }
+
+/**
+ * For tests: drop the process-lifetime cache so a test that swaps the fake
+ * SecureStore gets a fresh read. Mirrors `clearHighlightCacheForTests`.
+ */
+export function resetViewedFilesCacheForTests(): void {
+  cachedMap = null;
+}
diff --git a/apps/web/src/lib/github-pr-review/dtos.ts b/apps/web/src/lib/github-pr-review/dtos.ts
index f294dc635a..0f82de3d14 100644
--- a/apps/web/src/lib/github-pr-review/dtos.ts
+++ b/apps/web/src/lib/github-pr-review/dtos.ts
@@ -160,6 +160,29 @@ export type GitHubPrReviewReviewThreadsResult = z.infer<
   typeof GitHubPrReviewReviewThreadsResultSchema
 >;
 
+export const GitHubPrReviewInboxItemSchema = z
+  .object({
+    owner: z.string().min(1),
+    repo: z.string().min(1),
+    number: z.number().int().positive(),
+    title: z.string(),
+    author: GitHubPrReviewAuthorSchema.nullable(),
+    isDraft: z.boolean(),
+    updatedAt: z.string(),
+  })
+  .strict();
+export type GitHubPrReviewInboxItem = z.infer<typeof GitHubPrReviewInboxItemSchema>;
+
+export const GitHubPrReviewInboxResultSchema = z
+  .object({
+    items: z.array(GitHubPrReviewInboxItemSchema),
+    nextCursor: z.string().nullable(),
+  })
+  .strict();
+export type GitHubPrReviewInboxResult = z.infer<typeof GitHubPrReviewInboxResultSchema>;
+
+export const INBOX_PAGE_SIZE = 25;
+
 export const FILES_PAGE_SIZE = 50;
 export const FILES_MAX_PAGES = 60;
 export const FILE_LINES_MAX = 500;
diff --git a/apps/web/src/lib/github-pr-review/mappers.ts b/apps/web/src/lib/github-pr-review/mappers.ts
index 8e2beb8a8c..c833d0f06b 100644
--- a/apps/web/src/lib/github-pr-review/mappers.ts
+++ b/apps/web/src/lib/github-pr-review/mappers.ts
@@ -8,10 +8,13 @@ import {
   type GitHubPrReviewChecksResult,
   type GitHubPrReviewFile,
   type GitHubPrReviewFilesResult,
+  type GitHubPrReviewInboxItem,
+  type GitHubPrReviewInboxResult,
   type GitHubPrReviewReviewComment,
   type GitHubPrReviewReviewThread,
   type GitHubPrReviewReviewThreadsResult,
   GitHubPrReviewFilesResultSchema,
+  GitHubPrReviewInboxResultSchema,
   GitHubPrReviewReviewThreadsResultSchema,
 } from './dtos';
 import {
@@ -347,4 +350,48 @@ export function buildReviewThreadsResult(args: {
   });
 }
 
+// A GraphQL `search(type: ISSUE)` node. GitHub can return non-PullRequest
+// nodes as `{}` (the inline fragment matches nothing), so every field is
+// optional and `buildInboxResult` drops a node missing its identity.
+export type GraphQlInboxNode = {
+  number?: number | null;
+  title?: string | null;
+  isDraft?: boolean | null;
+  updatedAt?: string | null;
+  author?: { login: string; avatarUrl: string | null } | null;
+  repository?: {
+    name?: string | null;
+    owner?: { login?: string | null } | null;
+  } | null;
+};
+
+/** Map an inbox `search` connection into the wire DTO, dropping non-PR nodes. */
+export function buildInboxResult(args: {
+  nodes: (GraphQlInboxNode | null)[];
+  pageInfo: { hasNextPage: boolean; endCursor: string | null } | null;
+}): GitHubPrReviewInboxResult {
+  const { nodes, pageInfo } = args;
+  const items: GitHubPrReviewInboxItem[] = [];
+  for (const node of nodes) {
+    if (!node) continue;
+    const owner = node.repository?.owner?.login;
+    const repo = node.repository?.name;
+    const number = node.number;
+    if (!owner || !repo || typeof number !== 'number') continue;
+    items.push({
+      owner,
+      repo,
+      number,
+      title: node.title ?? '',
+      author: node.author
+        ? { login: node.author.login, avatarUrl: node.author.avatarUrl ?? null }
+        : null,
+      isDraft: Boolean(node.isDraft),
+      updatedAt: node.updatedAt ?? '',
+    });
+  }
+  const nextCursor = pageInfo?.hasNextPage ? pageInfo.endCursor : null;
+  return GitHubPrReviewInboxResultSchema.parse({ items, nextCursor });
+}
+
 export { GitHubRestUserSchema };
diff --git a/apps/web/src/routers/github-pr-review-graphql-schema.test.ts b/apps/web/src/routers/github-pr-review-graphql-schema.test.ts
index 2337282bbe..ba211cc0c9 100644
--- a/apps/web/src/routers/github-pr-review-graphql-schema.test.ts
+++ b/apps/web/src/routers/github-pr-review-graphql-schema.test.ts
@@ -31,8 +31,8 @@ const introspection = JSON.parse(readFileSync(introspectionPath, 'utf8'));
 const githubSchema = buildClientSchema(introspection);
 
 describe('github-pr-review-router GraphQL documents', () => {
-  test('exports exactly 10 documents (sanity guard for the export record)', () => {
-    expect(Object.keys(PR_REVIEW_GRAPHQL_DOCUMENTS)).toHaveLength(10);
+  test('exports exactly 11 documents (sanity guard for the export record)', () => {
+    expect(Object.keys(PR_REVIEW_GRAPHQL_DOCUMENTS)).toHaveLength(11);
   });
 
   test.each(Object.entries(PR_REVIEW_GRAPHQL_DOCUMENTS))(
diff --git a/apps/web/src/routers/github-pr-review-router.test.ts b/apps/web/src/routers/github-pr-review-router.test.ts
index 0b71cbaafe..be55686b44 100644
--- a/apps/web/src/routers/github-pr-review-router.test.ts
+++ b/apps/web/src/routers/github-pr-review-router.test.ts
@@ -4,7 +4,7 @@
 import { TRPCError } from '@trpc/server';
 import { createCallerFactory } from '@/lib/trpc/init';
 import type { User } from '@kilocode/db/schema';
-import { prLedgerResourceKey } from './github-pr-review-router';
+import { INBOX_SEARCH_QUERY, prLedgerResourceKey } from './github-pr-review-router';
 
 const getGitHubUserAccessToken = jest.fn();
 
@@ -66,14 +66,43 @@ type OctokitMock = {
     get: jest.Mock;
   };
   git: { deleteRef: jest.Mock };
+  repos: {
+    get: jest.Mock;
+    listCommitStatusesForRef: jest.Mock;
+  };
+  checks: {
+    listForRef: jest.Mock;
+  };
+  paginate: jest.Mock;
   request: jest.Mock;
 };
 
+const checkRunsFixture = [
+  {
+    name: 'ci',
+    status: 'completed',
+    conclusion: 'success',
+    details_url: null,
+    html_url: null,
+    app: { name: 'CI' },
+  },
+];
+
+const commitStatusesFixture = [
+  {
+    context: 'continuous-integration',
+    state: 'success',
+    target_url: null,
+    updated_at: '2026-01-01T00:00:00Z',
+  },
+];
+
 const tokenOctokits = new Map<string, OctokitMock>();
 
 function buildOctokit(token: string): OctokitMock {
   const existing = tokenOctokits.get(token);
   if (existing) return existing;
+  const checks = { listForRef: jest.fn() };
   const octokit: OctokitMock = {
     __token: token,
     pulls: {
@@ -88,6 +117,16 @@ function buildOctokit(token: string): OctokitMock {
       get: jest.fn(),
     },
     git: { deleteRef: jest.fn() },
+    repos: {
+      get: jest.fn(),
+      listCommitStatusesForRef: jest.fn(),
+    },
+    checks,
+    // listChecks calls paginate(checks.listForRef, …) then
+    // paginate(repos.listCommitStatusesForRef, …); dispatch on the method.
+    paginate: jest.fn(async (method: unknown) =>
+      method === checks.listForRef ? checkRunsFixture : commitStatusesFixture
+    ),
     request: jest.fn(),
   };
   tokenOctokits.set(token, octokit);
@@ -982,6 +1021,344 @@ describe('githubPrReviewRouter.listReviewThreads conversation comments', () => {
   });
 });
 
+describe('githubPrReviewRouter.listInbox', () => {
+  const inboxNode = (overrides: Record<string, unknown> = {}) => ({
+    number: 1,
+    title: 'Fix the thing',
+    isDraft: false,
+    updatedAt: '2026-01-01T00:00:00Z',
+    author: { login: 'octocat', avatarUrl: 'https://avatars.example/octocat.png' },
+    repository: { name: 'hello', owner: { login: 'octocat' } },
+    ...overrides,
+  });
+
+  function mockSearch(octokit: OctokitMock, search: unknown) {
+    octokit.request.mockResolvedValueOnce({
+      data: { data: { search } },
+    });
+  }
+
+  it('maps search nodes to inbox items and returns nextCursor from pageInfo', async () => {
+    getGitHubUserAccessToken.mockResolvedValueOnce(connected('t1', 'auth_1', 1));
+    const caller = createCaller({ user: { id: 'user-1' } as User });
+    mockSearch(buildOctokit('t1'), {
+      pageInfo: { hasNextPage: true, endCursor: 'CURSOR_1' },
+      nodes: [inboxNode()],
+    });
+
+    const result = await caller.listInbox({ direction: 'forward' });
+
+    expect(result).toEqual({
+      items: [
+        {
+          owner: 'octocat',
+          repo: 'hello',
+          number: 1,
+          title: 'Fix the thing',
+          author: { login: 'octocat', avatarUrl: 'https://avatars.example/octocat.png' },
+          isDraft: false,
+          updatedAt: '2026-01-01T00:00:00Z',
+        },
+      ],
+      nextCursor: 'CURSOR_1',
+    });
+  });
+
+  it('returns nextCursor: null when hasNextPage is false', async () => {
+    getGitHubUserAccessToken.mockResolvedValueOnce(connected('t1', 'auth_1', 1));
+    const caller = createCaller({ user: { id: 'user-1' } as User });
+    mockSearch(buildOctokit('t1'), {
+      pageInfo: { hasNextPage: false, endCursor: 'CURSOR_2' },
+      nodes: [inboxNode()],
+    });
+
+    const result = await caller.listInbox({ direction: 'forward' });
+
+    expect(result.nextCursor).toBeNull();
+    expect(result.items).toHaveLength(1);
+  });
+
+  it('drops a node missing repository fields instead of throwing', async () => {
+    getGitHubUserAccessToken.mockResolvedValueOnce(connected('t1', 'auth_1', 1));
+    const caller = createCaller({ user: { id: 'user-1' } as User });
+    mockSearch(buildOctokit('t1'), {
+      pageInfo: { hasNextPage: false, endCursor: null },
+      nodes: [
+        // A non-PullRequest node: GraphQL returns it as `{}` (no fragment match).
+        { number: 1, title: 'orphan' },
+        inboxNode(),
+        inboxNode({ repository: null }),
+      ],
+    });
+
+    const result = await caller.listInbox({ direction: 'forward' });
+
+    expect(result.items).toHaveLength(1);
+    expect(result.items[0]).toMatchObject({ owner: 'octocat', repo: 'hello', number: 1 });
+  });
+
+  it('drops a null node and a node missing number, returning the rest of the page', async () => {
+    getGitHubUserAccessToken.mockResolvedValueOnce(connected('t1', 'auth_1', 1));
+    const caller = createCaller({ user: { id: 'user-1' } as User });
+    mockSearch(buildOctokit('t1'), {
+      pageInfo: { hasNextPage: false, endCursor: null },
+      nodes: [
+        // GitHub types `search.nodes` as `[SearchResultItem]`, so an element
+        // can be null; the mapper must drop it, not throw.
+        null,
+        // A node missing `number` alone has no identity and must be dropped.
+        inboxNode({ number: undefined }),
+        inboxNode(),
+      ],
+    });
+
+    const result = await caller.listInbox({ direction: 'forward' });
+
+    expect(result.items).toHaveLength(1);
+    expect(result.items[0]).toMatchObject({ owner: 'octocat', repo: 'hello', number: 1 });
+  });
+
+  it('returns { items: [], nextCursor: null } for a null connection', async () => {
+    getGitHubUserAccessToken.mockResolvedValueOnce(connected('t1', 'auth_1', 1));
+    const caller = createCaller({ user: { id: 'user-1' } as User });
+    mockSearch(buildOctokit('t1'), null);
+
+    const result = await caller.listInbox({ direction: 'forward' });
+
+    expect(result).toEqual({ items: [], nextCursor: null });
+  });
+
+  it('passes the server-fixed search string and page size as GraphQL variables', async () => {
+    getGitHubUserAccessToken.mockResolvedValueOnce(connected('t1', 'auth_1', 1));
+    const caller = createCaller({ user: { id: 'user-1' } as User });
+    const octokit = buildOctokit('t1');
+    mockSearch(octokit, { pageInfo: { hasNextPage: false, endCursor: null }, nodes: [] });
+
+    await caller.listInbox({ direction: 'forward' });
+
+    const call = octokit.request.mock.calls[0] as unknown[];
+    const body = call[1] as {
+      query: string;
+      variables: { q: string; first: number; after: string | null };
+    };
+    expect(body.query).toContain('query PrReviewInbox');
+    expect(body.variables.q).toBe(INBOX_SEARCH_QUERY);
+    expect(body.variables.first).toBe(25);
+    expect(body.variables.after).toBeNull();
+  });
+
+  it('rejects an extra q field (input is .strict())', async () => {
+    getGitHubUserAccessToken.mockResolvedValueOnce(connected('t1', 'auth_1', 1));
+    const caller = createCaller({ user: { id: 'user-1' } as User });
+
+    await expect(
+      caller.listInbox({ q: 'is:pr author:me', direction: 'forward' })
+    ).rejects.toMatchObject({ code: 'BAD_REQUEST' });
+  });
+
+  it('surfaces a GraphQL errors[] FORBIDDEN as a tRPC FORBIDDEN', async () => {
+    getGitHubUserAccessToken.mockResolvedValueOnce(connected('t1', 'auth_1', 1));
+    const caller = createCaller({ user: { id: 'user-1' } as User });
+    buildOctokit('t1').request.mockResolvedValueOnce({
+      data: { data: null, errors: [{ type: 'FORBIDDEN', message: 'no access' }] },
+    });
+
+    await expect(caller.listInbox({ direction: 'forward' })).rejects.toMatchObject({
+      code: 'FORBIDDEN',
+    });
+  });
+
+  it('rotates the credential and retries once on a raw 401', async () => {
+    getGitHubUserAccessToken
+      .mockResolvedValueOnce(connected('t1', 'auth_1', 1))
+      .mockResolvedValueOnce(connected('t2', 'auth_1', 2));
+    const caller = createCaller({ user: { id: 'user-1' } as User });
+    const t1Octokit = buildOctokit('t1');
+    const t2Octokit = buildOctokit('t2');
+    t1Octokit.request.mockRejectedValueOnce({ status: 401, message: 'gone' });
+    mockSearch(t2Octokit, { pageInfo: { hasNextPage: false, endCursor: null }, nodes: [] });
+
+    const result = await caller.listInbox({ direction: 'forward' });
+
+    expect(result).toEqual({ items: [], nextCursor: null });
+    expect(t1Octokit.request).toHaveBeenCalledTimes(1);
+    expect(t2Octokit.request).toHaveBeenCalledTimes(1);
+    expect(t2Octokit.__token).toBe('t2');
+  });
+});
+
+describe('githubPrReviewRouter.getPullRequest and listChecks parallel legs (P2-GH-44b)', () => {
+  const overviewPrData = {
+    number: 1,
+    title: 'Fix the thing',
+    body: 'body',
+    user: { login: 'octocat', avatar_url: 'https://avatars.example/octocat.png' },
+    state: 'open',
+    draft: false,
+    merged: false,
+    base: { ref: 'main', repo: { full_name: 'octocat/hello' } },
+    head: { ref: 'feature/x', sha: 'a'.repeat(40), repo: { full_name: 'octocat/hello' } },
+    node_id: 'PR_1',
+    commits: 3,
+    changed_files: 2,
+    additions: 10,
+    deletions: 4,
+    mergeable: true,
+    mergeable_state: 'clean',
+    auto_merge: null,
+  };
+
+  const overviewRepoData = {
+    allow_merge_commit: true,
+    allow_squash_merge: true,
+    allow_rebase_merge: false,
+    allow_auto_merge: true,
+    delete_branch_on_merge: true,
+    allow_update_branch: true,
+    permissions: { push: true, admin: false, maintain: false },
+  };
+
+  const overviewGraphQlData = {
+    repository: { pullRequest: { reviewDecision: 'APPROVED' } },
+    viewer: { login: 'octocat' },
+  };
+
+  function mockOverview(octokit: OctokitMock, graphQl: unknown = overviewGraphQlData) {
+    octokit.pulls.get.mockResolvedValueOnce({ data: overviewPrData });
+    octokit.repos.get.mockResolvedValueOnce({ data: overviewRepoData });
+    octokit.request.mockResolvedValueOnce({ data: { data: graphQl } });
+  }
+
+  // Polls an assertion until it passes or the timeout elapses. Used to wait for
+  // the async `call` callback (which starts after the token fetch microtask) to
+  // have kicked off its legs before asserting ordering.
+  async function waitFor(assertion: () => void, timeoutMs = 1000): Promise<void> {
+    const start = Date.now();
+    for (;;) {
+      try {
+        assertion();
+        return;
+      } catch {
+        if (Date.now() - start > timeoutMs) {
+          assertion();
+          return;
+        }
+        await new Promise(resolve => setTimeout(resolve, 0));
+      }
+    }
+  }
+
+  it('getPullRequest starts repos.get and the GraphQL leg before pulls.get resolves', async () => {
+    getGitHubUserAccessToken.mockResolvedValueOnce(connected('t1', 'auth_1', 1));
+    const caller = createCaller({ user: { id: 'user-1' } as User });
+    const octokit = buildOctokit('t1');
+
+    let resolvePulls!: (value: unknown) => void;
+    octokit.pulls.get.mockReturnValueOnce(
+      new Promise(resolve => {
+        resolvePulls = resolve;
+      })
+    );
+    octokit.repos.get.mockResolvedValueOnce({ data: overviewRepoData });
+    octokit.request.mockResolvedValueOnce({ data: { data: overviewGraphQlData } });
+
+    const resultPromise = caller.getPullRequest({ owner: 'octocat', repo: 'hello', number: 1 });
+
+    await waitFor(() => expect(octokit.pulls.get).toHaveBeenCalledTimes(1));
+
+    // The other two legs were already started before pulls.get resolved.
+    expect(octokit.repos.get).toHaveBeenCalledTimes(1);
+    expect(octokit.request).toHaveBeenCalledTimes(1);
+
+    resolvePulls({ data: overviewPrData });
+
+    await expect(resultPromise).resolves.toMatchObject({ number: 1, title: 'Fix the thing' });
+  });
+
+  it('listChecks starts both paginate calls before either resolves', async () => {
+    getGitHubUserAccessToken.mockResolvedValueOnce(connected('t1', 'auth_1', 1));
+    const caller = createCaller({ user: { id: 'user-1' } as User });
+    const octokit = buildOctokit('t1');
+
+    let resolveChecks!: (value: unknown) => void;
+    octokit.paginate.mockImplementationOnce(
+      () =>
+        new Promise(resolve => {
+          resolveChecks = resolve;
+        })
+    );
+
+    const resultPromise = caller.listChecks({ owner: 'octocat', repo: 'hello', ref: 'heads/main' });
+
+    await waitFor(() => expect(octokit.paginate).toHaveBeenCalledTimes(2));
+
+    resolveChecks(checkRunsFixture);
+
+    await expect(resultPromise).resolves.toMatchObject({
+      rollup: { total: 2, success: 2, failure: 0, pending: 0, skipped: 0 },
+    });
+  });
+
+  it('surfaces the repos.get error when repos.get rejects and the GraphQL leg rejects later (no unhandled rejection)', async () => {
+    getGitHubUserAccessToken.mockResolvedValueOnce(connected('t1', 'auth_1', 1));
+    const caller = createCaller({ user: { id: 'user-1' } as User });
+    const octokit = buildOctokit('t1');
+
+    octokit.pulls.get.mockResolvedValueOnce({ data: overviewPrData });
+    octokit.repos.get.mockRejectedValueOnce({ status: 404, message: 'repo not found' });
+    let rejectGraphQl!: (reason: unknown) => void;
+    octokit.request.mockReturnValueOnce(
+      new Promise((_resolve, reject) => {
+        rejectGraphQl = reject;
+      })
+    );
+
+    const resultPromise = caller.getPullRequest({ owner: 'octocat', repo: 'hello', number: 1 });
+
+    await waitFor(() => expect(octokit.repos.get).toHaveBeenCalledTimes(1));
+
+    // The GraphQL leg rejects after repos.get already rejected.
+    rejectGraphQl({ status: 401, message: 'gone' });
+
+    await expect(resultPromise).rejects.toMatchObject({ code: 'NOT_FOUND' });
+  });
+
+  it('rotates the credential and retries once on a raw 401 from pulls.get', async () => {
+    getGitHubUserAccessToken
+      .mockResolvedValueOnce(connected('t1', 'auth_1', 1))
+      .mockResolvedValueOnce(connected('t2', 'auth_1', 2));
+    const caller = createCaller({ user: { id: 'user-1' } as User });
+    const t1Octokit = buildOctokit('t1');
+    const t2Octokit = buildOctokit('t2');
+
+    t1Octokit.pulls.get.mockRejectedValueOnce({ status: 401, message: 'gone' });
+    mockOverview(t2Octokit);
+
+    const result = await caller.getPullRequest({ owner: 'octocat', repo: 'hello', number: 1 });
+
+    expect(result).toMatchObject({ number: 1, title: 'Fix the thing' });
+    expect(t1Octokit.pulls.get).toHaveBeenCalledTimes(1);
+    expect(t2Octokit.pulls.get).toHaveBeenCalledTimes(1);
+    expect(t2Octokit.__token).toBe('t2');
+  });
+
+  it('degrades the GraphQL enrichment to a null reviewDecision when the GraphQL leg fails with a non-401 error', async () => {
+    getGitHubUserAccessToken.mockResolvedValueOnce(connected('t1', 'auth_1', 1));
+    const caller = createCaller({ user: { id: 'user-1' } as User });
+    const octokit = buildOctokit('t1');
+
+    octokit.pulls.get.mockResolvedValueOnce({ data: overviewPrData });
+    octokit.repos.get.mockResolvedValueOnce({ data: overviewRepoData });
+    octokit.request.mockRejectedValueOnce(new Error('graphql 5xx'));
+
+    const result = await caller.getPullRequest({ owner: 'octocat', repo: 'hello', number: 1 });
+
+    expect(result.reviewDecision).toBeNull();
+    expect(result.repo.viewerLogin).toBeNull();
+    expect(result.number).toBe(1);
+  });
+});
+
 describe('githubPrReviewRouter mutations go through withGitHubUserTokenRetry', () => {
   it('rotates the credential and retries on a raw 401', async () => {
     getGitHubUserAccessToken
diff --git a/apps/web/src/routers/github-pr-review-router.ts b/apps/web/src/routers/github-pr-review-router.ts
index 29f441b2b9..4f98317582 100644
--- a/apps/web/src/routers/github-pr-review-router.ts
+++ b/apps/web/src/routers/github-pr-review-router.ts
@@ -22,9 +22,11 @@ import type { createGitHubPrReviewOctokit } from '@/lib/github-pr-review/client'
 import {
   buildChecksResult,
   buildFilesPage,
+  buildInboxResult,
   buildOverviewDto,
   buildReviewThreadsResult,
   sliceFileLines,
+  type GraphQlInboxNode,
 } from '@/lib/github-pr-review/mappers';
 import {
   CONVERSATION_COMMENTS_MAX_PAGES,
@@ -32,6 +34,7 @@ import {
   FILE_LINES_MAX,
   FILES_MAX_PAGES,
   FILES_PAGE_SIZE,
+  INBOX_PAGE_SIZE,
   REVIEW_THREADS_PAGE_SIZE,
 } from '@/lib/github-pr-review/dtos';
 import { throwTrpcFromGraphQlErrors, withGitHubUserTokenRetry } from '@/lib/github-pr-review/retry';
@@ -112,6 +115,13 @@ const ListReviewThreadsInput = ownerRepoSchema
   })
   .strict();
 
+const ListInboxInput = z
+  .object({
+    cursor: z.string().min(1).max(512).optional(),
+    direction: infiniteQueryDirection,
+  })
+  .strict();
+
 const CreateReviewCommentInput = ownerRepoSchema
   .extend({
     number: prNumberSchema,
@@ -354,6 +364,40 @@ const CONVERSATION_COMMENTS_QUERY = /* GraphQL */ `
   }
 `;
 
+const INBOX_QUERY = /* GraphQL */ `
+  query PrReviewInbox($q: String!, $first: Int!, $after: String) {
+    search(query: $q, type: ISSUE, first: $first, after: $after) {
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+      nodes {
+        ... on PullRequest {
+          number
+          title
+          isDraft
+          updatedAt
+          author {
+            login
+            avatarUrl
+          }
+          repository {
+            name
+            owner {
+              login
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+
+// Server-fixed. The caller never supplies or influences the search string, so
+// the inbox can only ever return pull requests the caller's own GitHub token
+// can already see, and a caller cannot widen the query.
+export const INBOX_SEARCH_QUERY = 'is:open is:pr review-requested:@me archived:false';
+
 const ENABLE_AUTO_MERGE_MUTATION = /* GraphQL */ `
   mutation EnableAutoMerge($input: EnablePullRequestAutoMergeInput!) {
     enablePullRequestAutoMerge(input: $input) {
@@ -487,6 +531,7 @@ export const PR_REVIEW_GRAPHQL_DOCUMENTS = {
   REVIEW_THREADS_QUERY,
   REVIEW_THREAD_COMMENTS_FOLLOWUP_QUERY,
   CONVERSATION_COMMENTS_QUERY,
+  INBOX_QUERY,
   ENABLE_AUTO_MERGE_MUTATION,
   DISABLE_AUTO_MERGE_MUTATION,
   RESOLVE_THREAD_MUTATION,
@@ -1380,59 +1425,87 @@ async function runMergeWrite(
   }
 }
 
+type OverviewGraphQl = {
+  repository: {
+    pullRequest: { reviewDecision: string | null } | null;
+  } | null;
+  viewer: { login: string } | null;
+};
+
+// GraphQL enrichment for the overview (reviewDecision + viewer.login). It keeps
+// its own try/catch: a TRPCError and any raw 401 are rethrown so
+// withGitHubUserTokenRetry can classify/rotate; everything else degrades to
+// null so a GraphQL 5xx or field error never blocks the rest of the overview.
+async function fetchOverviewGraphQl(
+  octokit: ReturnType<typeof createGitHubPrReviewOctokit>,
+  input: { owner: string; repo: string; number: number }
+): Promise<OverviewGraphQl | null> {
+  try {
+    const gqlResp = (await octokit.request('POST /graphql', {
+      query: PULL_REQUEST_FRAGMENT_QUERY,
+      variables: {
+        owner: input.owner,
+        name: input.repo,
+        number: input.number,
+      },
+    })) as { data: { data: OverviewGraphQl | null; errors?: unknown } };
+    throwTrpcFromGraphQlErrors(gqlResp.data.errors as never);
+    return gqlResp.data.data ?? null;
+  } catch (error) {
+    if (error instanceof TRPCError) throw error;
+    // A raw 401 must reach withGitHubUserTokenRetry so it can rotate the
+    // credential (and report a terminal rejection) — never silently degrade an
+    // authorization failure.
+    if (
+      error !== null &&
+      typeof error === 'object' &&
+      (error as { status?: number }).status === 401
+    ) {
+      throw error;
+    }
+    // Other GraphQL failures (5xx, field errors) should not block the rest of
+    // the overview — degrade the reviewDecision/viewer enrichment.
+    return null;
+  }
+}
+
 export const githubPrReviewRouter = createTRPCRouter({
   getPullRequest: baseProcedure.input(GetPullRequestInput).query(async ({ ctx, input }) => {
     const overview = await withGitHubUserTokenRetry({
       kiloUserId: ctx.user.id,
       call: async octokit => {
-        // Raw GitHub errors propagate to withGitHubUserTokenRetry, which
-        // handles 401 rotation and classifies everything else.
-        const pullsResp = await octokit.pulls.get({
+        // Start all three legs before awaiting so the authorized overview
+        // retrieval runs in parallel. Raw GitHub errors propagate to
+        // withGitHubUserTokenRetry, which handles 401 rotation and classifies
+        // everything else.
+        const pullsPromise = octokit.pulls.get({
           owner: input.owner,
           repo: input.repo,
           pull_number: input.number,
         });
-        const pr = pullsResp.data;
-        const repoResp = await octokit.repos.get({
+        const reposPromise = octokit.repos.get({
           owner: input.owner,
           repo: input.repo,
         });
-        const repo = repoResp.data;
-        // GraphQL for reviewDecision + viewer.login
-        type OverviewGraphQl = {
-          repository: {
-            pullRequest: { reviewDecision: string | null } | null;
-          } | null;
-          viewer: { login: string } | null;
-        };
-        let graphQl: OverviewGraphQl | null = null;
-        try {
-          const gqlResp = (await octokit.request('POST /graphql', {
-            query: PULL_REQUEST_FRAGMENT_QUERY,
-            variables: {
-              owner: input.owner,
-              name: input.repo,
-              number: input.number,
-            },
-          })) as { data: { data: OverviewGraphQl | null; errors?: unknown } };
-          throwTrpcFromGraphQlErrors(gqlResp.data.errors as never);
-          graphQl = gqlResp.data.data ?? null;
-        } catch (error) {
-          if (error instanceof TRPCError) throw error;
-          // A raw 401 must reach withGitHubUserTokenRetry so it can rotate the
-          // credential (and report a terminal rejection) — never silently
-          // degrade an authorization failure.
-          if (
-            error !== null &&
-            typeof error === 'object' &&
-            (error as { status?: number }).status === 401
-          ) {
-            throw error;
-          }
-          // Other GraphQL failures (5xx, field errors) should not block the
-          // rest of the overview — degrade the reviewDecision/viewer enrichment.
-          graphQl = null;
-        }
+        const graphQlPromise = fetchOverviewGraphQl(octokit, input);
+
+        const [pullsResult, reposResult, graphQlResult] = await Promise.allSettled([
+          pullsPromise,
+          reposPromise,
+          graphQlPromise,
+        ]);
+
+        // Rethrow the first rejection in leg order (pulls, repos, graphql).
+        // Promise.allSettled — not Promise.all — is used so a second rejection
+        // after the first never becomes an unhandled rejection.
+        if (pullsResult.status === 'rejected') throw pullsResult.reason;
+        if (reposResult.status === 'rejected') throw reposResult.reason;
+        if (graphQlResult.status === 'rejected') throw graphQlResult.reason;
+
+        const pr = (pullsResult.value as { data: unknown }).data;
+        const repo = (reposResult.value as { data: unknown }).data;
+        const graphQl = graphQlResult.value;
+
         return buildOverviewDto({
           pr: pr as never,
           repo: repo as never,
@@ -1448,21 +1521,35 @@ export const githubPrReviewRouter = createTRPCRouter({
     return withGitHubUserTokenRetry({
       kiloUserId: ctx.user.id,
       call: async octokit => {
-        const checkRuns = await octokit.paginate(octokit.checks.listForRef, {
+        // Start both paginate calls before awaiting so the checks retrieval
+        // runs in parallel.
+        const checkRunsPromise = octokit.paginate(octokit.checks.listForRef, {
           owner: input.owner,
           repo: input.repo,
           ref: input.ref,
           per_page: 100,
         });
-        const statuses = await octokit.paginate(octokit.repos.listCommitStatusesForRef, {
+        const statusesPromise = octokit.paginate(octokit.repos.listCommitStatusesForRef, {
           owner: input.owner,
           repo: input.repo,
           ref: input.ref,
           per_page: 100,
         });
+
+        const [checkRunsResult, statusesResult] = await Promise.allSettled([
+          checkRunsPromise,
+          statusesPromise,
+        ]);
+
+        // Rethrow the first rejection in order (check runs, then commit
+        // statuses). Promise.allSettled — not Promise.all — is used so a second
+        // rejection after the first never becomes an unhandled rejection.
+        if (checkRunsResult.status === 'rejected') throw checkRunsResult.reason;
+        if (statusesResult.status === 'rejected') throw statusesResult.reason;
+
         return buildChecksResult({
-          checkRuns: checkRuns as never,
-          commitStatuses: statuses as never,
+          checkRuns: checkRunsResult.value as never,
+          commitStatuses: statusesResult.value as never,
         });
       },
     });
@@ -1583,6 +1670,42 @@ export const githubPrReviewRouter = createTRPCRouter({
     });
   }),
 
+  // The authorized PR inbox: pull requests requesting the caller's review,
+  // paginated through GitHub GraphQL `search`. The query string is
+  // server-fixed (INBOX_SEARCH_QUERY) so the caller can only ever see PRs
+  // their own token can already see. Read-only — no ledger, no Terms check.
+  listInbox: baseProcedure.input(ListInboxInput).query(async ({ ctx, input }) => {
+    return withGitHubUserTokenRetry({
+      kiloUserId: ctx.user.id,
+      call: async octokit => {
+        const resp = (await octokit.request('POST /graphql', {
+          query: INBOX_QUERY,
+          variables: {
+            q: INBOX_SEARCH_QUERY,
+            first: INBOX_PAGE_SIZE,
+            after: input.cursor ?? null,
+          },
+        })) as {
+          data: {
+            data: {
+              search: {
+                pageInfo: { hasNextPage: boolean; endCursor: string | null };
+                nodes: GraphQlInboxNode[];
+              } | null;
+            } | null;
+            errors?: unknown;
+          };
+        };
+        throwTrpcFromGraphQlErrors(resp.data.errors as never);
+        const connection = resp.data.data?.search ?? null;
+        return buildInboxResult({
+          nodes: connection?.nodes ?? [],
+          pageInfo: connection?.pageInfo ?? null,
+        });
+      },
+    });
+  }),
+
   // Post a single immediate review comment (no pending review required).
   createReviewComment: baseProcedure
     .input(CreateReviewCommentInput)