@oxy.so/services 11.8.0 → 11.10.0

package/src/ui/components/__tests__/AccountInvitationAcceptance.test.tsx

@@ -0,0 +1,61 @@
+import React from 'react';
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { AccountInvitationAcceptance } from '../AccountInvitationAcceptance';
+const mockPreview = jest.fn();
+const mockAccept = jest.fn();
+const mockSwitch = jest.fn();
+let mockUser: { id: string; kind: string; email: string; username: string } | null = null;
+const mockServices = { accounts: { invitations: { preview: mockPreview, accept: mockAccept } } };
+jest.mock('../../context/OxyContext', () => ({
+  useOxy: () => ({
+    oxyServices: mockServices,
+    user: mockUser,
+    canUsePrivateApi: !!mockUser,
+    openAccountDialog: mockSwitch,
+  }),
+}));
+beforeEach(() => {
+  jest.clearAllMocks();
+  mockUser = null;
+  mockPreview.mockResolvedValue({
+    invitation: { role: 'editor' },
+    account: { displayName: 'Community' },
+  });
+  mockAccept.mockResolvedValue({ success: true });
+});
+test('sign-in and switching never accept; confirmation names the displayed selected account', async () => {
+  const { rerender } = render(<AccountInvitationAcceptance token="secret" />);
+  fireEvent.click(screen.getByText('Sign in or create account'));
+  expect(mockSwitch).toHaveBeenCalled();
+  expect(mockAccept).not.toHaveBeenCalled();
+  mockUser = { id: 'first', kind: 'personal', username: 'first', email: 'different@example.com' };
+  rerender(<AccountInvitationAcceptance token="secret" />);
+  await screen.findByText('Join Community as editor.');
+  fireEvent.click(screen.getByText('Change account'));
+  expect(mockAccept).not.toHaveBeenCalled();
+  mockUser = { id: 'second', kind: 'personal', username: 'second', email: 'second@example.com' };
+  rerender(<AccountInvitationAcceptance token="secret" />);
+  expect(screen.getByText(/Selected account: second/)).toBeTruthy();
+  fireEvent.click(screen.getByText('Confirm and accept'));
+  await waitFor(() => expect(mockAccept).toHaveBeenCalledWith('secret', 'second'));
+  await screen.findByText('Invitation accepted. You can now access this account.');
+});
+test('a new link resets previous acceptance and does not auto-accept', async () => {
+  mockUser = { id: 'first', kind: 'personal', username: 'first', email: 'first@example.com' };
+  const { rerender } = render(<AccountInvitationAcceptance token="old" />);
+  await screen.findByText('Join Community as editor.');
+  fireEvent.click(screen.getByText('Confirm and accept'));
+  await screen.findByText('Invitation accepted. You can now access this account.');
+  rerender(<AccountInvitationAcceptance token="new" />);
+  await screen.findByText('Join Community as editor.');
+  expect(screen.queryByText('Invitation accepted. You can now access this account.')).toBeNull();
+  expect(mockAccept).toHaveBeenCalledTimes(1);
+});
+test('preview failure leaves confirmation disabled', async () => {
+  mockUser = { id: 'first', kind: 'personal', username: 'first', email: 'first@example.com' };
+  mockPreview.mockRejectedValue(new Error('Invitation expired'));
+  render(<AccountInvitationAcceptance token="expired" />);
+  await screen.findByText('Invitation expired');
+  fireEvent.click(screen.getByText('Confirm and accept'));
+  expect(mockAccept).not.toHaveBeenCalled();
+});

package/src/ui/components/fileManagement/FileViewer.tsx

@@ -18,7 +18,10 @@ interface FileViewerProps {
   onToggleDetails: () => void;
   onClose: () => void;
   onDownload: (fileId: string, filename: string) => void;
+  /** Removes the file from the library: to trash, or for good if it is blocked. */
   onDelete: (fileId: string, filename: string) => void;
+  /** The remove button's label — "Move to trash", or "Delete" for a blocked file. */
+  deleteLabel: string;
   isOwner: boolean;
 }
 
@@ -55,6 +58,7 @@ export const FileViewer: React.FC<FileViewerProps> = ({
   onClose,
   onDownload,
   onDelete,
+  deleteLabel,
   isOwner,
 }) => {
   const { colors } = useTheme();
@@ -395,7 +399,7 @@ export const FileViewer: React.FC<FileViewerProps> = ({
                     onDelete(file.id, file.filename);
                   }}
                 >
-                  Delete
+                  {deleteLabel}
                 </Button>
               </View>
             )}

package/src/ui/hooks/queries/__tests__/fileQueries.test.ts

@@ -0,0 +1,70 @@
+/**
+ * The file library's page mapping and cache helpers for the Trash view (ADR
+ * 0043 D5): a trashed file keeps its `trashedAt`, and the library and the
+ * trash are separate cache entries under one `files` root.
+ */
+import { QueryClient } from '@tanstack/react-query';
+import { queryKeys } from '../queryKeys';
+import {
+  mapRawFileToMetadata,
+  removeFileFromCache,
+  toUserFilesPage,
+  type UserFilesInfinite,
+} from '../useFileQueries';
+
+jest.mock('../../../context/OxyContext', () => ({ useOxy: () => ({}) }));
+
+const page = (ids: string[]): UserFilesInfinite => ({
+  pages: [
+    {
+      files: ids.map((id) => mapRawFileToMetadata({ id, originalName: `${id}.png` })),
+      total: ids.length,
+      hasMore: false,
+      nextOffset: 40,
+    },
+  ],
+  pageParams: [0],
+});
+
+describe('mapRawFileToMetadata', () => {
+  it('keeps the status and when the file went to trash', () => {
+    const file = mapRawFileToMetadata({
+      id: 'f',
+      originalName: 'f.png',
+      status: 'trash',
+      trashedAt: '2026-10-16T10:00:00.000Z',
+    });
+    expect(file).toMatchObject({ status: 'trash', trashedAt: '2026-10-16T10:00:00.000Z' });
+    expect(mapRawFileToMetadata({ id: 'g', trashedAt: null })).not.toHaveProperty('trashedAt');
+  });
+});
+
+describe('toUserFilesPage', () => {
+  it('maps a page and where the next one starts', () => {
+    const mapped = toUserFilesPage({ files: [{ id: 'a' }], total: 41, hasMore: true }, 0);
+    expect(mapped).toMatchObject({ total: 41, hasMore: true, nextOffset: 40 });
+    expect(mapped.files.map((file) => file.id)).toEqual(['a']);
+  });
+});
+
+describe('the trash cache', () => {
+  it('is its own entry under files.all, and removal targets the list it names', () => {
+    expect(queryKeys.files.trash('u').slice(0, 1)).toEqual([...queryKeys.files.all]);
+    expect(queryKeys.files.trash('u')).not.toEqual(queryKeys.files.list('u'));
+
+    const client = new QueryClient();
+    client.setQueryData(queryKeys.files.list('u'), page(['a', 'b']));
+    client.setQueryData(queryKeys.files.trash('u'), page(['b', 't']));
+
+    removeFileFromCache(client, 'u', 'b', 'trash');
+    const ids = (key: readonly unknown[]) =>
+      client
+        .getQueryData<UserFilesInfinite>(key)
+        ?.pages.flatMap((p) => p.files.map((file) => file.id));
+    expect(ids(queryKeys.files.trash('u'))).toEqual(['t']);
+    expect(ids(queryKeys.files.list('u'))).toEqual(['a', 'b']);
+
+    removeFileFromCache(client, 'u', 'a');
+    expect(ids(queryKeys.files.list('u'))).toEqual(['b']);
+  });
+});

package/src/ui/hooks/queries/queryKeys.ts

@@ -113,6 +113,8 @@ export const queryKeys = {
   files: {
     all: ['files'] as const,
     list: (ownerId?: string) => [...queryKeys.files.all, 'list', ownerId || 'anonymous'] as const,
+    /** The owner's trash (ADR 0043 D5) — under `files.all`, so one invalidation covers both. */
+    trash: (ownerId?: string) => [...queryKeys.files.all, 'trash', ownerId || 'anonymous'] as const,
   },
 
   // Connected apps (OAuth grants the user has authorized)

package/src/ui/hooks/queries/useFileQueries.ts

@@ -27,6 +27,12 @@ export interface RawUserFile {
   createdAt?: string;
   metadata?: Record<string, unknown>;
   variants?: unknown[];
+  /** Whether any application uses the file (ADR 0043 D5). */
+  inUse?: boolean;
+  /** `blocked`: taken down after a content claim (ADR 0043 D10). */
+  status?: string;
+  /** When the owner moved it to trash (ADR 0043 D5). */
+  trashedAt?: string | null;
 }
 
 /** One page of the infinite file list. */
@@ -48,31 +54,52 @@ export function mapRawFileToMetadata(raw: RawUserFile): FileMetadata {
     length: raw.size ?? 0,
     chunkSize: 0,
     uploadDate: raw.createdAt ?? '',
+    ...(typeof raw.inUse === 'boolean' ? { inUse: raw.inUse } : {}),
+    ...(raw.status === 'active' || raw.status === 'trash' || raw.status === 'blocked'
+      ? { status: raw.status }
+      : {}),
+    ...(typeof raw.trashedAt === 'string' ? { trashedAt: raw.trashedAt } : {}),
     metadata: raw.metadata ?? {},
     variants: (raw.variants ?? []) as FileMetadata['variants'],
   };
 }
 
+/** Which of the owner's files a page lists: the library, or the trash (ADR 0043 D5). */
+export type UserFilesListing = 'library' | 'trash';
+
+/** Map one `oxyServices.assets.list` response onto a page. */
+export function toUserFilesPage(
+  response: { files?: unknown[]; total?: number; hasMore?: boolean },
+  offset: number,
+): UserFilesPage {
+  const files = ((response.files ?? []) as RawUserFile[]).map(mapRawFileToMetadata);
+  return {
+    files,
+    total: response.total ?? offset + files.length,
+    hasMore: Boolean(response.hasMore),
+    nextOffset: offset + FILES_PAGE_SIZE,
+  };
+}
+
 /**
- * Infinite-paginated list of the owner's files. Fires on mount and whenever
- * `ownerId` changes (a new key); `staleTime: 0` reloads on every open. The
- * rendered list is `data.pages.flatMap(p => p.files)`.
+ * Infinite-paginated list of the owner's files: the LIBRARY (active files, and
+ * blocked ones shown as removed after a claim) or, with `listing: 'trash'`,
+ * what the owner moved to trash, most recently trashed first. Fires on mount
+ * and whenever `ownerId` changes (a new key); `staleTime: 0` reloads on every
+ * open. The rendered list is `data.pages.flatMap(p => p.files)`.
  */
-export const useUserFilesInfinite = (ownerId?: string) => {
+export const useUserFilesInfinite = (ownerId?: string, listing: UserFilesListing = 'library') => {
   const { oxyServices } = useOxy();
   return useInfiniteQuery<UserFilesPage, Error>({
-    queryKey: queryKeys.files.list(ownerId),
+    queryKey: listing === 'trash' ? queryKeys.files.trash(ownerId) : queryKeys.files.list(ownerId),
     queryFn: async ({ pageParam }) => {
       const offset = typeof pageParam === 'number' ? pageParam : 0;
-      const response = await oxyServices.assets.list({ limit: FILES_PAGE_SIZE, offset });
-      const raw = (response.files ?? []) as RawUserFile[];
-      const files = raw.map(mapRawFileToMetadata);
-      return {
-        files,
-        total: response.total ?? offset + files.length,
-        hasMore: Boolean(response.hasMore),
-        nextOffset: offset + FILES_PAGE_SIZE,
-      };
+      const response = await oxyServices.assets.list({
+        limit: FILES_PAGE_SIZE,
+        offset,
+        ...(listing === 'trash' ? { status: 'trash' as const } : {}),
+      });
+      return toUserFilesPage(response, offset);
     },
     initialPageParam: 0,
     getNextPageParam: (lastPage) => (lastPage.hasMore ? lastPage.nextOffset : undefined),
@@ -114,13 +141,15 @@ export function prependFileToCache(
   });
 }
 
-/** Remove a file (by id) from every page. */
+/** Remove a file (by id) from every page of the library, or of the trash. */
 export function removeFileFromCache(
   queryClient: QueryClient,
   ownerId: string | undefined,
   fileId: string,
+  listing: UserFilesListing = 'library',
 ): void {
-  queryClient.setQueryData<UserFilesInfinite>(fileListKey(ownerId), (data) =>
+  const key = listing === 'trash' ? queryKeys.files.trash(ownerId) : fileListKey(ownerId);
+  queryClient.setQueryData<UserFilesInfinite>(key, (data) =>
     data ? mapPages(data, (files) => files.filter((f) => f.id !== fileId)) : data,
   );
 }

package/src/ui/hooks/useDisplayCurrency.ts

@@ -0,0 +1,64 @@
+import { useSyncExternalStore } from 'react';
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { authenticatedApiCall, type UserPreferences } from '@oxy.so/core';
+import { useOxy } from '../context/OxyContext';
+import { useCurrentUser } from './queries/useAccountQueries';
+import { queryKeys } from './queries/queryKeys';
+import { useAuthStore } from '../stores/authStore';
+import { mutationKeys } from './mutations/mutationKeys';
+
+export type DisplayCurrency = NonNullable<UserPreferences['displayCurrency']>;
+export const DISPLAY_CURRENCIES: readonly DisplayCurrency[] = ['USD', 'EUR', 'FAIR'];
+
+let anonymousCurrency: DisplayCurrency = 'USD';
+const anonymousListeners = new Set<() => void>();
+const subscribeAnonymous = (listener: () => void) => {
+  anonymousListeners.add(listener);
+  return () => {
+    anonymousListeners.delete(listener);
+  };
+};
+const anonymousSnapshot = () => anonymousCurrency;
+
+/** Account-scoped server preference. A late save can never replace another account. */
+export function useDisplayCurrency() {
+  const { oxyServices, activeSessionId, isAuthenticated, user } = useOxy();
+  const current = useCurrentUser({ enabled: isAuthenticated });
+  const client = useQueryClient();
+  const anonymous = useSyncExternalStore(
+    subscribeAnonymous,
+    anonymousSnapshot,
+    () => 'USD' as const,
+  );
+  const currency = isAuthenticated
+    ? (current.data?.userPreferences?.displayCurrency ??
+      user?.userPreferences?.displayCurrency ??
+      'USD')
+    : anonymous;
+  const mutation = useMutation({
+    mutationKey: [...mutationKeys.account.updateSettings],
+    mutationFn: async (input: { currency: DisplayCurrency; sessionId: string; userId: string }) => {
+      const updated = await authenticatedApiCall(oxyServices, input.sessionId, () =>
+        oxyServices.users.updateMe({ userPreferences: { displayCurrency: input.currency } }),
+      );
+      if (updated.id !== input.userId) throw new Error('Account changed. Please try again.');
+      return updated;
+    },
+    onSuccess: (updated, input) => {
+      client.setQueryData(queryKeys.accounts.current(input.sessionId), updated);
+      if (useAuthStore.getState().user?.id === input.userId)
+        useAuthStore.getState().setUser(updated);
+    },
+  });
+  function selectCurrency(next: DisplayCurrency) {
+    if (!DISPLAY_CURRENCIES.includes(next)) return;
+    if (!isAuthenticated) {
+      anonymousCurrency = next;
+      for (const listener of anonymousListeners) listener();
+      return;
+    }
+    if (activeSessionId && user?.id)
+      mutation.mutate({ currency: next, sessionId: activeSessionId, userId: user.id });
+  }
+  return { currency, selectCurrency, isSaving: mutation.isPending, error: mutation.error };
+}

package/src/ui/hooks/useDisplayPrice.ts

@@ -0,0 +1,40 @@
+import { useQuery } from '@tanstack/react-query';
+import { useEffect, useState } from 'react';
+import { convertDisplayAmount, readDisplayRates } from '@peable.to/sdk/display';
+import { useDisplayCurrency } from './useDisplayCurrency';
+import { useI18n } from './useI18n';
+
+/** Display conversion only. Pricing and checkout request bodies retain their source units. */
+export function useDisplayPrice() {
+  const { currency } = useDisplayCurrency();
+  const { t } = useI18n();
+  const [now, setNow] = useState(Date.now);
+  const rates = useQuery({
+    queryKey: ['display-currency', 'faircoin-indexed-price'],
+    queryFn: ({ signal }) => readDisplayRates({ signal }),
+    enabled: currency !== 'USD',
+    staleTime: 30_000,
+    gcTime: 0,
+    retry: false,
+    refetchInterval: 60_000,
+    refetchOnWindowFocus: 'always',
+  });
+  useEffect(() => {
+    const timer = setInterval(() => setNow(Date.now()), 1000);
+    return () => clearInterval(timer);
+  }, []);
+  function formatUsd(minorUnits: number) {
+    const display = convertDisplayAmount({
+      units: String(minorUnits),
+      currency: 'USD',
+      displayCurrency: currency,
+      rates: rates.isError ? null : rates.data,
+      now,
+    });
+    if (!display) return t('preferences.displayCurrency.unavailable', { currency });
+    return currency === 'USD'
+      ? display
+      : t('preferences.displayCurrency.approximate', { amount: display });
+  }
+  return { currency, formatUsd };
+}

package/src/ui/icons/subsetGlyphMaps.ts

@@ -9,6 +9,7 @@ export const ioniconsGlyphMap = {
   "arrow-back": 61735,
   "arrow-down": 61741,
   "arrow-forward": 61747,
+  "arrow-undo": 61759,
   "arrow-up": 61765,
   "at": 61771,
   "briefcase-outline": 61874,

package/src/ui/navigation/__tests__/getSurfaceConfig.test.ts

@@ -32,6 +32,15 @@ describe('getSurfaceConfig presentation', () => {
     expect(config.frameSize).toEqual({ heightRatio: 0.9, maxWidth: 640 });
   });
 
+  it('hosts the file Trash as a morphing own-scroller sheet (it owns its list)', () => {
+    const config = getSurfaceConfig('FileTrash', {});
+    expect(config.presentation).toBe('sheet');
+    expect(config.scrollable).toBe(false);
+    expect(config.morph).toBe(true);
+    expect(config.stacks).toBe(false);
+    expect(config.header).toBe(true);
+  });
+
   it('morphs the surface for every route, the picker included', () => {
     // NAV-WITHIN: drilling into these swaps the content inside ONE surface,
     // which reshapes the panel instead of hard-cutting.

package/src/ui/navigation/routes.ts

@@ -12,6 +12,7 @@ export type RouteName =
   | 'PrivacySettings'
   | 'SearchSettings'
   | 'FileManagement'
+  | 'FileTrash' // The person's trash: restore, or delete permanently (ADR 0043 D5)
   | 'HelpSupport'
   | 'LegalDocuments'
   | 'AppInfo'
@@ -81,6 +82,7 @@ const screenComponents: Record<RouteName, ComponentType<never>> = {
   PrivacySettings: lazy(() => import('../screens/PrivacySettingsScreen')),
   SearchSettings: lazy(() => import('../screens/SearchSettingsScreen')),
   FileManagement: lazy(() => import('../screens/FileManagementScreen')),
+  FileTrash: lazy(() => import('../screens/FileTrashScreen')),
   HelpSupport: lazy(() => import('../screens/HelpSupportScreen')),
   LegalDocuments: lazy(() => import('../screens/LegalDocumentsScreen')),
   AppInfo: lazy(() => import('../screens/AppInfoScreen')),

package/src/ui/navigation/surfaceRegistry.ts

@@ -39,6 +39,8 @@ export interface SurfaceRegistry {
    * keep their callback behaviour and this result goes unread.
    */
   FileManagement: SurfaceRoute<Record<string, unknown>, FileMetadata>;
+  /** The person's trash (ADR 0043 D5), opened from the file manager. */
+  FileTrash: SurfaceRoute;
   HelpSupport: SurfaceRoute;
   LegalDocuments: SurfaceRoute;
   AppInfo: SurfaceRoute;
@@ -233,7 +235,7 @@ const isFileManagementImageOnlyPicker = (props: Record<string, unknown>): boolea
  * Routes whose screen owns its OWN scroll container — a FlatList /
  * VirtualizedList (`ConnectedApps`, `TrustLeaderboard`, `FollowersList` /
  * `FollowingList` via `UserListScreen`) or its own vertical `ScrollView`
- * (`FileManagement`). These MUST opt out of the Dialog's internal ScrollView
+ * (`FileManagement`, `FileTrash`). These MUST opt out of the Dialog's internal ScrollView
  * (`scrollable: false`) so there is exactly ONE scroll container — otherwise a
  * VirtualizedList nests inside a plain ScrollView (RN warning) or a nested
  * vertical scroll-in-scroll breaks windowing. Screens with only a HORIZONTAL
@@ -242,6 +244,7 @@ const isFileManagementImageOnlyPicker = (props: Record<string, unknown>): boolea
  */
 const OWN_SCROLL_CONTAINER_ROUTES: ReadonlySet<RouteName> = new Set<RouteName>([
   'FileManagement',
+  'FileTrash',
   'ConnectedApps',
   'TrustLeaderboard',
   'FollowersList',

package/src/ui/screens/AccountMembersScreen.tsx

@@ -30,13 +30,8 @@ const ASSIGNABLE_ROLES: AssignableRole[] = ['admin', 'editor', 'developer', 'bil
 const errorMessage = (error: unknown, fallback: string): string =>
   error instanceof Error && error.message ? error.message : fallback;
 
-const isUserNotFound = (error: unknown): boolean => {
-  const message = error instanceof Error ? error.message.toLowerCase() : '';
-  return message.includes('user not found') || message.includes('not found');
-};
-
 /**
- * Manage the members of an account (invite by username/email, change roles,
+ * Manage the members of an account (invite by email, change roles,
  * remove, transfer ownership). Gated on the caller's `callerMembership`
  * permissions. Receives the target `accountId` via navigation props.
  */
@@ -86,6 +81,27 @@ const AccountMembersScreen: React.FC<BaseScreenProps> = ({ onClose, goBack, acco
     queryFn: () => oxyServices.accounts.members.list(id),
     enabled: canUsePrivateApi && id.length > 0 && canRead,
   });
+  const invitationsQuery = useQuery({
+    queryKey: ['account-invitations', id],
+    queryFn: () => oxyServices.accounts.invitations.list(id),
+    enabled: canUsePrivateApi && !!id && canRead,
+  });
+  const invitationAction = useMutation({
+    mutationFn: async ({
+      invitationId,
+      action,
+    }: {
+      invitationId: string;
+      action: 'resend' | 'cancel';
+    }) => {
+      if (action === 'resend') await oxyServices.accounts.invitations.resend(id, invitationId);
+      else await oxyServices.accounts.invitations.cancel(id, invitationId);
+    },
+    onSuccess: () => {
+      void invitationsQuery.refetch();
+    },
+    onError: (error) => toast.error(errorMessage(error, 'Could not update invitation')),
+  });
   const members = useMemo<AccountMember[]>(() => membersQuery.data ?? [], [membersQuery.data]);
   const memberUserIds = useMemo(
     () => [...new Set(members.map((member) => member.memberUserId).filter((id) => id.length > 0))],
@@ -126,6 +142,7 @@ const AccountMembersScreen: React.FC<BaseScreenProps> = ({ onClose, goBack, acco
     // tables — mirror the SDK's per-account prefix sweep so every cached member
     // list refetches, not only the account that was mutated.
     queryClient.invalidateQueries({ queryKey: ['accounts', 'members'] });
+    queryClient.invalidateQueries({ queryKey: ['account-invitations', id] });
     queryClient.invalidateQueries({ queryKey: ['accounts', 'detail', id] });
   }, [queryClient, id]);
 
@@ -137,24 +154,20 @@ const AccountMembersScreen: React.FC<BaseScreenProps> = ({ onClose, goBack, acco
   const inviteMutation = useMutation({
     mutationKey: ['accounts', 'members', 'invite', id],
     mutationFn: (input: { usernameOrEmail: string; role: AssignableRole }) =>
-      oxyServices.accounts.members.invite(id, input),
+      oxyServices.accounts.invitations.create(id, {
+        email: input.usernameOrEmail,
+        role: input.role,
+      }),
     onSuccess: () => {
       setInviteIdentifier('');
       setInviteRole('editor');
       setInviteError(null);
       invalidateMembers();
-      toast.success(t('accounts.members.toasts.added') || 'Member added');
+      toast.success('Invitation sent');
     },
     onError: (error) => {
-      if (isUserNotFound(error)) {
-        const message = t('accounts.members.errors.userNotFound') || 'User not found';
-        setInviteError(message);
-        toast.error(message);
-        return;
-      }
-      toast.error(
-        errorMessage(error, t('accounts.members.toasts.addFailed') || 'Failed to add member'),
-      );
+      invalidateMembers();
+      toast.error(errorMessage(error, 'Could not send invitation'));
     },
   });
 
@@ -207,14 +220,12 @@ const AccountMembersScreen: React.FC<BaseScreenProps> = ({ onClose, goBack, acco
   const handleInvite = useCallback(() => {
     const usernameOrEmail = inviteIdentifier.trim();
     if (!usernameOrEmail) {
-      setInviteError(
-        t('accounts.members.errors.identifierRequired') || 'Enter a username or email to invite',
-      );
+      setInviteError('Enter an email to invite');
       return;
     }
     setInviteError(null);
     inviteMutation.mutate({ usernameOrEmail, role: inviteRole });
-  }, [inviteIdentifier, inviteRole, inviteMutation, t]);
+  }, [inviteIdentifier, inviteRole, inviteMutation]);
 
   const handleChangeRole = useCallback(
     (member: AccountMember, role: AccountRole) => {
@@ -282,13 +293,11 @@ const AccountMembersScreen: React.FC<BaseScreenProps> = ({ onClose, goBack, acco
       {/* Invite form */}
       {canInvite ? (
         <View className="gap-space-12 p-space-16 rounded-radius-20 bg-fill">
-          <Text className="text-body font-semibold text-text">
-            {t('accounts.members.invite.title') || 'Add a member'}
-          </Text>
+          <Text className="text-body font-semibold text-text">{'Invite a member'}</Text>
           <TextField isInvalid={!!inviteError}>
             <TextFieldInput
               floatingLabel
-              label={t('accounts.members.invite.identifierLabel') || 'Username or email'}
+              label={'Email'}
               value={inviteIdentifier}
               onChangeText={(value) => {
                 setInviteIdentifier(value);
@@ -332,14 +341,49 @@ const AccountMembersScreen: React.FC<BaseScreenProps> = ({ onClose, goBack, acco
             onPress={handleInvite}
             disabled={inviteMutation.isPending || !inviteIdentifier.trim()}
             loading={inviteMutation.isPending}
-            accessibilityLabel={t('accounts.members.invite.submit') || 'Add member'}
+            accessibilityLabel={'Send invitation'}
             className="w-full"
           >
-            {t('accounts.members.invite.submit') || 'Add member'}
+            {'Send invitation'}
           </Button>
         </View>
       ) : null}
 
+      {canRead ? (
+        <View className="gap-space-12">
+          <Text className="text-body font-semibold text-text">Pending invitations</Text>
+          {invitationsQuery.isError ? <Text>Could not load invitations.</Text> : null}
+          {(invitationsQuery.data ?? []).map((invitation) => (
+            <View key={invitation.id} className="gap-space-8 p-space-16 rounded-radius-20 bg-fill">
+              <Text>
+                {invitation.email} · {roleLabel(invitation.role)} · {invitation.status}
+              </Text>
+              <Text>Expires {new Date(invitation.expiresAt).toLocaleDateString()}</Text>
+              {canInvite ? (
+                <Button
+                  disabled={invitationAction.isPending}
+                  onPress={() =>
+                    invitationAction.mutate({ invitationId: invitation.id, action: 'resend' })
+                  }
+                >
+                  Resend
+                </Button>
+              ) : null}
+              {canRemove ? (
+                <Button
+                  disabled={invitationAction.isPending}
+                  onPress={() =>
+                    invitationAction.mutate({ invitationId: invitation.id, action: 'cancel' })
+                  }
+                >
+                  Cancel invitation
+                </Button>
+              ) : null}
+            </View>
+          ))}
+        </View>
+      ) : null}
+
       {/* Member list */}
       {canRead ? (
         <View className="gap-space-8">