feat(recorder): on-device recorder host + whisper transcription + chat/RAG

.gitignore

@@ -86,6 +86,11 @@ fastlane/*.p8
 !.yarn/sdks
 !.yarn/versions
 docs/TRACTION_KNOWLEDGE_BASE.md
+# Dev-only insights sim harness + private real recordings (never commit)
+/sim/
+# Debug screenshots (scratch)
+/image.png
+/image-*.png
 # Local marketing drafts (not part of the app)
 marketing/
 

App.tsx

@@ -31,6 +31,7 @@ import { LockScreen } from './src/screens';
 import { useAppState } from './src/hooks/useAppState';
 import { useDownloadStore } from './src/stores/downloadStore';
 import { ErrorBoundary } from './src/components/ErrorBoundary';
+import { Toast } from './src/components';
 
 LogBox.ignoreAllLogs(); // Suppress all logs
 
@@ -392,6 +393,7 @@ function App() {
         >
           <AppNavigator />
         </NavigationContainer>
+        <Toast />
       </SafeAreaProvider>
     </GestureHandlerRootView>
   );

__tests__/rntl/navigation/AppNavigator.test.tsx

@@ -179,7 +179,7 @@ describe('AppNavigator', () => {
   });
 
   describe('Tab bar rendering', () => {
-    it('renders all five tab labels', () => {
+    it('renders all five tab labels (Recorder replaced by Settings)', () => {
       const { getAllByText } = renderAppNavigator();
 
       expect(getAllByText('Home').length).toBeGreaterThanOrEqual(1);
@@ -198,6 +198,11 @@ describe('AppNavigator', () => {
       expect(getByTestId('models-tab')).toBeTruthy();
       expect(getByTestId('settings-tab')).toBeTruthy();
     });
+
+    it('no longer renders a Recorder tab (moved to a Home card)', () => {
+      const { queryByTestId } = renderAppNavigator();
+      expect(queryByTestId('recorder-tab')).toBeNull();
+    });
   });
 
   describe('Tab bar safe area insets', () => {
@@ -279,14 +284,12 @@ describe('AppNavigator', () => {
       expect(getAllByText('Chats').length).toBeGreaterThanOrEqual(1);
       expect(getAllByText('Projects').length).toBeGreaterThanOrEqual(1);
       expect(getAllByText('Models').length).toBeGreaterThanOrEqual(1);
-      expect(getAllByText('Settings').length).toBeGreaterThanOrEqual(1);
 
       // All tab buttons should be pressable
       expect(getByTestId('home-tab')).toBeTruthy();
       expect(getByTestId('chats-tab')).toBeTruthy();
       expect(getByTestId('projects-tab')).toBeTruthy();
       expect(getByTestId('models-tab')).toBeTruthy();
-      expect(getByTestId('settings-tab')).toBeTruthy();
     });
   });
 });

__tests__/rntl/onboarding/HomeScreenSpotlight.test.tsx

@@ -299,15 +299,15 @@ describe('HomeScreen Spotlight Integration', () => {
   // Flow 5: Explore Settings
   // ========================================================================
   describe('Flow 5: exploredSettings', () => {
-    it('queues pending spotlight 6, navigates to SettingsTab, fires goTo(5)', () => {
+    it('queues pending spotlight 6, navigates to Settings, fires goTo(5)', () => {
       const { getByTestId } = renderHomeScreen();
 
       act(() => {
         fireEvent.press(getByTestId('step-exploredSettings'));
       });
 
       expect(peekPendingSpotlight()).toBe(6);
-      expect(mockNavigate).toHaveBeenCalledWith('SettingsTab');
+      expect(mockNavigate).toHaveBeenCalledWith('Settings');
 
       act(() => { jest.advanceTimersByTime(800); });
       expect(mockGoTo).toHaveBeenCalledWith(5);

__tests__/unit/onboarding/handleStepPress.test.ts

@@ -307,9 +307,9 @@ describe('handleStepPress', () => {
       expect(peekPendingSpotlight()).toBe(6);
     });
 
-    it('navigates to SettingsTab', () => {
+    it('navigates to Settings', () => {
       simulateHandleStepPress('exploredSettings', callbacks());
-      expect(navigate).toHaveBeenCalledWith('SettingsTab');
+      expect(navigate).toHaveBeenCalledWith('Settings');
     });
 
     it('fires goTo(5) after delay', () => {

__tests__/unit/onboarding/onboardingFlows.test.ts

@@ -80,7 +80,7 @@ describe('Onboarding Flows', () => {
         downloadedModel: 'ModelsTab',
         loadedModel: 'HomeTab',
         sentMessage: 'ChatsTab',
-        exploredSettings: 'SettingsTab',
+        exploredSettings: 'Settings',
         createdProject: 'ProjectsTab',
         triedImageGen: 'ModelsTab',
       });

__tests__/unit/services/rag/database.test.ts

@@ -42,11 +42,13 @@ describe('RagDatabase', () => {
     it('opens the database and creates tables', async () => {
       await ragDatabase.ensureReady();
       expect(open).toHaveBeenCalledWith({ name: 'rag.db' });
-      // rag_documents, rag_chunks, rag_embeddings = 3 tables
-      expect(mockExecuteSync).toHaveBeenCalledTimes(3);
+      // rag_documents, rag_chunks, ALTER rag_chunks (metadata migration), rag_embeddings
+      expect(mockExecuteSync).toHaveBeenCalledTimes(4);
       expect(mockExecuteSync.mock.calls[0][0]).toContain('rag_documents');
       expect(mockExecuteSync.mock.calls[1][0]).toContain('rag_chunks');
-      expect(mockExecuteSync.mock.calls[2][0]).toContain('rag_embeddings');
+      expect(mockExecuteSync.mock.calls[2][0]).toContain('ALTER TABLE rag_chunks');
+      expect(mockExecuteSync.mock.calls[2][0]).toContain('metadata');
+      expect(mockExecuteSync.mock.calls[3][0]).toContain('rag_embeddings');
     });
 
     it('does not re-initialize on second call', async () => {
@@ -86,8 +88,22 @@ describe('RagDatabase', () => {
         (c: any[]) => typeof c[0] === 'string' && c[0].includes('INSERT INTO rag_chunks')
       );
       expect(chunkInserts).toHaveLength(2);
-      expect(chunkInserts[0][1]).toEqual(['chunk one', 42, 0]);
-      expect(chunkInserts[1][1]).toEqual(['chunk two', 42, 1]);
+      // 4th bind is metadata (null when the chunk carries none).
+      expect(chunkInserts[0][1]).toEqual(['chunk one', 42, 0, null]);
+      expect(chunkInserts[1][1]).toEqual(['chunk two', 42, 1, null]);
+    });
+
+    it('serializes chunk metadata to a JSON string on the way into the DB', async () => {
+      await ragDatabase.ensureReady();
+      mockExecuteSync.mockReturnValue({ insertId: 7, rowsAffected: 1, rows: [] });
+
+      const metadata = { recordingId: 'rec-1', startMs: 100, eventTitle: 'Standup' };
+      ragDatabase.insertChunks(42, [{ content: 'has meta', position: 0, metadata } as any]);
+
+      const chunkInsert = mockExecuteSync.mock.calls.find(
+        (c: any[]) => typeof c[0] === 'string' && c[0].includes('INSERT INTO rag_chunks'),
+      );
+      expect(chunkInsert![1]).toEqual(['has meta', 42, 0, JSON.stringify(metadata)]);
     });
   });
 

__tests__/unit/services/selectTextModel.test.ts

@@ -0,0 +1,63 @@
+import { selectTextModelToLoad, fitsBudget } from '../../../src/services/selectTextModel';
+import type { DownloadedModel } from '../../../src/types';
+
+const MB = 1024 * 1024;
+
+function model(id: string, fileSizeMB: number): DownloadedModel {
+  return {
+    id,
+    name: id,
+    author: 'test',
+    filePath: `/models/${id}`,
+    fileName: `${id}.gguf`,
+    fileSize: fileSizeMB * MB,
+    quantization: 'Q4',
+    downloadedAt: '2026-07-13',
+    engine: 'llama',
+  };
+}
+
+// Footprint = fileSize in MB (1x) — the selection logic is independent of the
+// multiplier; the real caller passes hardwareService.estimateModelRam.
+const footprint = (m: DownloadedModel) => (m.fileSize || 0) / MB;
+
+const small = model('small', 500);
+const medium = model('medium', 1000);
+const large = model('large', 3000);
+
+describe('fitsBudget', () => {
+  it('fits when footprint <= budget, not otherwise', () => {
+    expect(fitsBudget(1000, 1000)).toBe(true); // exactly fits
+    expect(fitsBudget(1001, 1000)).toBe(false);
+  });
+});
+
+describe('selectTextModelToLoad', () => {
+  it('returns null when nothing is downloaded', () => {
+    expect(selectTextModelToLoad([], 4000, { activeId: null, footprintMB: footprint })).toBeNull();
+    expect(selectTextModelToLoad([], 4000, { activeId: 'medium', footprintMB: footprint })).toBeNull();
+  });
+
+  it('uses the active model when it fits the budget', () => {
+    expect(selectTextModelToLoad([small, medium, large], 2000, { activeId: 'small', footprintMB: footprint })?.id).toBe('small');
+  });
+
+  it('ignores the active model when it does NOT fit, and picks the largest that fits', () => {
+    // budget 2000: large(3000) does not fit -> largest fitting is medium(1000)
+    expect(selectTextModelToLoad([small, medium, large], 2000, { activeId: 'large', footprintMB: footprint })?.id).toBe('medium');
+  });
+
+  it('with no active id, picks the largest model that fits (best quality within RAM)', () => {
+    expect(selectTextModelToLoad([small, medium, large], 2000, { activeId: null, footprintMB: footprint })?.id).toBe('medium');
+    expect(selectTextModelToLoad([small, medium, large], 4000, { activeId: null, footprintMB: footprint })?.id).toBe('large');
+  });
+
+  it('falls back to the SMALLEST when nothing fits (run something, not an OOM)', () => {
+    // budget 400: smallest is small(500) > 400, nothing fits -> smallest
+    expect(selectTextModelToLoad([small, medium, large], 400, { activeId: 'large', footprintMB: footprint })?.id).toBe('small');
+  });
+
+  it('ignores an active id that is not among the downloaded models', () => {
+    expect(selectTextModelToLoad([small, medium], 2000, { activeId: 'ghost', footprintMB: footprint })?.id).toBe('medium');
+  });
+});

__tests__/unit/services/whisperService.test.ts

@@ -311,11 +311,49 @@ describe('WhisperService', () => {
 
       await whisperService.loadModel('/path/to/model.bin');
 
-      expect(initWhisper).toHaveBeenCalledWith({ filePath: '/path/to/model.bin' });
+      expect(initWhisper).toHaveBeenCalledWith({
+        filePath: '/path/to/model.bin',
+        useGpu: false,
+        useFlashAttn: false,
+        // The test's RNFS.exists mock reports the CoreML encoder present, so
+        // loadModel auto-enables ANE CoreML on iOS.
+        useCoreMLIos: true,
+      });
       expect(whisperService.isModelLoaded()).toBe(true);
       expect(whisperService.getLoadedModelPath()).toBe('/path/to/model.bin');
     });
 
+    it('falls back to CPU when CoreML requested but the encoder asset is missing', async () => {
+      // Valid model file, but the ggml-<model>-encoder.mlmodelc bundle is absent.
+      // Enabling CoreML without it makes whisper.rn crash at 0% on some iOS devices,
+      // so the guard must silently downgrade to CPU (useCoreMLIos: false).
+      mockedRNFS.stat.mockResolvedValue({ size: 75 * 1024 * 1024, isFile: () => true } as any);
+      mockedRNFS.exists.mockImplementation(async (p: string) =>
+        !p.endsWith('-encoder.mlmodelc'),
+      );
+      const mockContext = { id: 'ctx', release: jest.fn(), transcribeRealtime: jest.fn(), transcribe: jest.fn() };
+      mockedInitWhisper.mockResolvedValue(mockContext as any);
+
+      await whisperService.loadModel('/path/to/model.bin', { useCoreML: true });
+
+      expect(initWhisper).toHaveBeenCalledWith(
+        expect.objectContaining({ filePath: '/path/to/model.bin', useCoreMLIos: false }),
+      );
+    });
+
+    it('enables CoreML when the encoder asset is present', async () => {
+      mockedRNFS.stat.mockResolvedValue({ size: 75 * 1024 * 1024, isFile: () => true } as any);
+      mockedRNFS.exists.mockResolvedValue(true); // both the .bin and the .mlmodelc exist
+      const mockContext = { id: 'ctx', release: jest.fn(), transcribeRealtime: jest.fn(), transcribe: jest.fn() };
+      mockedInitWhisper.mockResolvedValue(mockContext as any);
+
+      await whisperService.loadModel('/path/to/model.bin', { useCoreML: true, useGpu: true, useFlashAttn: true });
+
+      expect(initWhisper).toHaveBeenCalledWith(
+        expect.objectContaining({ useCoreMLIos: true, useGpu: true, useFlashAttn: true }),
+      );
+    });
+
     it('unloads different model before loading new one', async () => {
       mockValidModelFile();
       const mockContext1 = {
@@ -788,7 +826,8 @@ describe('WhisperService', () => {
         })),
       };
       mockedInitWhisper.mockResolvedValueOnce(mockContext as any);
-      await whisperService.loadModel('/path/model.bin');
+      // English-only model (.en.bin) so transcribeFile forces language 'en'.
+      await whisperService.loadModel('/path/model.en.bin');
 
       const result = await whisperService.transcribeFile('/audio.wav');
 

__tests__/unit/utils/memorySnapshot.test.ts

@@ -0,0 +1,68 @@
+/**
+ * memorySnapshot unit tests
+ *
+ * logMemory() is a diagnostics probe used around whisper model load and each
+ * transcribe chunk to capture the app's footprint. On iOS it surfaces whether
+ * an apparent transcription "crash" was actually a jetsam low-memory kill.
+ *
+ * Guarantees under test:
+ * - formats used/total in MB and a percentage
+ * - never throws (a failing probe must not break the path it observes)
+ * - no divide-by-zero when total memory is reported as 0
+ */
+
+import DeviceInfo from 'react-native-device-info';
+import logger from '../../../src/utils/logger';
+import { logMemory } from '../../../src/utils/memorySnapshot';
+
+const mockedDeviceInfo = DeviceInfo as jest.Mocked<typeof DeviceInfo>;
+
+describe('logMemory', () => {
+  let logSpy: jest.SpyInstance;
+  let warnSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    logSpy = jest.spyOn(logger, 'log').mockImplementation(() => {});
+    warnSpy = jest.spyOn(logger, 'warn').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    logSpy.mockRestore();
+    warnSpy.mockRestore();
+  });
+
+  it('logs used/total in MB with a percentage, tagged with the call site', async () => {
+    mockedDeviceInfo.getUsedMemory.mockResolvedValue(1.4 * 1024 * 1024 * 1024);
+    mockedDeviceInfo.getTotalMemory.mockResolvedValue(4 * 1024 * 1024 * 1024);
+
+    await logMemory('whisper:beforeLoad');
+
+    expect(logSpy).toHaveBeenCalledTimes(1);
+    const msg = logSpy.mock.calls[0][0] as string;
+    expect(msg).toContain('[mem] whisper:beforeLoad');
+    expect(msg).toContain('used=1434MB');
+    expect(msg).toContain('total=4096MB');
+    expect(msg).toContain('(35%)');
+  });
+
+  it('never throws and warns when the probe fails', async () => {
+    mockedDeviceInfo.getUsedMemory.mockRejectedValue(new Error('boom'));
+    mockedDeviceInfo.getTotalMemory.mockResolvedValue(4 * 1024 * 1024 * 1024);
+
+    await expect(logMemory('transcribe:chunk@0s')).resolves.toBeUndefined();
+    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('snapshot failed'));
+    expect(logSpy).not.toHaveBeenCalled();
+  });
+
+  it('does not divide by zero when total memory is unavailable', async () => {
+    mockedDeviceInfo.getUsedMemory.mockResolvedValue(100 * 1024 * 1024);
+    mockedDeviceInfo.getTotalMemory.mockResolvedValue(0);
+
+    await logMemory('zero');
+
+    const msg = logSpy.mock.calls[0][0] as string;
+    expect(msg).toContain('total=0MB');
+    expect(msg).toContain('(0%)');
+  });
+});