Add match archiving, chat enhancements, and daily limits

- Match archives with swipe-to-archive and unread filtering
- Chat settings sheet and full-screen media modals
- Match notification modal for new matches
- Admin AI settings with model/provider configuration
- Daily response limit feature with recommended questions
- New test coverage for stores, hooks, and components
- Claude Code agent and command configurations

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

apps/mobile/src/__tests__/hooks/useFeatureInterest.test.ts

@@ -0,0 +1,197 @@
+import { renderHook, act, waitFor } from '@testing-library/react-native';
+import { useFeatureInterest } from '@/hooks/useFeatureInterest';
+import { useAuthStore } from '@/store/authStore';
+import { supabase } from '@/lib/supabase';
+
+function createThenableQuery(result: any) {
+    const query: any = {
+        select: jest.fn(() => query),
+        eq: jest.fn(() => query),
+        insert: jest.fn(() => query),
+        delete: jest.fn(() => query),
+        maybeSingle: jest.fn(() => query),
+        then: (resolve: any, reject: any) => Promise.resolve(result).then(resolve, reject),
+    };
+    return query;
+}
+
+describe('useFeatureInterest', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        useAuthStore.setState({ user: { id: 'user1' } } as any);
+    });
+
+    it('fetches initial interest status as true when interest exists', async () => {
+        const query = createThenableQuery({ data: { id: 'interest1' } });
+        (supabase.from as jest.Mock).mockReturnValue(query);
+
+        const { result } = renderHook(() => useFeatureInterest('dares'));
+
+        await waitFor(() => {
+            expect(result.current.isLoading).toBe(false);
+        });
+
+        expect(result.current.isInterested).toBe(true);
+        expect(result.current.isAuthenticated).toBe(true);
+        expect(query.eq).toHaveBeenCalledWith('user_id', 'user1');
+        expect(query.eq).toHaveBeenCalledWith('feature_name', 'dares');
+    });
+
+    it('fetches initial interest status as false when no interest exists', async () => {
+        const query = createThenableQuery({ data: null });
+        (supabase.from as jest.Mock).mockReturnValue(query);
+
+        const { result } = renderHook(() => useFeatureInterest('dares'));
+
+        await waitFor(() => {
+            expect(result.current.isLoading).toBe(false);
+        });
+
+        expect(result.current.isInterested).toBe(false);
+    });
+
+    it('returns isAuthenticated false when user is null', async () => {
+        useAuthStore.setState({ user: null } as any);
+
+        const { result } = renderHook(() => useFeatureInterest('dares'));
+
+        await waitFor(() => {
+            expect(result.current.isLoading).toBe(false);
+        });
+
+        expect(result.current.isAuthenticated).toBe(false);
+        expect(result.current.isInterested).toBe(false);
+        expect(supabase.from).not.toHaveBeenCalled();
+    });
+
+    it('adds interest when toggling from not interested', async () => {
+        // Initial query returns no interest
+        const initialQuery = createThenableQuery({ data: null });
+        const insertQuery = createThenableQuery({ error: null });
+
+        (supabase.from as jest.Mock)
+            .mockReturnValueOnce(initialQuery) // Initial fetch
+            .mockReturnValueOnce(insertQuery); // Insert on toggle
+
+        const { result } = renderHook(() => useFeatureInterest('dares'));
+
+        await waitFor(() => {
+            expect(result.current.isLoading).toBe(false);
+        });
+
+        expect(result.current.isInterested).toBe(false);
+
+        await act(async () => {
+            await result.current.toggleInterest();
+        });
+
+        expect(result.current.isInterested).toBe(true);
+        expect(insertQuery.insert).toHaveBeenCalledWith({
+            user_id: 'user1',
+            feature_name: 'dares',
+        });
+    });
+
+    it('removes interest when toggling from interested', async () => {
+        // Initial query returns existing interest
+        const initialQuery = createThenableQuery({ data: { id: 'interest1' } });
+        const deleteQuery = createThenableQuery({ error: null });
+
+        (supabase.from as jest.Mock)
+            .mockReturnValueOnce(initialQuery) // Initial fetch
+            .mockReturnValueOnce(deleteQuery); // Delete on toggle
+
+        const { result } = renderHook(() => useFeatureInterest('dares'));
+
+        await waitFor(() => {
+            expect(result.current.isLoading).toBe(false);
+        });
+
+        expect(result.current.isInterested).toBe(true);
+
+        await act(async () => {
+            await result.current.toggleInterest();
+        });
+
+        expect(result.current.isInterested).toBe(false);
+        expect(deleteQuery.delete).toHaveBeenCalled();
+        expect(deleteQuery.eq).toHaveBeenCalledWith('user_id', 'user1');
+        expect(deleteQuery.eq).toHaveBeenCalledWith('feature_name', 'dares');
+    });
+
+    it('reverts optimistic update on error', async () => {
+        const initialQuery = createThenableQuery({ data: null });
+        const insertQuery = createThenableQuery({ error: new Error('Insert failed') });
+
+        (supabase.from as jest.Mock)
+            .mockReturnValueOnce(initialQuery)
+            .mockReturnValueOnce(insertQuery);
+
+        const { result } = renderHook(() => useFeatureInterest('dares'));
+
+        await waitFor(() => {
+            expect(result.current.isLoading).toBe(false);
+        });
+
+        expect(result.current.isInterested).toBe(false);
+
+        await act(async () => {
+            await result.current.toggleInterest();
+        });
+
+        // Should revert to original state after error
+        expect(result.current.isInterested).toBe(false);
+    });
+
+    it('does not toggle when user is not authenticated', async () => {
+        useAuthStore.setState({ user: null } as any);
+
+        const { result } = renderHook(() => useFeatureInterest('dares'));
+
+        await waitFor(() => {
+            expect(result.current.isLoading).toBe(false);
+        });
+
+        await act(async () => {
+            await result.current.toggleInterest();
+        });
+
+        // Should not make any API calls
+        expect(supabase.from).not.toHaveBeenCalled();
+    });
+
+    it('isToggling is false when not toggling', async () => {
+        const initialQuery = createThenableQuery({ data: null });
+
+        (supabase.from as jest.Mock).mockReturnValueOnce(initialQuery);
+
+        const { result } = renderHook(() => useFeatureInterest('dares'));
+
+        await waitFor(() => {
+            expect(result.current.isLoading).toBe(false);
+        });
+
+        expect(result.current.isToggling).toBe(false);
+    });
+
+    it('isToggling is false after toggle completes', async () => {
+        const initialQuery = createThenableQuery({ data: null });
+        const insertQuery = createThenableQuery({ error: null });
+
+        (supabase.from as jest.Mock)
+            .mockReturnValueOnce(initialQuery)
+            .mockReturnValueOnce(insertQuery);
+
+        const { result } = renderHook(() => useFeatureInterest('dares'));
+
+        await waitFor(() => {
+            expect(result.current.isLoading).toBe(false);
+        });
+
+        await act(async () => {
+            await result.current.toggleInterest();
+        });
+
+        expect(result.current.isToggling).toBe(false);
+    });
+});

apps/mobile/src/__tests__/hooks/useMediaPicker.test.ts

@@ -6,91 +6,355 @@ import { useMediaPicker } from '@/hooks/useMediaPicker';
 describe('useMediaPicker', () => {
     beforeEach(() => {
         jest.clearAllMocks();
+        jest.useFakeTimers();
     });
 
-    it('returns null when user cancels library picker', async () => {
-        (ImagePicker.launchImageLibraryAsync as jest.Mock).mockResolvedValueOnce({
-            canceled: true,
-            assets: [],
-        });
-
-        const { result } = renderHook(() => useMediaPicker());
-
-        let picked: any;
-        await act(async () => {
-            picked = await result.current.pickMedia();
-        });
-
-        expect(picked).toBeNull();
+    afterEach(() => {
+        jest.useRealTimers();
     });
 
-    it('maps selected image to MediaResult', async () => {
-        (ImagePicker.launchImageLibraryAsync as jest.Mock).mockResolvedValueOnce({
-            canceled: false,
-            assets: [{
+    describe('pickMedia', () => {
+        it('returns null when user cancels library picker', async () => {
+            (ImagePicker.launchImageLibraryAsync as jest.Mock).mockResolvedValueOnce({
+                canceled: true,
+                assets: [],
+            });
+
+            const { result } = renderHook(() => useMediaPicker());
+
+            let picked: any;
+            await act(async () => {
+                picked = await result.current.pickMedia();
+            });
+
+            expect(picked).toBeNull();
+        });
+
+        it('maps selected image to MediaResult', async () => {
+            (ImagePicker.launchImageLibraryAsync as jest.Mock).mockResolvedValueOnce({
+                canceled: false,
+                assets: [{
+                    uri: 'file://image.jpg',
+                    type: 'image',
+                    width: 100,
+                    height: 200,
+                }],
+            });
+
+            const { result } = renderHook(() => useMediaPicker());
+
+            let picked: any;
+            await act(async () => {
+                picked = await result.current.pickMedia();
+            });
+
+            expect(picked).toEqual({
                 uri: 'file://image.jpg',
-                type: 'image',
+                mediaType: 'image',
                 width: 100,
                 height: 200,
-            }],
+                duration: undefined,
+            });
         });
 
-        const { result } = renderHook(() => useMediaPicker());
+        it('maps selected video to MediaResult', async () => {
+            (ImagePicker.launchImageLibraryAsync as jest.Mock).mockResolvedValueOnce({
+                canceled: false,
+                assets: [{
+                    uri: 'file://video.mp4',
+                    type: 'video',
+                    width: 640,
+                    height: 480,
+                    duration: 1234,
+                }],
+            });
 
-        let picked: any;
-        await act(async () => {
-            picked = await result.current.pickMedia();
-        });
+            const { result } = renderHook(() => useMediaPicker());
 
-        expect(picked).toEqual({
-            uri: 'file://image.jpg',
-            mediaType: 'image',
-            width: 100,
-            height: 200,
-            duration: undefined,
-        });
-    });
+            let picked: any;
+            await act(async () => {
+                picked = await result.current.pickMedia();
+            });
 
-    it('maps selected video to MediaResult', async () => {
-        (ImagePicker.launchImageLibraryAsync as jest.Mock).mockResolvedValueOnce({
-            canceled: false,
-            assets: [{
+            expect(picked).toEqual({
                 uri: 'file://video.mp4',
-                type: 'video',
+                mediaType: 'video',
                 width: 640,
                 height: 480,
                 duration: 1234,
-            }],
+            });
         });
 
-        const { result } = renderHook(() => useMediaPicker());
+        it('uses custom config options', async () => {
+            (ImagePicker.launchImageLibraryAsync as jest.Mock).mockResolvedValueOnce({
+                canceled: true,
+            });
 
-        let picked: any;
-        await act(async () => {
-            picked = await result.current.pickMedia();
-        });
+            const { result } = renderHook(() => useMediaPicker({
+                imageQuality: 0.5,
+                libraryVideoMaxDuration: 120,
+            }));
 
-        expect(picked).toEqual({
-            uri: 'file://video.mp4',
-            mediaType: 'video',
-            width: 640,
-            height: 480,
-            duration: 1234,
+            await act(async () => {
+                await result.current.pickMedia();
+            });
+
+            expect(ImagePicker.launchImageLibraryAsync).toHaveBeenCalledWith({
+                mediaTypes: ImagePicker.MediaTypeOptions.All,
+                quality: 0.5,
+                videoMaxDuration: 120,
+            });
         });
     });
 
-    it('alerts and returns false when camera permission denied', async () => {
-        const alertSpy = jest.spyOn(Alert, 'alert').mockImplementation(() => {});
-        (ImagePicker.requestCameraPermissionsAsync as jest.Mock).mockResolvedValueOnce({ status: 'denied' });
+    describe('requestCameraPermission', () => {
+        it('returns true when permission granted', async () => {
+            (ImagePicker.requestCameraPermissionsAsync as jest.Mock).mockResolvedValueOnce({ status: 'granted' });
 
-        const { result } = renderHook(() => useMediaPicker());
+            const { result } = renderHook(() => useMediaPicker());
 
-        let ok: any;
-        await act(async () => {
-            ok = await result.current.requestCameraPermission();
+            let ok: any;
+            await act(async () => {
+                ok = await result.current.requestCameraPermission();
+            });
+
+            expect(ok).toBe(true);
         });
 
-        expect(ok).toBe(false);
-        expect(alertSpy).toHaveBeenCalled();
+        it('alerts and returns false when camera permission denied', async () => {
+            const alertSpy = jest.spyOn(Alert, 'alert').mockImplementation(() => {});
+            (ImagePicker.requestCameraPermissionsAsync as jest.Mock).mockResolvedValueOnce({ status: 'denied' });
+
+            const { result } = renderHook(() => useMediaPicker());
+
+            let ok: any;
+            await act(async () => {
+                ok = await result.current.requestCameraPermission();
+            });
+
+            expect(ok).toBe(false);
+            expect(alertSpy).toHaveBeenCalledWith(
+                'Camera Permission',
+                'Please allow camera access to use this feature.'
+            );
+        });
+    });
+
+    describe('takePhoto', () => {
+        it('takes photo successfully', async () => {
+            (ImagePicker.requestCameraPermissionsAsync as jest.Mock).mockResolvedValueOnce({ status: 'granted' });
+            (ImagePicker.launchCameraAsync as jest.Mock).mockResolvedValueOnce({
+                canceled: false,
+                assets: [{
+                    uri: 'file://photo.jpg',
+                    type: 'image',
+                    width: 3024,
+                    height: 4032,
+                }],
+            });
+
+            const { result } = renderHook(() => useMediaPicker());
+
+            let photo: any;
+            await act(async () => {
+                photo = await result.current.takePhoto();
+            });
+
+            expect(photo).toEqual({
+                uri: 'file://photo.jpg',
+                mediaType: 'image',
+                width: 3024,
+                height: 4032,
+            });
+        });
+
+        it('returns null when permission denied', async () => {
+            jest.spyOn(Alert, 'alert').mockImplementation(() => {});
+            (ImagePicker.requestCameraPermissionsAsync as jest.Mock).mockResolvedValueOnce({ status: 'denied' });
+
+            const { result } = renderHook(() => useMediaPicker());
+
+            let photo: any;
+            await act(async () => {
+                photo = await result.current.takePhoto();
+            });
+
+            expect(photo).toBeNull();
+            expect(ImagePicker.launchCameraAsync).not.toHaveBeenCalled();
+        });
+
+        it('returns null when cancelled', async () => {
+            (ImagePicker.requestCameraPermissionsAsync as jest.Mock).mockResolvedValueOnce({ status: 'granted' });
+            (ImagePicker.launchCameraAsync as jest.Mock).mockResolvedValueOnce({
+                canceled: true,
+            });
+
+            const { result } = renderHook(() => useMediaPicker());
+
+            let photo: any;
+            await act(async () => {
+                photo = await result.current.takePhoto();
+            });
+
+            expect(photo).toBeNull();
+        });
+
+        it('uses custom image quality', async () => {
+            (ImagePicker.requestCameraPermissionsAsync as jest.Mock).mockResolvedValueOnce({ status: 'granted' });
+            (ImagePicker.launchCameraAsync as jest.Mock).mockResolvedValueOnce({ canceled: true });
+
+            const { result } = renderHook(() => useMediaPicker({ imageQuality: 0.9 }));
+
+            await act(async () => {
+                await result.current.takePhoto();
+            });
+
+            expect(ImagePicker.launchCameraAsync).toHaveBeenCalledWith({ quality: 0.9 });
+        });
+    });
+
+    describe('recordVideo', () => {
+        it('records video successfully', async () => {
+            (ImagePicker.requestCameraPermissionsAsync as jest.Mock).mockResolvedValueOnce({ status: 'granted' });
+            (ImagePicker.launchCameraAsync as jest.Mock).mockResolvedValueOnce({
+                canceled: false,
+                assets: [{
+                    uri: 'file://video.mp4',
+                    type: 'video',
+                    width: 1920,
+                    height: 1080,
+                    duration: 15000,
+                }],
+            });
+
+            const { result } = renderHook(() => useMediaPicker());
+
+            let video: any;
+            await act(async () => {
+                video = await result.current.recordVideo();
+            });
+
+            expect(video).toEqual({
+                uri: 'file://video.mp4',
+                mediaType: 'video',
+                width: 1920,
+                height: 1080,
+                duration: 15000,
+            });
+        });
+
+        it('returns null when permission denied', async () => {
+            jest.spyOn(Alert, 'alert').mockImplementation(() => {});
+            (ImagePicker.requestCameraPermissionsAsync as jest.Mock).mockResolvedValueOnce({ status: 'denied' });
+
+            const { result } = renderHook(() => useMediaPicker());
+
+            let video: any;
+            await act(async () => {
+                video = await result.current.recordVideo();
+            });
+
+            expect(video).toBeNull();
+        });
+
+        it('returns null when cancelled', async () => {
+            (ImagePicker.requestCameraPermissionsAsync as jest.Mock).mockResolvedValueOnce({ status: 'granted' });
+            (ImagePicker.launchCameraAsync as jest.Mock).mockResolvedValueOnce({ canceled: true });
+
+            const { result } = renderHook(() => useMediaPicker());
+
+            let video: any;
+            await act(async () => {
+                video = await result.current.recordVideo();
+            });
+
+            expect(video).toBeNull();
+        });
+
+        it('uses custom video max duration', async () => {
+            (ImagePicker.requestCameraPermissionsAsync as jest.Mock).mockResolvedValueOnce({ status: 'granted' });
+            (ImagePicker.launchCameraAsync as jest.Mock).mockResolvedValueOnce({ canceled: true });
+
+            const { result } = renderHook(() => useMediaPicker({ cameraVideoMaxDuration: 30 }));
+
+            await act(async () => {
+                await result.current.recordVideo();
+            });
+
+            expect(ImagePicker.launchCameraAsync).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    videoMaxDuration: 30,
+                    mediaTypes: ImagePicker.MediaTypeOptions.Videos,
+                })
+            );
+        });
+
+        it('handles null duration in video result', async () => {
+            (ImagePicker.requestCameraPermissionsAsync as jest.Mock).mockResolvedValueOnce({ status: 'granted' });
+            (ImagePicker.launchCameraAsync as jest.Mock).mockResolvedValueOnce({
+                canceled: false,
+                assets: [{
+                    uri: 'file://video.mp4',
+                    type: 'video',
+                    width: 1920,
+                    height: 1080,
+                    duration: null,
+                }],
+            });
+
+            const { result } = renderHook(() => useMediaPicker());
+
+            let video: any;
+            await act(async () => {
+                video = await result.current.recordVideo();
+            });
+
+            expect(video.duration).toBeUndefined();
+        });
+    });
+
+    describe('default config', () => {
+        it('uses default image quality of 0.7', async () => {
+            (ImagePicker.launchImageLibraryAsync as jest.Mock).mockResolvedValueOnce({ canceled: true });
+
+            const { result } = renderHook(() => useMediaPicker());
+
+            await act(async () => {
+                await result.current.pickMedia();
+            });
+
+            expect(ImagePicker.launchImageLibraryAsync).toHaveBeenCalledWith(
+                expect.objectContaining({ quality: 0.7 })
+            );
+        });
+
+        it('uses default library video max duration of 300', async () => {
+            (ImagePicker.launchImageLibraryAsync as jest.Mock).mockResolvedValueOnce({ canceled: true });
+
+            const { result } = renderHook(() => useMediaPicker());
+
+            await act(async () => {
+                await result.current.pickMedia();
+            });
+
+            expect(ImagePicker.launchImageLibraryAsync).toHaveBeenCalledWith(
+                expect.objectContaining({ videoMaxDuration: 300 })
+            );
+        });
+
+        it('uses default camera video max duration of 60', async () => {
+            (ImagePicker.requestCameraPermissionsAsync as jest.Mock).mockResolvedValueOnce({ status: 'granted' });
+            (ImagePicker.launchCameraAsync as jest.Mock).mockResolvedValueOnce({ canceled: true });
+
+            const { result } = renderHook(() => useMediaPicker());
+
+            await act(async () => {
+                await result.current.recordVideo();
+            });
+
+            expect(ImagePicker.launchCameraAsync).toHaveBeenCalledWith(
+                expect.objectContaining({ videoMaxDuration: 60 })
+            );
+        });
     });
 });

apps/mobile/src/__tests__/hooks/useMediaSaver.test.ts

@@ -0,0 +1,231 @@
+import { renderHook, act, waitFor } from '@testing-library/react-native';
+import { Alert } from 'react-native';
+import * as MediaLibrary from 'expo-media-library';
+import * as FileSystem from 'expo-file-system';
+import { useMediaSaver } from '@/hooks/useMediaSaver';
+
+// Mock expo-media-library
+jest.mock('expo-media-library', () => ({
+    usePermissions: jest.fn(),
+    createAssetAsync: jest.fn(),
+}));
+
+// Mock expo-file-system with all required methods
+jest.mock('expo-file-system', () => ({
+    readAsStringAsync: jest.fn(async () => ''),
+    downloadAsync: jest.fn(),
+    deleteAsync: jest.fn(),
+    cacheDirectory: 'file:///cache/',
+    EncodingType: {
+        Base64: 'base64',
+    },
+}));
+
+// Mock Alert
+jest.spyOn(Alert, 'alert').mockImplementation(() => {});
+
+describe('useMediaSaver', () => {
+    const mockRequestPermission = jest.fn();
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Default: permission granted
+        (MediaLibrary.usePermissions as jest.Mock).mockReturnValue([
+            { granted: true },
+            mockRequestPermission,
+        ]);
+        (MediaLibrary.createAssetAsync as jest.Mock).mockResolvedValue({ id: 'asset1' });
+        (FileSystem.downloadAsync as jest.Mock).mockResolvedValue({
+            uri: 'file:///cache/download_123.jpg',
+        });
+        (FileSystem.deleteAsync as jest.Mock).mockResolvedValue(undefined);
+    });
+
+    it('initializes with saving as false', () => {
+        const { result } = renderHook(() => useMediaSaver());
+
+        expect(result.current.saving).toBe(false);
+        expect(typeof result.current.saveMedia).toBe('function');
+    });
+
+    it('saves local image successfully', async () => {
+        const { result } = renderHook(() => useMediaSaver());
+
+        await act(async () => {
+            await result.current.saveMedia('file:///local/image.jpg', 'image');
+        });
+
+        expect(MediaLibrary.createAssetAsync).toHaveBeenCalledWith('file:///local/image.jpg');
+        expect(Alert.alert).toHaveBeenCalledWith('Saved', 'Image saved to your gallery.');
+        expect(result.current.saving).toBe(false);
+    });
+
+    it('saves local video successfully', async () => {
+        const { result } = renderHook(() => useMediaSaver());
+
+        await act(async () => {
+            await result.current.saveMedia('file:///local/video.mp4', 'video');
+        });
+
+        expect(MediaLibrary.createAssetAsync).toHaveBeenCalledWith('file:///local/video.mp4');
+        expect(Alert.alert).toHaveBeenCalledWith('Saved', 'Video saved to your gallery.');
+    });
+
+    it('downloads remote image before saving', async () => {
+        const { result } = renderHook(() => useMediaSaver());
+
+        await act(async () => {
+            await result.current.saveMedia('https://example.com/image.jpg', 'image');
+        });
+
+        expect(FileSystem.downloadAsync).toHaveBeenCalledWith(
+            'https://example.com/image.jpg',
+            expect.stringMatching(/download_\d+\.jpg$/)
+        );
+        expect(MediaLibrary.createAssetAsync).toHaveBeenCalledWith('file:///cache/download_123.jpg');
+        expect(FileSystem.deleteAsync).toHaveBeenCalledWith('file:///cache/download_123.jpg', { idempotent: true });
+    });
+
+    it('downloads remote video before saving', async () => {
+        (FileSystem.downloadAsync as jest.Mock).mockResolvedValue({
+            uri: 'file:///cache/download_123.mp4',
+        });
+
+        const { result } = renderHook(() => useMediaSaver());
+
+        await act(async () => {
+            await result.current.saveMedia('https://example.com/video.mp4', 'video');
+        });
+
+        expect(FileSystem.downloadAsync).toHaveBeenCalledWith(
+            'https://example.com/video.mp4',
+            expect.stringMatching(/download_\d+\.mp4$/)
+        );
+        expect(MediaLibrary.createAssetAsync).toHaveBeenCalledWith('file:///cache/download_123.mp4');
+    });
+
+    it('handles http URLs (upgrades to https internally)', async () => {
+        const { result } = renderHook(() => useMediaSaver());
+
+        await act(async () => {
+            await result.current.saveMedia('http://example.com/image.jpg', 'image');
+        });
+
+        // http URLs are also considered remote
+        expect(FileSystem.downloadAsync).toHaveBeenCalled();
+    });
+
+    it('requests permission when not granted', async () => {
+        (MediaLibrary.usePermissions as jest.Mock).mockReturnValue([
+            { granted: false },
+            mockRequestPermission,
+        ]);
+        mockRequestPermission.mockResolvedValue({ granted: true });
+
+        const { result } = renderHook(() => useMediaSaver());
+
+        await act(async () => {
+            await result.current.saveMedia('file:///local/image.jpg', 'image');
+        });
+
+        expect(mockRequestPermission).toHaveBeenCalled();
+        expect(MediaLibrary.createAssetAsync).toHaveBeenCalled();
+    });
+
+    it('shows alert and returns early when permission denied', async () => {
+        (MediaLibrary.usePermissions as jest.Mock).mockReturnValue([
+            { granted: false },
+            mockRequestPermission,
+        ]);
+        mockRequestPermission.mockResolvedValue({ granted: false });
+
+        const { result } = renderHook(() => useMediaSaver());
+
+        await act(async () => {
+            await result.current.saveMedia('file:///local/image.jpg', 'image');
+        });
+
+        expect(Alert.alert).toHaveBeenCalledWith(
+            'Permission required',
+            'Please allow access to your photo library to save media.'
+        );
+        expect(MediaLibrary.createAssetAsync).not.toHaveBeenCalled();
+        expect(result.current.saving).toBe(false);
+    });
+
+    it('handles save errors gracefully', async () => {
+        (MediaLibrary.createAssetAsync as jest.Mock).mockRejectedValue(new Error('Save failed'));
+
+        const { result } = renderHook(() => useMediaSaver());
+
+        await act(async () => {
+            await result.current.saveMedia('file:///local/image.jpg', 'image');
+        });
+
+        expect(Alert.alert).toHaveBeenCalledWith('Error', 'Failed to save media.');
+        expect(result.current.saving).toBe(false);
+    });
+
+    it('handles download errors gracefully', async () => {
+        (FileSystem.downloadAsync as jest.Mock).mockRejectedValue(new Error('Download failed'));
+
+        const { result } = renderHook(() => useMediaSaver());
+
+        await act(async () => {
+            await result.current.saveMedia('https://example.com/image.jpg', 'image');
+        });
+
+        expect(Alert.alert).toHaveBeenCalledWith('Error', 'Failed to save media.');
+        expect(result.current.saving).toBe(false);
+    });
+
+    it('sets saving to true during operation', async () => {
+        let savingDuringOperation = false;
+
+        (MediaLibrary.createAssetAsync as jest.Mock).mockImplementation(async () => {
+            // This would capture the saving state during the async operation
+            // but since we can't access result.current here synchronously,
+            // we'll test this differently
+            return { id: 'asset1' };
+        });
+
+        const { result } = renderHook(() => useMediaSaver());
+
+        const savePromise = act(async () => {
+            // Check saving is true after calling but before completion
+            const promise = result.current.saveMedia('file:///local/image.jpg', 'image');
+            // Can't reliably check intermediate state, so we just verify final state
+            await promise;
+        });
+
+        await savePromise;
+        expect(result.current.saving).toBe(false);
+    });
+
+    it('does not delete local files after saving', async () => {
+        const { result } = renderHook(() => useMediaSaver());
+
+        await act(async () => {
+            await result.current.saveMedia('file:///local/image.jpg', 'image');
+        });
+
+        expect(FileSystem.deleteAsync).not.toHaveBeenCalled();
+    });
+
+    it('cleans up downloaded file after saving remote URL', async () => {
+        (FileSystem.downloadAsync as jest.Mock).mockResolvedValue({
+            uri: 'file:///cache/download_123.jpg',
+        });
+
+        const { result } = renderHook(() => useMediaSaver());
+
+        await act(async () => {
+            await result.current.saveMedia('https://example.com/image.jpg', 'image');
+        });
+
+        expect(FileSystem.deleteAsync).toHaveBeenCalledWith(
+            'file:///cache/download_123.jpg',
+            { idempotent: true }
+        );
+    });
+});