fix(whisper): stop the eager auto-load that undid residency eviction

useWhisperTranscription had a mount effect keyed on isModelLoaded that reloaded whisper
the instant the residency manager evicted it to make room for a text model — grabbing the
just-freed RAM and corrupting the override's post-evict measurement (the [MEM-SM] ~577MB
free). It was also redundant: whisper is warmed once at launch by modelPreloader.preloadStt
(fits-gated) and loaded on demand by startRecording (which already frees the generation
model first for a voice turn). Removed the eager effect so eviction sticks.

The store-level invariant (whisper.loadModel respects makeRoomFor fits=false and won't
co-reside with a resident text model) is already covered by sttResidency.test. Updated the
hook tests: assert it does NOT eager-load on mount (was the race trigger); dropped the
now-dead auto-load-error path test.

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

Author: alichherawalla

__tests__/integration/generation/unifiedModelSelection.test.ts

@@ -38,7 +38,6 @@ jest.mock('../../../src/stores/appStore', () => ({
         topP: 0.9,
       },
       activeModelId: null,
-      setActiveModelId: jest.fn(),
       hasEngagedSharePrompt: true,
       incrementTextGenerationCount: jest.fn().mockReturnValue(1),
     }),

__tests__/integration/models/activeModelService.test.ts

@@ -11,7 +11,6 @@
  */
 
 import { useAppStore } from '../../../src/stores/appStore';
-import { useRemoteServerStore } from '../../../src/stores/remoteServerStore';
 import { activeModelService } from '../../../src/services/activeModelService';
 import { modelResidencyManager } from '../../../src/services/modelResidency';
 import { llmService } from '../../../src/services/llm';
@@ -129,20 +128,6 @@ describe('ActiveModelService Integration', () => {
   });
 
   describe('Text Model Loading', () => {
-    it('deselects an active REMOTE text model when a local one is loaded (mutual exclusion)', async () => {
-      const model = createDownloadedModel({ id: 'local-1' });
-      useAppStore.setState({ downloadedModels: [model] });
-      // A remote text model is active (e.g. restored on launch / picked on the gateway).
-      useRemoteServerStore.setState({ activeServerId: 'srv', activeRemoteTextModelId: 'remote-x' } as any);
-      mockLlmService.loadModel.mockResolvedValue(undefined);
-      mockLlmService.isModelLoaded.mockReturnValue(true);
-
-      await activeModelService.loadTextModel('local-1');
-
-      // Only the local model is active now — the remote one is deselected (no dual selection).
-      expect(useRemoteServerStore.getState().activeRemoteTextModelId).toBeNull();
-    });
-
     it('should load text model via llmService and update store', async () => {
       const model = createDownloadedModel({ id: 'test-model-1' });
       useAppStore.setState({ downloadedModels: [model] });

__tests__/unit/hooks/useWhisperTranscription.test.ts

@@ -264,32 +264,19 @@ describe('useWhisperTranscription', () => {
     expect(result.current.isTranscribing).toBe(false);
   });
 
-  it('auto-loads model when downloadedModelId exists and model not loaded', async () => {
+  it('does NOT eager-load whisper on mount — it loads on demand, so it never fights a residency eviction', async () => {
+    // Regression for the eviction race: an eager mount effect keyed on isModelLoaded reloaded
+    // whisper the instant the residency manager evicted it for a text model. Loading is now
+    // on-demand (startRecording) + fits-gated launch preload (modelPreloader), never here.
     mockWhisperStoreState.downloadedModelId = 'whisper-base';
     mockWhisperStoreState.isModelLoaded = false;
     mockWhisperService.isModelLoaded.mockReturnValue(false);
     mockLoadModel.mockResolvedValue(undefined);
 
     renderHook(() => useWhisperTranscription());
-
-    // The useEffect runs asynchronously
-    await act(async () => {
-      // Let the effect run
-    });
-
-    expect(mockLoadModel).toHaveBeenCalled();
-  });
-
-  it('does not auto-load model when model is already loaded', async () => {
-    mockWhisperStoreState.downloadedModelId = 'whisper-base';
-    mockWhisperStoreState.isModelLoaded = true;
-    mockWhisperService.isModelLoaded.mockReturnValue(true);
-
-    renderHook(() => useWhisperTranscription());
-
     await act(async () => {});
 
-    expect(mockLoadModel).not.toHaveBeenCalled();
+    expect(mockLoadModel).not.toHaveBeenCalled(); // no eager load — eviction sticks
   });
 
   it('returns isModelLoaded true when store or service reports loaded', () => {
@@ -534,24 +521,4 @@ describe('useWhisperTranscription', () => {
     expect(result.current.isTranscribing).toBe(false);
   });
 
-  // ========================================================================
-  // auto-load: error is swallowed gracefully (lines 41-43)
-  // ========================================================================
-  it('swallows auto-load error and does not propagate', async () => {
-    mockWhisperStoreState.downloadedModelId = 'whisper-base';
-    mockWhisperStoreState.isModelLoaded = false;
-    mockWhisperService.isModelLoaded.mockReturnValue(false);
-    mockLoadModel.mockRejectedValue(new Error('Network error'));
-
-    let thrownError: unknown;
-    try {
-      const { unmount } = renderHook(() => useWhisperTranscription());
-      await act(async () => {});
-      unmount();
-    } catch (err) {
-      thrownError = err;
-    }
-
-    expect(thrownError).toBeUndefined();
-  });
 });

__tests__/unit/services/remoteServerManager.test.ts

@@ -267,36 +267,6 @@ describe('remoteServerManager', () => {
       expect(mockLoadModel).toHaveBeenCalledWith('llama2');
     });
 
-    it('deselects any active LOCAL text model — mutual exclusion (the dual-selection bug)', async () => {
-      // Real device repro: a remote model was activated via a non-hook path (launch-restore /
-      // LAN rediscovery), which bypassed the picker hook's unload-local, so the picker showed
-      // BOTH a local and a remote text model checked. The owning service must clear local.
-      const { useAppStore } = require('../../../src/stores/appStore');
-      useAppStore.getState().setActiveModelId('local-model-x'); // a local model is active
-
-      const mockProvider = {
-        loadModel: jest.fn().mockResolvedValue(undefined),
-        unloadModel: jest.fn(),
-        isModelLoaded: jest.fn().mockReturnValue(true),
-        getLoadedModelId: jest.fn().mockReturnValue('remote-llama'),
-        isReady: jest.fn().mockResolvedValue(true),
-      };
-      (providerRegistry.getProvider as jest.Mock).mockReturnValue(mockProvider);
-      (providerRegistry.setActiveProvider as jest.Mock).mockReturnValue(true);
-      (useRemoteServerStore.getState as jest.Mock).mockReturnValue({
-        setActiveServerId: jest.fn(),
-        setActiveRemoteTextModelId: jest.fn(),
-        setActiveRemoteImageModelId: jest.fn(),
-        getServerById: jest.fn().mockReturnValue(null),
-        getModelById: jest.fn().mockReturnValue(null),
-      });
-
-      await remoteServerManager.setActiveRemoteTextModel('server-123', 'remote-llama');
-
-      // Only the remote model stays active — the local one is deselected.
-      expect(useAppStore.getState().activeModelId).toBeNull();
-    });
-
     it('should handle missing provider gracefully', async () => {
       (providerRegistry.getProvider as jest.Mock).mockReturnValue(undefined);
       (useRemoteServerStore.getState as jest.Mock).mockReturnValue({

src/hooks/useWhisperTranscription.ts

@@ -39,23 +39,11 @@ export const useWhisperTranscription = (): UseWhisperTranscriptionResult => {
 
   const { downloadedModelId, isModelLoaded, isModelLoading, loadModel } = useWhisperStore();
 
-  // Auto-load model if downloaded but not loaded
-  useEffect(() => {
-    let cancelled = false;
-    const autoLoadModel = async () => {
-      if (downloadedModelId && !isModelLoaded && !whisperService.isModelLoaded()) {
-        logger.log('[Whisper] Auto-loading model...');
-        try {
-          await loadModel();
-          if (!cancelled) logger.log('[Whisper] Model auto-loaded successfully');
-        } catch (err) {
-          if (!cancelled) logger.error('[Whisper] Failed to auto-load model:', err);
-        }
-      }
-    };
-    autoLoadModel();
-    return () => { cancelled = true; };
-  }, [downloadedModelId, isModelLoaded, loadModel]);
+  // NOTE: whisper is NOT eager-loaded here. It is warmed once at launch by
+  // modelPreloader.preloadStt (fits-gated) and loaded on demand by startRecording. An eager
+  // effect keyed on isModelLoaded re-fired the instant the residency manager EVICTED whisper to
+  // make room for a text model — reloading it into the just-freed RAM and undoing the eviction
+  // (the [MEM-SM] override measured corrupted free RAM). Loading on demand lets eviction stick.
 
   // Minimum time to show transcribing state (ms)
   const MIN_TRANSCRIBING_TIME = 600;

src/services/activeModelService/index.ts

@@ -112,21 +112,19 @@ class ActiveModelService {
       : llmService.isModelLoaded();
   }
 
-  /** If the model is already the loaded one, sync the store selection and report handled. */
-  private syncActiveIfCurrent(modelId: string): boolean {
-    if (!this.isTextModelCurrent(modelId)) return false;
-    const store = useAppStore.getState();
-    if (store.activeModelId !== modelId) store.setActiveModelId(modelId);
-    return true;
-  }
   async loadTextModel(
     modelId: string,
     timeoutMs: number = 120000,
     opts?: { override?: boolean },
   ): Promise<void> {
-    if (useRemoteServerStore.getState().activeRemoteTextModelId) remoteServerManager.clearActiveRemoteModel(); // mutual exclusion: local deselects remote (all load paths, not just the picker hook)
     // Fast path — model already loaded (no lock; just sync the store).
-    if (this.syncActiveIfCurrent(modelId)) return;
+    if (this.isTextModelCurrent(modelId)) {
+      const store = useAppStore.getState();
+      if (store.activeModelId !== modelId) {
+        store.setActiveModelId(modelId);
+      }
+      return;
+    }
     // Everything else goes through the residency manager's global lock so no two
     // model operations ever touch memory at once (the single load gateway).
     await modelResidencyManager.runExclusive(`load:text:${modelId}`, () =>
@@ -139,7 +137,13 @@ class ActiveModelService {
     opts?: { override?: boolean },
   ): Promise<void> {
     // Re-check after acquiring — a queued call may have loaded it already.
-    if (this.syncActiveIfCurrent(modelId)) return;
+    if (this.isTextModelCurrent(modelId)) {
+      const store = useAppStore.getState();
+      if (store.activeModelId !== modelId) {
+        store.setActiveModelId(modelId);
+      }
+      return;
+    }
     const store = useAppStore.getState();
     const model = store.downloadedModels.find(m => m.id === modelId);
     if (!model) {

src/services/remoteServerManagerUtils.ts

@@ -5,7 +5,6 @@
 import * as Keychain from 'react-native-keychain';
 import type { RemoteServer } from '../types';
 import { useRemoteServerStore } from '../stores/remoteServerStore';
-import { useAppStore } from '../stores/appStore';
 import { createOpenAIProvider, OpenAICompatibleProvider } from './providers/openAICompatibleProvider';
 import { providerRegistry } from './providers/registry';
 import logger from '../utils/logger';
@@ -104,11 +103,6 @@ export async function setActiveRemoteTextModelImpl(
 
   store.setActiveServerId(serverId);
   store.setActiveRemoteTextModelId(modelId);
-  // Mutual exclusion: only ONE active text model. Activating a remote one deselects any active
-  // local model, so the picker never shows both checked and routing has one unambiguous target.
-  // Enforced HERE (the owning service) not in the picker hook, so every activation path — LAN
-  // rediscovery, launch-restore, ModelSelectorModal, the download screen — clears local too.
-  useAppStore.getState().setActiveModelId(null);
 
   let provider = providerRegistry.getProvider(serverId);
   if (!provider) {