chore(sonar): clear all 27 SonarCloud PR issues

All on PR-changed code (leak period). No behaviour change — gated by tsc + full suite (7741).
- S7763 (11): re-export patterns → `export … from` (useChatScreen, CustomAlert, downloadStore),
  keeping internally-used symbols as normal imports.
- S3863 (2): merged the duplicate `./types` import in imageDownloadQnn.
- S4782 (1): extracted a named `RemoteCaps` type in engines.ts (drops the indexed-access `undefined`).
- S3776 (2 CRITICAL): reduced cognitive complexity — handleRetryMessageFn split into
  retryFromUserMessage/retryFromAssistantMessage helpers; parseThinkingContent split into
  parseGemmaThinking/parseChannelThinking/parseThinkTags (behavior-preserving, contract tests green).
- S3358 (1): killed the nested ternary via assistantRetryKind() helper.
- S6594 (7): `content.match(/re/)` → `/re/.exec(content)` (non-global, same semantics).
- S7780 (3): String.raw for the regex-building template strings.
- S5976 (1): parameterized the 3 platform-floor residency tests with it.each (real seam, real outcome).

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

Author: alichherawalla

__tests__/unit/services/modelResidency.test.ts

@@ -794,43 +794,24 @@ describe('ModelResidencyManager', () => {
       const originalOS = RN.Platform.OS;
       afterEach(() => { RN.Platform.OS = originalOS; });
 
-      it('ANDROID: a ~3.7GB dirty model that leaves ~800MB physical LOADS (was refused by the iOS 1200 floor)', async () => {
-        RN.Platform.OS = 'android';
+      // All three share the same real seam (makeRoomFor with override on a dirty model, 4500MB
+      // physical); only platform + model size differ, driving a different floor verdict. Physical
+      // is always the guard — no swap credit — so an oversized dirty model is refused on both.
+      it.each([
+        { os: 'android', sizeMB: 3700, expected: true, why: 'leaves 800MB > 700 android floor → LOADS (the 12GB-phone case)' },
+        { os: 'android', sizeMB: 5235, expected: false, why: '4500-5235 negative → refused (the E4B OOM guard, no swap credit)' },
+        { os: 'ios', sizeMB: 3700, expected: false, why: 'leaves 800MB < 1200 iOS jetsam floor → refused' },
+      ])('$os: a $sizeMB MB dirty model → fits=$expected ($why)', async ({ os, sizeMB, expected }) => {
+        RN.Platform.OS = os;
         modelResidencyManager.setBudgetOverrideMB(null);
         jest.spyOn(hardwareService, 'refreshMemoryInfo').mockResolvedValue(undefined as never);
         jest.spyOn(hardwareService, 'getTotalMemoryGB').mockReturnValue(12);
         jest.spyOn(hardwareService, 'getAvailableMemoryGB').mockReturnValue(4.5); // ~4500MB physical
         const { fits } = await modelResidencyManager.makeRoomFor(
-          { key: 'text', type: 'text', sizeMB: 3700, dirtyMemory: true }, // 4500-3700=800 > 700 android floor
+          { key: 'text', type: 'text', sizeMB, dirtyMemory: true },
           { override: true },
         );
-        expect(fits).toBe(true); // loads on Android (800 > 700) — the user's 12GB-phone case
-      });
-
-      it('ANDROID: an oversized dirty model that exceeds PHYSICAL is still refused (the OOM guard, no swap credit)', async () => {
-        RN.Platform.OS = 'android';
-        modelResidencyManager.setBudgetOverrideMB(null);
-        jest.spyOn(hardwareService, 'refreshMemoryInfo').mockResolvedValue(undefined as never);
-        jest.spyOn(hardwareService, 'getTotalMemoryGB').mockReturnValue(12);
-        jest.spyOn(hardwareService, 'getAvailableMemoryGB').mockReturnValue(4.5);
-        const { fits } = await modelResidencyManager.makeRoomFor(
-          { key: 'text', type: 'text', sizeMB: 5235, dirtyMemory: true }, // 4500-5235 = negative → refuse (the E4B OOM case)
-          { override: true },
-        );
-        expect(fits).toBe(false); // refused — a 5.2GB dirty model can't fit ~4.5GB physical (would OOM)
-      });
-
-      it('iOS: the same ~3.7GB dirty model is REFUSED (full jetsam floor stands — no user swap)', async () => {
-        RN.Platform.OS = 'ios';
-        modelResidencyManager.setBudgetOverrideMB(null);
-        jest.spyOn(hardwareService, 'refreshMemoryInfo').mockResolvedValue(undefined as never);
-        jest.spyOn(hardwareService, 'getTotalMemoryGB').mockReturnValue(12);
-        jest.spyOn(hardwareService, 'getAvailableMemoryGB').mockReturnValue(4.5);
-        const { fits } = await modelResidencyManager.makeRoomFor(
-          { key: 'text', type: 'text', sizeMB: 3700, dirtyMemory: true }, // 4500-3700=800 < 1200 iOS floor
-          { override: true },
-        );
-        expect(fits).toBe(false); // iOS unchanged — 800 < 1200 jetsam floor
+        expect(fits).toBe(expected);
       });
     });
   });

src/components/CustomAlert.tsx

@@ -13,16 +13,11 @@ import { SPACING, TYPOGRAPHY } from '../constants';
 // AlertState + its factories are pure and live in utils/alertState so non-UI code can build an
 // alert state without importing this component (no-backward-layering-core). Re-exported here so
 // existing `from '../components/CustomAlert'` importers are unchanged.
-import {
-  AlertButton,
-  AlertState,
-  initialAlertState,
-  showAlert,
-  hideAlert,
-} from '../utils/alertState';
+import { AlertButton } from '../utils/alertState';
 
-export type { AlertButton, AlertState };
-export { initialAlertState, showAlert, hideAlert };
+export type { AlertButton };
+export type { AlertState } from '../utils/alertState';
+export { initialAlertState, showAlert, hideAlert } from '../utils/alertState';
 
 export interface CustomAlertProps {
   visible: boolean;

src/screens/ChatScreen/useChatMessageHandlers.ts

@@ -21,6 +21,38 @@ type RetryParams = {
   setDebugInfo: SetState<any>;
 };
 
+/** Recorded modality when retrying an ASSISTANT message: its own output is the fact (an image
+ *  attachment → image turn); otherwise it's a text turn when it had a preceding user message. */
+function assistantRetryKind(message: Message, prevUser: Message | null): TurnKind | undefined {
+  if (messageHasImageOutput(message)) return 'image';
+  return prevUser ? 'text' : undefined;
+}
+
+/** Shared context for the retry-branch helpers (bundled so each stays within the param limit). */
+type RetryCtx = { message: Message; genDeps: GenerationDeps; p: RetryParams; convId: string; msgs: Message[] };
+
+/** Retry from a USER message: read the turn's recorded modality BEFORE deleting the reply that
+ *  carries it, so resend re-runs the SAME pipeline (deterministic) instead of re-classifying. */
+async function retryFromUserMessage({ message, genDeps, p, convId, msgs }: RetryCtx): Promise<void> {
+  const idx = msgs.findIndex((m: Message) => m.id === message.id);
+  const recordedKind = recordedTurnKind(msgs, message.id);
+  logger.log(`[RESEND-SM] retry user msg idx=${idx} willDelete=${idx !== -1 && idx < msgs.length - 1} recordedKind=${recordedKind ?? 'none'}`);
+  if (idx !== -1 && idx < msgs.length - 1) p.deleteMessagesAfter(convId, message.id);
+  await regenerateResponseFn(genDeps, { setDebugInfo: p.setDebugInfo, userMessage: message, recordedKind });
+}
+
+/** Retry from an ASSISTANT message: regenerate the preceding user turn with the recorded kind. */
+async function retryFromAssistantMessage({ message, genDeps, p, convId, msgs }: RetryCtx): Promise<void> {
+  const idx = msgs.findIndex((m: Message) => m.id === message.id);
+  const prev = idx > 0 ? msgs.slice(0, idx).reverse().find((m: Message) => m.role === 'user') ?? null : null;
+  const recordedKind = assistantRetryKind(message, prev);
+  logger.log(`[RESEND-SM] retry assistant msg idx=${idx} prevUser=${prev?.id ?? 'none'} recordedKind=${recordedKind ?? 'none'}`);
+  if (prev) {
+    p.deleteMessagesAfter(convId, prev.id);
+    await regenerateResponseFn(genDeps, { setDebugInfo: p.setDebugInfo, userMessage: prev, recordedKind });
+  }
+}
+
 export async function handleRetryMessageFn(
   message: Message, genDeps: GenerationDeps, p: RetryParams,
 ): Promise<void> {
@@ -39,25 +71,9 @@ export async function handleRetryMessageFn(
   if (!p.activeConversationId) { logger.log('[RESEND-SM] retry BAIL: no conv'); return; }
   // Stop any in-flight TTS before deleting messages (no-op without pro audio)
   callHook(HOOKS.audioStop);
-  if (message.role === 'user') {
-    const idx = msgs.findIndex((m: Message) => m.id === message.id);
-    // Read the turn's recorded modality BEFORE deleting the reply that carries it, so resend
-    // re-runs the SAME pipeline (deterministic) instead of re-classifying — the image-resend fix.
-    const recordedKind = recordedTurnKind(msgs, message.id);
-    logger.log(`[RESEND-SM] retry user msg idx=${idx} willDelete=${idx !== -1 && idx < msgs.length - 1} recordedKind=${recordedKind ?? 'none'}`);
-    if (idx !== -1 && idx < msgs.length - 1) p.deleteMessagesAfter(p.activeConversationId, message.id);
-    await regenerateResponseFn(genDeps, { setDebugInfo: p.setDebugInfo, userMessage: message, recordedKind });
-  } else {
-    const idx = msgs.findIndex((m: Message) => m.id === message.id);
-    const prev = idx > 0 ? msgs.slice(0, idx).reverse().find((m: Message) => m.role === 'user') : null;
-    // The retried assistant message IS the turn's reply — its output determines the kind directly.
-    const recordedKind: TurnKind | undefined = messageHasImageOutput(message) ? 'image' : (prev ? 'text' : undefined);
-    logger.log(`[RESEND-SM] retry assistant msg idx=${idx} prevUser=${prev?.id ?? 'none'} recordedKind=${recordedKind ?? 'none'}`);
-    if (prev) {
-      p.deleteMessagesAfter(p.activeConversationId, prev.id);
-      await regenerateResponseFn(genDeps, { setDebugInfo: p.setDebugInfo, userMessage: prev, recordedKind });
-    }
-  }
+  const ctx: RetryCtx = { message, genDeps, p, convId: p.activeConversationId, msgs };
+  if (message.role === 'user') await retryFromUserMessage(ctx);
+  else await retryFromAssistantMessage(ctx);
 }
 
 type EditParams = {

src/screens/ChatScreen/useChatScreen.ts

@@ -18,15 +18,16 @@ import { RootStackParamList } from '../../navigation/types';
 import { ensureModelLoadedFn, ensureTextModelForChatFn, handleModelSelectFn, handleUnloadModelFn, initiateModelLoad, useChatImageModelEffects, useChatModelStateSync } from './useChatModelActions';
 import { startGenerationFn, handleSendFn, handleStopFn, handleSelectProjectFn, dispatchGenerationFn } from './useChatGenerationActions';
 import { handleRetryMessageFn, handleEditMessageFn, handleDeleteConversationFn, handleGenerateImageFromMsgFn } from './useChatMessageHandlers';
-import { getDisplayMessages, getPlaceholderText, ChatMessageItem } from './types';
+import { getDisplayMessages } from './types';
 import { saveImageToGallery } from './useSaveImage';
 import {
   isSuspiciousRecoveredImageModel,
   isSuspiciousRecoveredTextModel,
 } from '../../utils/modelSelectorFilters';
 
-export type { AlertState, ChatMessageItem };
-export {  getPlaceholderText };
+export type { AlertState };
+export type { ChatMessageItem } from './types';
+export { getPlaceholderText } from './types';
 
 type ChatScreenRouteProp = RouteProp<RootStackParamList, 'Chat'>;
 

src/screens/ModelsScreen/imageDownloadQnn.ts

@@ -1,6 +1,5 @@
 import { hideAlert, showAlert } from '../../components/CustomAlert';
-import { ImageModelDescriptor } from './types';
-import { ImageDownloadDeps } from './types';
+import { ImageModelDescriptor, ImageDownloadDeps } from './types';
 
 export function getQnnWarningMessage(
   modelInfo: ImageModelDescriptor,

src/services/engines.ts

@@ -16,10 +16,13 @@ export interface EngineCapabilities {
 }
 
 /** Runtime inputs for deriveEngineCapabilities — passed explicitly so the rule is pure/testable. */
+/** A remote model's declared capabilities (single named type so callers don't index CapabilityInputs). */
+export type RemoteCaps = { supportsVision?: boolean; supportsToolCalling?: boolean; supportsThinking?: boolean } | null;
+
 export interface CapabilityInputs {
   /** A remote (gateway) model is active — its declared capabilities win. */
   isRemote: boolean;
-  remoteCaps?: { supportsVision?: boolean; supportsToolCalling?: boolean; supportsThinking?: boolean } | null;
+  remoteCaps?: RemoteCaps;
   /** The active LOCAL model's engine ('litert' | 'llama' | ...) and LiteRT capability flags. */
   engine?: string;
   liteRTVision?: boolean;
@@ -113,7 +116,7 @@ export function isModelReady(model: { engine?: string; filePath?: string } | nul
  */
 export function activeTextCapabilities(i: {
   isRemote: boolean;
-  remoteCaps?: CapabilityInputs['remoteCaps'];
+  remoteCaps?: RemoteCaps;
   model: DownloadedModel | null | undefined;
 }): EngineCapabilities {
   const litert = i.model && isLiteRTModel(i.model) ? i.model : null;

src/stores/downloadStore.ts

@@ -4,17 +4,11 @@ import logger from '../utils/logger';
 // The status classification + DownloadEntry shape live in a PURE util so pure consumers can use
 // them without depending on this store (utils-stay-pure). Re-exported here for back-compat — every
 // existing `from '../stores/downloadStore'` importer of these keeps working unchanged.
-import {
-  DownloadStatus,
-  ModelType,
-  DownloadEntry,
-  isActiveStatus,
-  isQueuedStatus,
-  isDownloadingStatus,
-} from '../utils/downloadStatus';
+import { DownloadStatus, DownloadEntry } from '../utils/downloadStatus';
 
-export type { DownloadStatus, ModelType, DownloadEntry };
-export { isActiveStatus, isQueuedStatus, isDownloadingStatus };
+export type { DownloadStatus, DownloadEntry };
+export type { ModelType } from '../utils/downloadStatus';
+export { isActiveStatus, isQueuedStatus, isDownloadingStatus } from '../utils/downloadStatus';
 
 interface DownloadStoreState {
   downloads: Record<ModelKey, DownloadEntry>