test(image-gen): GPU-path advice rule, advice card, and the 256 size floor

- imageGenAdvice unit: mnn-only; raiseSteps (<20), lowerSize (>256), raiseSize (<256 =
  garbage, the 128 case), quiet at the 256/20 sweet spot, no false raiseSize at width 0.
- ImageGenAdviceCard (RNTL): hidden off-mnn + at sweet spot; shows the right tip per
  setting, driving the real store + real rule.
- imageGenerationFlow: a stale 128 setting is floored to 256 before the native call; a
  valid 512 passes through unchanged.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: alichherawalla

__tests__/integration/generation/imageGenerationFlow.test.ts

@@ -1618,6 +1618,43 @@ describe('Image Generation Flow Integration', () => {
   // re-run the load forcing past the budget. Before the fix, imageGenerationService
   // stringified the typed OverridableMemoryError, so the override was never offered.
   // ============================================================================
+  describe('size floor (never generate at a garbage sub-256 resolution)', () => {
+    it('floors a stale 128 setting up to 256 before it reaches the native pipeline', async () => {
+      const imageModel = setupImageModelState();
+      // Simulate the on-device state: user had dragged size down to 128 (garbage for SD1.5).
+      useAppStore.setState({ settings: { ...useAppStore.getState().settings, imageWidth: 128, imageHeight: 128 } });
+      mockActiveModelService.getActiveModels.mockReturnValue({
+        text: { model: null, isLoaded: false, isLoading: false },
+        image: { model: imageModel, isLoaded: true, isLoading: false },
+      });
+
+      await imageGenerationService.generateImage({ prompt: 'a dog' });
+
+      expect(mockLocalDreamService.generateImage).toHaveBeenCalledWith(
+        expect.objectContaining({ width: 256, height: 256 }),
+        expect.any(Function),
+        expect.any(Function),
+      );
+    });
+
+    it('passes a valid 512 through unchanged', async () => {
+      const imageModel = setupImageModelState();
+      useAppStore.setState({ settings: { ...useAppStore.getState().settings, imageWidth: 512, imageHeight: 512 } });
+      mockActiveModelService.getActiveModels.mockReturnValue({
+        text: { model: null, isLoaded: false, isLoading: false },
+        image: { model: imageModel, isLoaded: true, isLoading: false },
+      });
+
+      await imageGenerationService.generateImage({ prompt: 'a dog' });
+
+      expect(mockLocalDreamService.generateImage).toHaveBeenCalledWith(
+        expect.objectContaining({ width: 512, height: 512 }),
+        expect.any(Function),
+        expect.any(Function),
+      );
+    });
+  });
+
   describe('Load Anyway override (overridable memory gate)', () => {
     beforeEach(() => useModelFailureStore.getState().clear());
 

__tests__/rntl/components/ImageGenAdviceCard.test.tsx

@@ -0,0 +1,57 @@
+/**
+ * ImageGenAdviceCard — GPU-path speed/quality guidance. Renders nothing off the mnn path
+ * or at good settings; shows the right tips (raise steps / lower size / raise size) when
+ * the live settings warrant it. Drives the REAL store + REAL advice rule.
+ */
+import React from 'react';
+import { render } from '@testing-library/react-native';
+
+jest.mock('react-native-vector-icons/Feather', () => 'Icon');
+
+import { ImageGenAdviceCard } from '../../../src/components/GenerationSettingsModal/ImageGenAdviceCard';
+import { useAppStore } from '../../../src/stores';
+
+const setup = (backend: string | undefined, imageSteps: number, imageWidth: number) => {
+  useAppStore.setState({
+    downloadedImageModels: backend
+      ? ([{ id: 'img', name: 'M', modelPath: '/m', backend, downloadedAt: '', size: 1 }] as any)
+      : ([] as any),
+    activeImageModelId: backend ? 'img' : null,
+    settings: { ...useAppStore.getState().settings, imageSteps, imageWidth, imageHeight: imageWidth },
+  });
+};
+
+describe('ImageGenAdviceCard', () => {
+  it('renders nothing on the NPU (qnn) path', () => {
+    setup('qnn', 8, 512);
+    const { queryByTestId } = render(<ImageGenAdviceCard />);
+    expect(queryByTestId('image-gen-advice')).toBeNull();
+  });
+
+  it('renders nothing at the sweet spot (mnn, 22 steps, 256)', () => {
+    setup('mnn', 22, 256);
+    const { queryByTestId } = render(<ImageGenAdviceCard />);
+    expect(queryByTestId('image-gen-advice')).toBeNull();
+  });
+
+  it('shows the raise-steps tip on the GPU path at low steps', () => {
+    setup('mnn', 8, 256);
+    const { getByTestId, queryByTestId } = render(<ImageGenAdviceCard />);
+    expect(getByTestId('image-gen-advice')).toBeTruthy();
+    expect(getByTestId('image-gen-advice-steps')).toBeTruthy();
+    expect(queryByTestId('image-gen-advice-size')).toBeNull();
+  });
+
+  it('shows the lower-size tip when too large (512)', () => {
+    setup('mnn', 22, 512);
+    const { getByTestId } = render(<ImageGenAdviceCard />);
+    expect(getByTestId('image-gen-advice-size')).toBeTruthy();
+  });
+
+  it('shows the raise-size (garbage) tip when below 256 (the 128 case)', () => {
+    setup('mnn', 22, 128);
+    const { getByTestId, queryByTestId } = render(<ImageGenAdviceCard />);
+    expect(getByTestId('image-gen-advice-raise-size')).toBeTruthy();
+    expect(queryByTestId('image-gen-advice-size')).toBeNull();
+  });
+});

__tests__/unit/utils/imageGenAdvice.test.ts

@@ -0,0 +1,54 @@
+/**
+ * getImageGenAdvice — the GPU-path (mnn) speed/quality guidance rule. Only the mnn path
+ * gets advice (NPU/CoreML are fast + fixed-shape). Encodes the on-device reality:
+ *  - <20 steps looks muddy,
+ *  - >256 is very slow on a mid-tier GPU,
+ *  - <256 is GARBAGE (SD1.5 below training res), not just smaller.
+ */
+import { getImageGenAdvice, QUALITY_STEP_FLOOR, SWEET_SPOT_SIZE } from '../../../src/utils/imageGenAdvice';
+
+describe('getImageGenAdvice', () => {
+  it('gives NO advice for the NPU (qnn) path', () => {
+    expect(getImageGenAdvice({ backend: 'qnn', steps: 8, width: 512 })).toEqual({
+      show: false, raiseSteps: false, lowerSize: false, raiseSize: false,
+    });
+  });
+
+  it('gives NO advice for CoreML (iOS ANE)', () => {
+    expect(getImageGenAdvice({ backend: 'coreml', steps: 4, width: 128 }).show).toBe(false);
+  });
+
+  it('recommends raising steps on the GPU path when below the quality floor', () => {
+    const a = getImageGenAdvice({ backend: 'mnn', steps: QUALITY_STEP_FLOOR - 1, width: SWEET_SPOT_SIZE });
+    expect(a.raiseSteps).toBe(true);
+    expect(a.show).toBe(true);
+  });
+
+  it('does not nag about steps at/above the quality floor', () => {
+    expect(getImageGenAdvice({ backend: 'mnn', steps: QUALITY_STEP_FLOOR, width: SWEET_SPOT_SIZE }).raiseSteps).toBe(false);
+  });
+
+  it('recommends LOWERING size for speed when above the sweet spot', () => {
+    const a = getImageGenAdvice({ backend: 'mnn', steps: 22, width: 512 });
+    expect(a.lowerSize).toBe(true);
+    expect(a.raiseSize).toBe(false);
+    expect(a.show).toBe(true);
+  });
+
+  it('recommends RAISING size when below 256 (garbage, not "smaller") — the 128 case', () => {
+    const a = getImageGenAdvice({ backend: 'mnn', steps: 22, width: 128 });
+    expect(a.raiseSize).toBe(true);
+    expect(a.lowerSize).toBe(false);
+    expect(a.show).toBe(true);
+  });
+
+  it('is quiet at the sweet spot (256, >=20 steps)', () => {
+    expect(getImageGenAdvice({ backend: 'mnn', steps: 22, width: SWEET_SPOT_SIZE })).toEqual({
+      show: false, raiseSteps: false, lowerSize: false, raiseSize: false,
+    });
+  });
+
+  it('a zero/unknown width does not falsely trigger raiseSize', () => {
+    expect(getImageGenAdvice({ backend: 'mnn', steps: 22, width: 0 }).raiseSize).toBe(false);
+  });
+});