feat: image generation offload - run the Mac's image models from the phone

__tests__/integration/generation/unifiedModelSelection.test.ts

@@ -198,8 +198,12 @@ describe('Unified Model Selection', () => {
       await remoteServerManager.setActiveRemoteImageModel(serverId, 'llava');
 
       expect(useRemoteServerStore.getState().activeRemoteImageModelId).toBe('llava');
-      expect(useRemoteServerStore.getState().activeServerId).toBe(serverId);
-      expect(mockLoadModel).toHaveBeenCalledWith('llava');
+      // The image selection carries its OWN server field and never re-routes text:
+      // the shared activeServerId stays untouched, and the shared chat provider is
+      // never loaded (doing so overwrote the text model id - the clobber bug).
+      expect(useRemoteServerStore.getState().activeRemoteImageServerId).toBe(serverId);
+      expect(useRemoteServerStore.getState().activeServerId).not.toBe(serverId);
+      expect(mockLoadModel).not.toHaveBeenCalled();
     });
   });
 

__tests__/integration/stores/remoteServerDiscovery.test.ts

@@ -537,7 +537,7 @@ describe('remoteServerDiscovery integration', () => {
   // =========================================================================
 
   describe('gateway kind filtering', () => {
-    it('keeps only chat/vision models and drops image, speech, and transcription', async () => {
+    it('keeps chat/vision as text and image as image; drops speech and transcription', async () => {
       addServer({ id: 'srv-gw', endpoint: 'http://192.168.1.44:7878' }); // NOSONAR
 
       mockFetch.mockImplementation((url: string) => {
@@ -562,8 +562,10 @@ describe('remoteServerDiscovery integration', () => {
       const models = await useRemoteServerStore.getState().discoverModels('srv-gw');
 
       const ids = models.map((m) => m.id).sort((a, b) => a.localeCompare(b));
-      expect(ids).toEqual(['gemma-3', 'qwen3-vl']);
-      expect(models.some((m) => m.id === 'sdxl')).toBe(false);
+      expect(ids).toEqual(['gemma-3', 'qwen3-vl', 'sdxl']);
+      // Image models ride the same discovery, tagged so the pickers split on modality.
+      expect(models.find((m) => m.id === 'sdxl')?.modality).toBe('image');
+      expect(models.find((m) => m.id === 'gemma-3')?.modality).toBe('text');
       expect(models.some((m) => m.id === 'kokoro')).toBe(false);
       expect(models.some((m) => m.id === 'whisper-base')).toBe(false);
     });

__tests__/rntl/components/McpAddServerSheet.test.tsx

@@ -78,6 +78,13 @@ maybe('McpAddServerSheet', () => {
     expect(props.onAddCustom).toHaveBeenCalledTimes(1);
   });
 
+  it('has no "Scan a desktop QR" button - a paired desktop grants tools over the mesh', () => {
+    // The QR-scan pairing was removed: a paired desktop now hands its tools over
+    // the sync mesh, so there is nothing to scan from the add sheet.
+    const { queryByTestId } = render(<McpAddServerSheet {...baseProps()} />);
+    expect(queryByTestId('scan-desktop-qr')).toBeNull();
+  });
+
   it('lists the preset rows', () => {
     const props = baseProps();
     const { getByTestId } = render(<McpAddServerSheet {...props} />);

__tests__/rntl/components/McpServersScreen.test.tsx

@@ -45,7 +45,7 @@ jest.mock('@react-navigation/native', () => {
 jest.mock('../../../src/services/tools/extensions', () => ({ getToolExtensions: () => [] }));
 
 const mockAppState = { settings: { enabledTools: [] as string[] }, updateSettings: jest.fn(), activeModelId: undefined, downloadedModels: [] as any[] };
-const mockRemoteState = { activeRemoteTextModelId: 'remote-1' };
+const mockRemoteState = { activeRemoteTextModelId: 'remote-1', servers: [] as any[] };
 jest.mock('../../../src/stores', () => ({
   useAppStore: (selector?: any) => (selector ? selector(mockAppState) : mockAppState),
   useRemoteServerStore: (selector?: any) => (selector ? selector(mockRemoteState) : mockRemoteState),
@@ -55,6 +55,10 @@ jest.mock('../../../pro/mcp/mcpService', () => ({
   connectServer: jest.fn(), disconnectServer: jest.fn(), signOutServer: jest.fn(),
 }));
 
+// The paired-desktops tools section pulls in the sync store + grant service (→ syncService,
+// which does not load under jest). This suite is about the MCP server cards, so stub it out.
+jest.mock('../../../pro/ui/CompanionToolsSection', () => ({ CompanionToolsSection: () => null }));
+
 type ScreenModule = typeof import('../../../pro/ui/McpServersScreen');
 type StoreModule = typeof import('../../../pro/mcp/mcpStore');
 

__tests__/rntl/components/companionToolsSection.test.tsx

@@ -0,0 +1,84 @@
+/**
+ * Integration (RNTL): CompanionToolsSection - the single home for desktop tools.
+ *
+ * Proves the moved grant: paired desktops (only desktops) appear in Pro tools with a
+ * switch that reflects whether their tools are connected here (grantedByDeviceId), and
+ * flipping one calls requestTools(deviceId, next) - the same mesh request the old
+ * Devices-row toggle sent. Loaded via a computed path so it skips where pro/ is absent.
+ */
+
+import React from 'react';
+import { render, fireEvent } from '@testing-library/react-native';
+
+jest.mock('react-native-vector-icons/Feather', () => {
+  const { Text } = require('react-native');
+  return ({ name, ...props }: any) => <Text {...props}>{name}</Text>;
+});
+
+jest.mock('../../../src/theme', () => ({
+  useTheme: () => ({
+    colors: {
+      text: '#000', textMuted: '#999', primary: '#1DB954', surface: '#F5F5F5', border: '#E0E0E0',
+    },
+  }),
+}));
+
+const mockState: { knownDevices: unknown[]; servers: unknown[] } = { knownDevices: [], servers: [] };
+const mockRequestTools = jest.fn();
+
+jest.mock('../../../pro/sync/syncStore', () => ({
+  useSyncStore: (selector: (s: unknown) => unknown) =>
+    selector({ knownDevices: mockState.knownDevices }),
+}));
+jest.mock('../../../pro/mcp/mcpStore', () => ({
+  useMcpStore: (selector: (s: unknown) => unknown) => selector({ servers: mockState.servers }),
+}));
+jest.mock('../../../pro/mcp/mcpToolGrantService', () => ({
+  requestTools: (...args: unknown[]) => mockRequestTools(...args),
+}));
+
+type Mod = typeof import('../../../pro/ui/CompanionToolsSection');
+function load(): Mod | null {
+  try {
+    return require(['..', '..', '..', 'pro', 'ui', 'CompanionToolsSection'].join('/'));
+  } catch {
+    return null;
+  }
+}
+
+const mod = load();
+const maybe = mod ? describe : describe.skip;
+
+maybe('CompanionToolsSection', () => {
+  const { CompanionToolsSection } = mod!;
+
+  beforeEach(() => {
+    mockState.knownDevices = [];
+    mockState.servers = [];
+    mockRequestTools.mockClear();
+  });
+
+  it('lists only desktop peers, reflects the grant, and toggles via requestTools', () => {
+    mockState.knownDevices = [
+      { id: 'mac1', name: 'My Mac', platform: 'macos' },
+      { id: 'phone1', name: 'My Phone', platform: 'ios' },
+    ];
+    mockState.servers = [{ id: 's1', grantedByDeviceId: 'mac1' }];
+
+    const { getByTestId, queryByTestId } = render(<CompanionToolsSection />);
+    // Desktop shows; a phone peer (serves no tools) is filtered out.
+    expect(getByTestId('companion-tools-mac1')).toBeTruthy();
+    expect(queryByTestId('companion-tools-phone1')).toBeNull();
+
+    const sw = getByTestId('companion-tools-switch-mac1');
+    expect(sw.props.value).toBe(true); // granted -> on
+    fireEvent(sw, 'valueChange', false);
+    expect(mockRequestTools).toHaveBeenCalledWith('mac1', false);
+  });
+
+  it('renders nothing when there are no paired desktops', () => {
+    mockState.knownDevices = [{ id: 'phone1', name: 'Phone', platform: 'android' }];
+    const { toJSON } = render(<CompanionToolsSection />);
+    expect(toJSON()).toBeNull();
+  });
+});

__tests__/rntl/components/pairingCodeSheet.test.tsx

@@ -0,0 +1,120 @@
+/**
+ * Integration (RNTL): PairingCodeSheet scan-to-pair.
+ *
+ * Guards the approved behavior change: a paired-code sheet can be filled by scanning
+ * the other device's QR, not just by typing. A decoded QR carrying a valid pairing
+ * code lands on the SAME onPair (syncService.pair) as the typed path, and a QR that
+ * is not a pairing code is ignored so the scanner keeps looking.
+ *
+ * Lives in the private pro/ submodule, loaded via a computed path so the suite skips
+ * in open-core CI where pro/ is absent.
+ */
+
+import React from 'react';
+import { render, fireEvent, act } from '@testing-library/react-native';
+
+jest.mock('react-native-vector-icons/Feather', () => {
+  const { Text } = require('react-native');
+  return ({ name, ...props }: any) => <Text {...props}>{name}</Text>;
+});
+
+// The sheet is a modal wrapper; render its children inline (respecting `visible`, as
+// the real one does) so the test can drive the content and observe it hiding while
+// the scanner is open.
+jest.mock('@offgrid/core/components/AppSheet', () => ({
+  AppSheet: ({ visible, children }: { visible: boolean; children: React.ReactNode }) =>
+    visible ? children : null,
+}));
+
+jest.mock('../../../src/theme', () => {
+  const colors = {
+    text: '#000', textMuted: '#999', primary: '#1DB954', error: '#F00',
+    background: '#FFF', surface: '#F5F5F5', border: '#E0E0E0',
+  };
+  const shadows = { small: {}, medium: {}, large: {} };
+  return {
+    useTheme: () => ({ colors, shadows, isDark: false }),
+    useThemedStyles: (fn: any) => fn(colors, shadows),
+  };
+});
+
+// vision-camera is globally stubbed in jest.setup; capture the scan config here so
+// the test can simulate a decoded QR frame.
+const visionCamera = require('react-native-vision-camera');
+let scanConfig: { onCodeScanned: (codes: { value?: string }[]) => void } | null = null;
+
+type SheetModule = typeof import('../../../pro/ui/SyncScreen/PairingCodeSheet');
+
+function load(): SheetModule | null {
+  try {
+    return require(['..', '..', '..', 'pro', 'ui', 'SyncScreen', 'PairingCodeSheet'].join('/'));
+  } catch {
+    return null;
+  }
+}
+
+const mod = load();
+const maybe = mod ? describe : describe.skip;
+
+// A valid code: every character is in the pairing alphabet.
+const VALID_QR = 'ABCD2345';
+
+maybe('PairingCodeSheet scan-to-pair', () => {
+  const { PairingCodeSheet } = mod!;
+
+  const baseProps = () => ({
+    visible: true,
+    deviceName: 'Studio Mac',
+    confirmLabel: 'Pair',
+    testIDPrefix: 'sync-test',
+    onClose: jest.fn(),
+    onPair: jest.fn().mockResolvedValue(undefined),
+  });
+
+  beforeEach(() => {
+    scanConfig = null;
+    jest.spyOn(visionCamera, 'useCodeScanner').mockImplementation((cfg: any) => {
+      scanConfig = cfg;
+      return cfg;
+    });
+  });
+
+  it('offers a Scan button that opens the camera scanner', () => {
+    const { getByTestId, queryByText, getByText } = render(
+      <PairingCodeSheet {...baseProps()} />,
+    );
+    expect(queryByText('Camera access needed')).toBeNull();
+    fireEvent.press(getByTestId('sync-test-scan'));
+    // Global vision-camera mock reports no permission, so the scanner asks for it -
+    // proof the scanner surface mounted.
+    expect(getByText('Camera access needed')).toBeTruthy();
+  });
+
+  it('hides the pairing sheet while the scanner is open (one modal at a time)', () => {
+    // iOS presents one modal at a time; the sheet must yield so the scanner can show.
+    const { getByTestId, queryByTestId } = render(<PairingCodeSheet {...baseProps()} />);
+    expect(queryByTestId('sync-test-input')).toBeTruthy();
+    fireEvent.press(getByTestId('sync-test-scan'));
+    expect(queryByTestId('sync-test-input')).toBeNull();
+  });
+
+  it('pairs from a scanned QR via the same onPair as typing', async () => {
+    const props = baseProps();
+    const { getByTestId } = render(<PairingCodeSheet {...props} />);
+    fireEvent.press(getByTestId('sync-test-scan'));
+    await act(async () => {
+      scanConfig!.onCodeScanned([{ value: VALID_QR }]);
+    });
+    expect(props.onPair).toHaveBeenCalledWith(VALID_QR);
+  });
+
+  it('ignores a QR that is not a pairing code', async () => {
+    const props = baseProps();
+    const { getByTestId } = render(<PairingCodeSheet {...props} />);
+    fireEvent.press(getByTestId('sync-test-scan'));
+    await act(async () => {
+      scanConfig!.onCodeScanned([{ value: 'https://example.com/not-a-code' }]);
+    });
+    expect(props.onPair).not.toHaveBeenCalled();
+  });
+});

__tests__/unit/hooks/useEjectAllModels.test.ts

@@ -41,7 +41,7 @@ const nothingActive = (): void => {
   app.setActiveImageModelId(null);
   const remote = useRemoteServerStore.getState();
   remote.setActiveRemoteTextModelId(null);
-  remote.setActiveRemoteImageModelId(null);
+  remote.setActiveRemoteImageModel(null, null);
 };
 
 beforeEach(() => {
@@ -63,7 +63,7 @@ describe('useEjectAllModels', () => {
     ],
     [
       'a remote image model',
-      (): void => useRemoteServerStore.getState().setActiveRemoteImageModelId('r2'),
+      (): void => useRemoteServerStore.getState().setActiveRemoteImageModel('srv-1', 'r2'),
     ],
   ])('offers the eject when the only thing loaded is %s', (_what, load) => {
     // Each of the four enables it independently. An `||` chain that dropped one would silently strand the user

__tests__/unit/hooks/useHomeScreen.test.ts

@@ -415,7 +415,8 @@ describe('useHomeScreen', () => {
         discoveredModels: { 'server-1': [remoteImgModel] },
         activeRemoteTextModelId: null,
         activeRemoteImageModelId: 'img-remote-1',
-        activeServerId: 'server-1',
+        activeRemoteImageServerId: 'server-1',
+        activeServerId: null,
       }; return sel ? sel(st) : st; });
       const { result } = renderHook(() => useHomeScreen(mockNavigation));
       expect(result.current.activeImageModel).toEqual(remoteImgModel);