Feat/pro feature registry

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "pro"]
+	path = pro
+	url = https://github.com/wednesday-solutions/offgrid-pro.git

App.tsx

@@ -14,14 +14,39 @@ import { useTheme } from './src/theme';
 import { hardwareService, modelManager, authService, ragService, remoteServerManager } from './src/services';
 import logger from './src/utils/logger';
 import { useAppStore, useAuthStore, useRemoteServerStore } from './src/stores';
+import { useDebugLogsStore } from './src/stores/debugLogsStore';
+import { loadProFeatures } from './src/bootstrap/loadProFeatures';
+import { preloadSelectedModels } from './src/services/modelPreloader';
+import { configureRevenueCat, checkProStatus } from './src/services/proLicenseService';
 import { hydrateDownloadStore } from './src/services/downloadHydration';
 import { useDownloadListeners } from './src/hooks/useDownloads';
+import { getSlot, SLOTS } from './src/bootstrap/slotRegistry';
 import { LockScreen } from './src/screens';
 import { useAppState } from './src/hooks/useAppState';
 import { useDownloadStore } from './src/stores/downloadStore';
 
 LogBox.ignoreAllLogs(); // Suppress all logs
 
+// Dev-only: mirror logger output into the in-app Debug Logs viewer. The whole block
+// is behind __DEV__, so release builds keep main's no-op logger (zero logging cost).
+if (__DEV__) {
+  const fmt = (a: unknown): string => {
+    if (a instanceof Error) return `${a.name}: ${a.message}`;
+    if (typeof a === 'string') return a;
+    try { return JSON.stringify(a); } catch { return String(a); }
+  };
+  const base = { log: logger.log, warn: logger.warn, error: logger.error };
+  const tap = (level: 'log' | 'warn' | 'error') => (...args: unknown[]) => {
+    base[level](...args);
+    try {
+      useDebugLogsStore.getState().addLog({ timestamp: Date.now(), level, message: args.map(fmt).join(' ') });
+    } catch { /* never break logging */ }
+  };
+  logger.log = tap('log');
+  logger.warn = tap('warn');
+  logger.error = tap('error');
+}
+
 const ensureRemoteServerStoreHydrated = async () => {
   const persistApi = useRemoteServerStore.persist;
   if (!persistApi?.hasHydrated || !persistApi.rehydrate) return;
@@ -166,11 +191,46 @@ function App() {
       // Initialize RAG database tables
       ragService.ensureReady().catch((err) => logger.error('Failed to initialize RAG service on startup', err));
 
+      // Configure RevenueCat and read the cached entitlement before Pro features load.
+      // configureRevenueCat is sync; checkProStatus reads the keychain cache immediately
+      // and fires a background RC network sync so the next launch stays fresh.
+      //
+      // Pro is optional: a failure here (missing native module, keychain locked,
+      // bad RC config) must never abort app init or hang the splash screen, so the
+      // whole block is isolated and only logs on error.
+      // RevenueCat is isolated in its own try: a failure here (no billing on a
+      // simulator, bad RC config, no network) must NOT prevent pro features from
+      // loading — otherwise the dev unlock below would never run.
+      let isPro = false;
+      try {
+        configureRevenueCat();
+        isPro = await checkProStatus();
+      } catch (rcError) {
+        logger.error('[App] RevenueCat init failed, continuing without entitlement:', rcError);
+      }
+
+      try {
+        // Load pro features — only activates if the keychain entitlement is set
+        // (or in dev, where loadProFeatures force-unlocks).
+        await loadProFeatures(isPro);
+
+        // DEV ONLY: treat dev builds as Pro so the upsell banner hides and pro
+        // UI is unlocked for local testing. Never runs in release (__DEV__ false).
+        if (__DEV__) {
+          useAppStore.getState().setHasRegisteredPro(true);
+        }
+      } catch (proError) {
+        logger.error('[App] Pro feature load failed, continuing without Pro:', proError);
+      }
+
       // Show the UI immediately
       setIsInitializing(false);
 
-      // Models are loaded on-demand when the user opens a chat,
-      // not eagerly on startup, to avoid freezing the UI.
+      // Warm the selected models in the background (text → image → TTS → STT,
+      // budget-gated, sequential) so the common paths have no cold-start wait.
+      // Fire-and-forget after the UI is up; loads run one at a time off the JS
+      // thread so they don't freeze the screen.
+      preloadSelectedModels();
     } catch (error) {
       logger.error('[App] Error initializing app:', error);
       setIsInitializing(false);
@@ -223,6 +283,7 @@ function App() {
     <GestureHandlerRootView style={styles.flex}>
       <SafeAreaProvider>
         <StatusBar barStyle={isDark ? 'light-content' : 'dark-content'} backgroundColor={colors.background} />
+        {(() => { const AppRoot = getSlot(SLOTS.appRoot); return AppRoot ? <AppRoot /> : null; })()}
         <NavigationContainer
           theme={{
             dark: isDark,

CLAUDE.md

@@ -46,6 +46,25 @@ The emotional arc for all content: **Recognition -> Return -> Freedom**. Name wh
 - Never use `lucide-react` or any other icon library — only `react-native-vector-icons`.
 - Follow the 5-category text hierarchy: TITLE → BODY → SUBTITLE/DESCRIPTION → META.
 
+## Reuse Before Building
+
+**Before writing any new component, style, hook, or service, search for an existing one and reuse it.** Building a parallel version of something that already exists creates visual and behavioural drift (e.g. a search box that looks different from every other search box).
+
+- For UI: grep `src/components/` and the relevant screen folder for an existing component or shared style (e.g. `ModelCard`, `Card`, `Button`, shared `searchContainer`/`searchInput` styles) before creating your own. Two screens that show the same kind of thing must use the same component.
+- For logic: check for an existing hook/service/store action (`grep -rn`) before adding a new one.
+- If an existing component is close but not exact, extend it with a prop rather than forking a copy.
+- Only build new when nothing fits — and say so in the PR description.
+
+## Architecture & Abstractions (SOLID)
+
+**Design to abstractions, not concrete implementations.** When there are multiple interchangeable implementations of a thing (TTS engines, model backends, providers, storage), the rest of the app must depend on a single interface/service layer — never branch on a concrete type.
+
+- **No leaking implementation details upward.** UI and stores must not do `instanceof SpecificEngine`, check `engineId === 'kokoro'`, or branch on capabilities to decide *how* to do something. Push that decision behind the abstraction (the engine/provider implements it; or a service layer dispatches once). If you find yourself writing `if (engine X) … else …` in a component, the abstraction is wrong.
+- **Single uniform entry point.** Prefer one polymorphic method (e.g. `engine.play(text, opts)`) that every implementation satisfies over several mechanism-specific methods (`speak` vs `playFromFile`) that callers must choose between.
+- **Service layer between UI and implementations.** Implementations (engines/adapters) are swappable; a service abstracts them and exposes a normalized API + state. Adding a new implementation must require zero changes to UI/store.
+- **Dependency Inversion / Liskov:** any implementation must be substitutable through the interface without callers knowing which one is active. Normalize gaps (e.g. an engine that can't report playback position) inside the service, not in the UI.
+- Apply the rest of SOLID: single responsibility per module, open for extension (add an implementation) / closed for modification (don't touch callers), segregated interfaces (don't force implementations to stub methods they can't support — model that with the abstraction).
+
 ## Pre-Commit Quality Gates
 
 All quality gates run automatically via Husky on every `git commit`, scoped to the file types you staged:

__tests__/integration/generation/generationFlow.test.ts

@@ -416,7 +416,7 @@ describe('Generation Flow Integration', () => {
           onComplete: expect.any(Function),
           onError: expect.any(Function),
         }),
-        ['file:///one.png', 'file:///two.png'],
+        { imageUris: ['file:///one.png', 'file:///two.png'], audioUris: [] },
       );
 
       const [, callbacks] = mockLiteRTService.sendMessage.mock.calls[0];

__tests__/integration/generation/toolExtensionLoop.test.ts

@@ -0,0 +1,178 @@
+/**
+ * Integration test: registered ToolExtension flows through runToolLoop.
+ *
+ * Verifies:
+ * 1. Extension system-prompt hint is appended to the system message.
+ * 2. Extension tool calls parsed from LLM text are collected.
+ * 3. Extension executor is called instead of the built-in executeToolCall.
+ * 4. Extension tool calls result in a tool-result message in the chat store.
+ * 5. Free path (no extensions): behaviour is identical to today.
+ */
+
+import { runToolLoop, ToolLoopContext } from '../../../src/services/generationToolLoop';
+import {
+  registerToolExtension,
+  _clearExtensionsForTesting,
+  ToolExtension,
+} from '../../../src/services/tools/extensions';
+import type { ToolCall } from '../../../src/services/tools/types';
+import { useChatStore } from '../../../src/stores';
+import { resetStores } from '../../utils/testHelpers';
+
+// Mock the LLM so we control what it "says"
+jest.mock('../../../src/services/llm');
+jest.mock('../../../src/services/litert');
+jest.mock('../../../src/services/activeModelService');
+
+const { llmService } = require('../../../src/services/llm');
+const { liteRTService } = require('../../../src/services/litert');
+
+// Mock executeToolCall so built-in tools don't actually run
+jest.mock('../../../src/services/tools', () => ({
+  getToolsAsOpenAISchema: jest.fn(() => []),
+  executeToolCall: jest.fn().mockResolvedValue({ name: 'builtin', content: 'builtin-result', durationMs: 1 }),
+}));
+
+// Mock the stores index: pull in the REAL chat + app stores (the loop reads/writes
+// them and the test asserts on stored messages), stub the remote server store so we
+// stay on the local path. Requiring the submodules directly avoids loading the full
+// stores index (auth/whisper/project), which fails to initialise in this test env.
+jest.mock('../../../src/stores', () => {
+  const { useChatStore: realChatStore } = jest.requireActual('../../../src/stores/chatStore');
+  const { useAppStore: realAppStore } = jest.requireActual('../../../src/stores/appStore');
+  return {
+    useChatStore: realChatStore,
+    useAppStore: realAppStore,
+    useRemoteServerStore: {
+      getState: () => ({ activeServerId: null, activeRemoteTextModelId: null }),
+    },
+  };
+});
+
+// Fake extension that parses <mcp_call>tool_name</mcp_call> tags
+const MCP_TOOL_NAME = 'mcp_fake_tool';
+const MCP_HINT = '\n\nMCP tools available:\n- mcp_fake_tool: A fake MCP tool';
+const MCP_RESULT = 'mcp-result-content';
+
+function makeFakeExtension(executorMock: jest.Mock): ToolExtension {
+  return {
+    id: 'mcp',
+    getSystemPromptHint: () => MCP_HINT,
+    parseToolCalls: (text: string): ToolCall[] => {
+      const match = /<mcp_call>([\s\S]*?)<\/mcp_call>/.exec(text);
+      if (!match) return [];
+      return [{ id: 'mcp-tc-1', name: match[1].trim(), arguments: {} }];
+    },
+    stripFromVisibleText: (text: string) => text.replace(/<mcp_call>[\s\S]*?<\/mcp_call>/g, '').trim(),
+    canHandle: (name: string) => name === MCP_TOOL_NAME,
+    execute: executorMock,
+    enabledToolCount: () => 1,
+  };
+}
+
+function makeCtx(overrides: Partial<ToolLoopContext> = {}): ToolLoopContext {
+  // createConversation takes a modelId and returns the generated conversation UUID
+  const conversationId = useChatStore.getState().createConversation('test-model');
+  return {
+    conversationId,
+    messages: [
+      { id: 'sys', role: 'system', content: 'You are helpful.', timestamp: 0 },
+      { id: 'u1', role: 'user', content: 'Run the MCP tool.', timestamp: 1 },
+    ],
+    enabledToolIds: [],
+    isAborted: () => false,
+    onThinkingDone: jest.fn(),
+    onFinalResponse: jest.fn(),
+    ...overrides,
+  };
+}
+
+describe('tool extension loop integration', () => {
+  beforeEach(() => {
+    resetStores();
+    _clearExtensionsForTesting();
+    jest.clearAllMocks();
+    liteRTService.isModelLoaded.mockReturnValue(false);
+    llmService.isModelLoaded.mockReturnValue(true);
+    llmService.stopGeneration.mockResolvedValue(undefined);
+  });
+
+  describe('free path — no extensions registered', () => {
+    it('calls onFinalResponse with the LLM text', async () => {
+      llmService.generateResponseWithTools.mockResolvedValue({
+        fullResponse: 'Hello world',
+        toolCalls: [],
+      });
+      const ctx = makeCtx();
+      await runToolLoop(ctx);
+      expect(ctx.onFinalResponse).toHaveBeenCalledWith('Hello world');
+    });
+  });
+
+  function setupProExtension(
+    firstResponse = `<mcp_call>${MCP_TOOL_NAME}</mcp_call>`,
+    secondResponse = 'Done.',
+  ): jest.Mock {
+    const executorMock = jest.fn().mockResolvedValue({
+      name: MCP_TOOL_NAME, content: MCP_RESULT, durationMs: 5,
+    });
+    registerToolExtension(makeFakeExtension(executorMock));
+    llmService.generateResponseWithTools
+      .mockResolvedValueOnce({ fullResponse: firstResponse, toolCalls: [] })
+      .mockResolvedValueOnce({ fullResponse: secondResponse, toolCalls: [] });
+    return executorMock;
+  }
+
+  describe('pro path — extension registered', () => {
+    it('appends extension hint to the system prompt sent to LLM', async () => {
+      setupProExtension();
+
+      const ctx = makeCtx();
+      await runToolLoop(ctx);
+
+      // System prompt in the first LLM call should contain the extension hint
+      const firstCallMessages = llmService.generateResponseWithTools.mock.calls[0][0] as any[];
+      const sysMsg = firstCallMessages.find((m: any) => m.role === 'system');
+      expect(sysMsg.content).toContain(MCP_HINT);
+    });
+
+    it('routes execution to the extension executor, not built-in executeToolCall', async () => {
+      const executorMock = setupProExtension();
+
+      const ctx = makeCtx();
+      await runToolLoop(ctx);
+
+      expect(executorMock).toHaveBeenCalledTimes(1);
+      expect(executorMock).toHaveBeenCalledWith(
+        expect.objectContaining({ name: MCP_TOOL_NAME }),
+      );
+
+      const { executeToolCall } = require('../../../src/services/tools');
+      expect(executeToolCall).not.toHaveBeenCalled();
+    });
+
+    it('stores tool result in chat store', async () => {
+      setupProExtension();
+
+      const ctx = makeCtx();
+      await runToolLoop(ctx);
+
+      const messages = useChatStore.getState().conversations.find(c => c.id === ctx.conversationId)?.messages ?? [];
+      const toolResultMsg = messages.find(m => m.role === 'tool' && m.toolName === MCP_TOOL_NAME);
+      expect(toolResultMsg).toBeDefined();
+      expect(toolResultMsg?.content).toBe(MCP_RESULT);
+    });
+
+    it('strips extension syntax from visible text', async () => {
+      setupProExtension(`Thinking...<mcp_call>${MCP_TOOL_NAME}</mcp_call>`, 'Final answer.');
+
+      const ctx = makeCtx();
+      await runToolLoop(ctx);
+
+      // The assistant message stored for the tool-call turn must not contain the raw tag
+      const messages = useChatStore.getState().conversations.find(c => c.id === ctx.conversationId)?.messages ?? [];
+      const assistantMsg = messages.find(m => m.role === 'assistant' && m.toolCalls && m.toolCalls.length > 0);
+      expect(assistantMsg?.content).not.toContain('<mcp_call>');
+    });
+  });
+});