fix: preserve yolo/permission mode across remote switch; validate persisted values; fix Ionicons, QR scanning, MCP bridge on macOS Tauri; add health/relay/spawn-mode tests

apps/cli/src/backends/claude/claudeLocalLauncher.ts

@@ -260,8 +260,16 @@ export async function claudeLocalLauncher(
                 const resolvedAgentMode = resolveSessionModeOverrideFromMetadataSnapshot({
                     metadata: metadataSnapshot,
                 });
+                // Use spawnPermissionMode as a floor: if the per-turn lastPermissionMode
+                // has been clobbered to 'default' by remote messages but the session was
+                // originally started with a non-default mode (e.g. yolo), preserve the
+                // launch intent so the local Claude process respects it.
+                const effectivePermissionMode =
+                    session.lastPermissionMode === 'default' && session.spawnPermissionMode !== 'default'
+                        ? session.spawnPermissionMode
+                        : session.lastPermissionMode;
                 session.claudeArgs = upsertClaudePermissionModeArgs(session.claudeArgs, {
-                    permissionMode: session.lastPermissionMode,
+                    permissionMode: effectivePermissionMode,
                     agentModeId: resolvedAgentMode ? resolvedAgentMode.modeId : null,
                 });
 

apps/cli/src/backends/claude/loop.ts

@@ -98,6 +98,7 @@ export async function loop(opts: LoopOptions): Promise<number> {
         precomputedMcpBridge: opts.precomputedMcpBridge ?? null,
     });
     session.claudeCodeExperimentalAgentTeamsEnabled = opts.claudeCodeExperimentalAgentTeamsEnabled === true;
+    session.spawnPermissionMode = opts.permissionMode ?? 'default';
 
     // Seed permission mode without blocking on transcript fetches.
     // The session's metadata snapshot is already available locally, and for fresh sessions

apps/cli/src/backends/claude/session.test.ts

@@ -148,6 +148,22 @@ describe('Session', () => {
     }
   });
 
+  it('exposes spawnPermissionMode that is independent of lastPermissionMode', () => {
+    const client = createSessionClientStub();
+    const session = createSession(client);
+
+    try {
+      expect(session.spawnPermissionMode).toBe('default');
+
+      session.spawnPermissionMode = 'yolo';
+      session.setLastPermissionMode('default', 200);
+      expect(session.lastPermissionMode).toBe('default');
+      expect(session.spawnPermissionMode).toBe('yolo');
+    } finally {
+      session.cleanup();
+    }
+  });
+
   it('does not bump permissionModeUpdatedAt when permission mode does not change', () => {
     const metadataUpdates: Metadata[] = [];
     const client = createSessionClientStub({

apps/cli/src/backends/claude/session.ts

@@ -102,6 +102,13 @@ export class Session {
         | null = null;
     private happierMcpBridgePromise: Promise<NonNullable<Session['happierMcpBridge']>> | null = null;
 
+    /**
+     * Permission mode from the initial session spawn (CLI --dangerously-skip-permissions or mobile picker).
+     * Set once at session creation, never overwritten by per-message or metadata updates.
+     * Used as a floor when constructing local spawn args so the launch intent is never lost.
+     */
+    spawnPermissionMode: PermissionMode = 'default';
+
     /**
      * Last known permission mode for this session, derived from message metadata / permission responses.
      * Used to carry permission settings across remote ↔ local mode switches.

apps/server/.gitignore

@@ -12,3 +12,5 @@ dist
 .claude/
 
 generated/
+
+prisma/migrations/

apps/server/sources/app/api/utils/enableMonitoring.integration.spec.ts

@@ -1,19 +1,27 @@
 import Fastify from 'fastify';
-import { describe, expect, it } from 'vitest';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 
 import { enableMonitoring } from './enableMonitoring';
 import { createLightSqliteHarness } from '@/testkit/lightSqliteHarness';
 
 describe('enableMonitoring', () => {
-    it('reports service as happier-server in /health responses', async () => {
-        const harness = await createLightSqliteHarness({
+    let harness: Awaited<ReturnType<typeof createLightSqliteHarness>>;
+
+    beforeAll(async () => {
+        harness = await createLightSqliteHarness({
             tempDirPrefix: 'happier-server-health-',
             initAuth: false,
             initEncrypt: false,
             initFiles: false,
         });
-        const app = Fastify();
+    });
+
+    afterAll(async () => {
+        await harness?.close().catch(() => {});
+    });
 
+    it('reports service as happier-server in /health responses', async () => {
+        const app = Fastify();
         try {
             enableMonitoring(app as any);
             await app.ready();
@@ -24,7 +32,24 @@ describe('enableMonitoring', () => {
             expect(body.service).toBe('happier-server');
         } finally {
             await app.close().catch(() => {});
-            await harness.close().catch(() => {});
+        }
+    });
+
+    it('returns full response body shape { status, timestamp, service } when database is healthy', async () => {
+        const app = Fastify();
+        try {
+            enableMonitoring(app as any);
+            await app.ready();
+
+            const res = await app.inject({ method: 'GET', url: '/health' });
+            expect(res.statusCode).toBe(200);
+            const body = res.json() as { status?: string; timestamp?: string; service?: string };
+            expect(body.status).toBe('ok');
+            expect(body.service).toBe('happier-server');
+            expect(typeof body.timestamp).toBe('string');
+            expect(Number.isNaN(new Date(body.timestamp!).getTime())).toBe(false);
+        } finally {
+            await app.close().catch(() => {});
         }
     });
 });

apps/server/sources/app/api/utils/enableMonitoring.spec.ts

@@ -0,0 +1,31 @@
+import Fastify from 'fastify';
+import { describe, expect, it, vi } from 'vitest';
+
+const mockQueryRaw = vi.fn();
+
+vi.mock('@/storage/db', () => ({
+    db: { $queryRaw: mockQueryRaw },
+}));
+
+describe('enableMonitoring (unit)', () => {
+    it('returns 503 with database connectivity error in body when database query fails', async () => {
+        mockQueryRaw.mockRejectedValueOnce(new Error('SQLITE_CANTOPEN: cannot open database'));
+
+        const { enableMonitoring } = await import('./enableMonitoring');
+        const app = Fastify({ logger: false }) as any;
+
+        try {
+            enableMonitoring(app);
+            await app.ready();
+
+            const res = await app.inject({ method: 'GET', url: '/health' });
+            expect(res.statusCode).toBe(503);
+            const body = res.json() as { status?: string; service?: string; error?: string };
+            expect(body.status).toBe('error');
+            expect(body.service).toBe('happier-server');
+            expect(body.error).toBe('Database connectivity failed');
+        } finally {
+            await app.close().catch(() => {});
+        }
+    });
+});

apps/ui/scripts/prepareTauriSidecar.mjs

@@ -3,6 +3,26 @@ import { dirname, join } from 'node:path';
 import { cp, mkdir, readFile, writeFile } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 
+const MCP_DEV_CAPABILITY = {
+  $schema: '../gen/schemas/desktop-schema.json',
+  identifier: 'mcp-dev',
+  description: 'enables the MCP bridge plugin in dev/debug builds',
+  windows: ['main'],
+  permissions: ['mcp-bridge:default'],
+};
+
+export async function ensureTauriMcpDevCapability({
+  srcTauriDir = join(uiDir, 'src-tauri'),
+  mkdirImpl = mkdir,
+  writeFileImpl = writeFile,
+} = {}) {
+  const capabilitiesDir = join(srcTauriDir, 'capabilities');
+  await mkdirImpl(capabilitiesDir, { recursive: true });
+  const targetPath = join(capabilitiesDir, 'mcp-dev.json');
+  await writeFileImpl(targetPath, JSON.stringify(MCP_DEV_CAPABILITY, null, 2) + '\n', 'utf8');
+  return targetPath;
+}
+
 import { ensureWorkspacePackagesBuiltForComponent as ensureWorkspacePackagesBuiltForComponentDefault } from '../../stack/scripts/utils/proc/pm.mjs';
 
 function normalizeTargetTriple(rawValue) {
@@ -117,11 +137,13 @@ export async function prepareTauriSidecar({
   ensureWorkspacePackagesBuiltForComponent = ensureWorkspacePackagesBuiltForComponentDefault,
   ensureTauriSidecarEntrypointFileImpl = ensureTauriSidecarEntrypointFile,
   ensureTauriSidecarRuntimeFilesImpl = ensureTauriSidecarRuntimeFiles,
+  ensureTauriMcpDevCapabilityImpl = ensureTauriMcpDevCapability,
   spawnSyncImpl = spawnSync,
 } = {}) {
   await ensureWorkspacePackagesBuiltForComponent(uiDir, { quiet: false, env });
   await ensureWorkspacePackagesBuiltForComponent(bootstrapDir, { quiet: false, env });
   await ensureTauriWatcherIgnoreFile();
+  await ensureTauriMcpDevCapabilityImpl();
 
   const bunTarget = resolveBunTargetForTauriBuildEnv(env);
   const nextEnv = {

apps/ui/scripts/prepareTauriSidecar.test.mjs

@@ -9,6 +9,7 @@ import {
   ensureTauriWatcherIgnoreFile,
   ensureTauriSidecarEntrypointFile,
   ensureTauriSidecarRuntimeFiles,
+  ensureTauriMcpDevCapability,
   resolveBunTargetForTauriBuildEnv,
   resolveTauriWatcherIgnoreContent,
 } from './prepareTauriSidecar.mjs';
@@ -53,6 +54,9 @@ test('prepareTauriSidecar builds app workspace dependencies before compiling hse
     calls.push(['entrypoint', options]);
     return join(options.srcTauriDir, 'binaries', 'hsetup.js');
   };
+  const ensureTauriMcpDevCapabilityImpl = async () => {
+    calls.push(['mcp-dev']);
+  };
   const spawnSyncImpl = (command, args, options) => {
     calls.push(['spawn', command, args, options]);
     return { status: 0 };
@@ -65,20 +69,44 @@ test('prepareTauriSidecar builds app workspace dependencies before compiling hse
     ensureWorkspacePackagesBuiltForComponent,
     ensureTauriSidecarRuntimeFilesImpl,
     ensureTauriSidecarEntrypointFileImpl,
+    ensureTauriMcpDevCapabilityImpl,
     spawnSyncImpl,
   });
 
   assert.equal(result, 0);
   assert.equal(calls[0][0], 'ensure');
-  assert.match(String(calls[0][1]), /apps\/ui$/);
+  assert.match(String(calls[0][1]), /apps[/\\]ui$/);
   assert.equal(calls[1][0], 'ensure');
-  assert.match(String(calls[1][1]), /apps\/bootstrap$/);
-  assert.equal(calls[2][0], 'spawn');
-  assert.equal(calls[2][1], process.platform === 'win32' ? 'yarn.cmd' : 'yarn');
-  assert.deepEqual(calls[2][2], ['-s', 'workspace', '@happier-dev/bootstrap', 'build:binary']);
-  assert.equal(calls[2][3].env.HAPPIER_BUN_TARGET, 'bun-darwin-arm64');
-  assert.equal(calls[3][0], 'runtime');
-  assert.equal(calls[4][0], 'entrypoint');
+  assert.match(String(calls[1][1]), /apps[/\\]bootstrap$/);
+  assert.equal(calls[2][0], 'mcp-dev');
+  assert.equal(calls[3][0], 'spawn');
+  assert.equal(calls[3][1], process.platform === 'win32' ? 'yarn.cmd' : 'yarn');
+  assert.deepEqual(calls[3][2], ['-s', 'workspace', '@happier-dev/bootstrap', 'build:binary']);
+  assert.equal(calls[3][3].env.HAPPIER_BUN_TARGET, 'bun-darwin-arm64');
+  assert.equal(calls[4][0], 'runtime');
+  assert.equal(calls[5][0], 'entrypoint');
+});
+
+test('ensureTauriMcpDevCapability writes mcp-dev.json with correct content', async () => {
+  const srcTauriDir = await mkdtemp(join(tmpdir(), 'happier-tauri-mcp-dev-'));
+
+  const targetPath = await ensureTauriMcpDevCapability({ srcTauriDir });
+
+  assert.equal(targetPath, join(srcTauriDir, 'capabilities', 'mcp-dev.json'));
+  const capability = JSON.parse(await readFile(targetPath, 'utf8'));
+  assert.equal(capability.identifier, 'mcp-dev');
+  assert.deepEqual(capability.windows, ['main']);
+  assert.ok(capability.permissions.includes('mcp-bridge:default'));
+});
+
+test('ensureTauriMcpDevCapability is idempotent when run multiple times', async () => {
+  const srcTauriDir = await mkdtemp(join(tmpdir(), 'happier-tauri-mcp-dev-idem-'));
+
+  await ensureTauriMcpDevCapability({ srcTauriDir });
+  await ensureTauriMcpDevCapability({ srcTauriDir });
+
+  const capability = JSON.parse(await readFile(join(srcTauriDir, 'capabilities', 'mcp-dev.json'), 'utf8'));
+  assert.equal(capability.identifier, 'mcp-dev');
 });
 
 test('ensureTauriSidecarEntrypointFile copies the compiled hsetup JS companion next to the native wrapper', async () => {

apps/ui/sources/__tests__/routes/(app)/restore/index.webDesktop.spec.tsx

@@ -55,7 +55,7 @@ afterEach(() => {
     resetRestoreRouteTestState();
 });
 describe('/restore (web desktop)', () => {
-    it('defaults to the show-QR restore flow when the web environment is not mobile-like', async () => {
+    it('shows the camera scanner on web desktop when camera API is available', async () => {
         vi.stubGlobal('navigator', {
             maxTouchPoints: 0,
             userAgent: 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
@@ -72,8 +72,8 @@ describe('/restore (web desktop)', () => {
         try {
             screen = await renderScreen(<Screen />);
             await act(async () => {});
-            const qrView = screen.findAllByType('div').filter((node) => node.props['data-testid'] === 'RestoreQrView');
-            expect(qrView).toHaveLength(1);
+            const scannerView = screen.findAllByType('div').filter((node) => node.props['data-testid'] === 'RestoreScanComputerQrView');
+            expect(scannerView).toHaveLength(1);
         } finally {
             await act(async () => {
                 screen?.tree.unmount();

apps/ui/sources/__tests__/routes/_layout.init.spec.tsx

@@ -74,6 +74,7 @@ vi.mock('expo-notifications', () => ({
 
 vi.mock('@expo/vector-icons', () => ({
     FontAwesome: { font: {} },
+    Ionicons: { font: {} },
 }));
 
 vi.mock('@/auth/storage/tokenStorage', () => ({

apps/ui/sources/app/(app)/restore/index.tsx

@@ -1,18 +1,15 @@
 import * as React from 'react';
-import { Platform, useWindowDimensions } from 'react-native';
+import { Platform } from 'react-native';
 
 import { isRunningOnMac } from '@/utils/platform/platform';
 import { RestoreQrView } from '@/components/account/restore/RestoreQrView';
 import { RestoreScanComputerQrView } from '@/components/account/restore/RestoreScanComputerQrView';
 import { isWebQrScannerSupported } from '@/utils/platform/qrScannerSupport';
-import { isWebMobileLikeQrScannerHost } from '@/utils/platform/webMobileHeuristics';
 
 export default function RestoreIndex() {
-    const { width, height } = useWindowDimensions();
     const isNativePhone = (Platform.OS === 'ios' || Platform.OS === 'android') && !isRunningOnMac();
-    const isWebPhoneWithCamera =
-        Platform.OS === 'web' && isWebQrScannerSupported() && isWebMobileLikeQrScannerHost({ width, height });
-    const showScannerFirst = isNativePhone || isWebPhoneWithCamera;
+    const webHasCamera = Platform.OS === 'web' && isWebQrScannerSupported();
+    const showScannerFirst = isNativePhone || webHasCamera;
 
     return showScannerFirst ? <RestoreScanComputerQrView /> : <RestoreQrView />;
 }

apps/ui/sources/app/_layout.tsx

@@ -5,7 +5,7 @@ import * as SplashScreen from 'expo-splash-screen';
 import * as Fonts from 'expo-font';
 import { Asset } from 'expo-asset';
 import * as Notifications from 'expo-notifications';
-import { FontAwesome } from '@expo/vector-icons';
+import { FontAwesome, Ionicons } from '@expo/vector-icons';
 import { useRouter } from 'expo-router';
 import {
     PUSH_NOTIFICATION_ACTION_IDS,
@@ -570,6 +570,7 @@ async function loadFonts() {
             'BricolageGrotesque-Bold': require('@/assets/fonts/BricolageGrotesque-Bold.ttf'),
 
             ...FontAwesome.font,
+            ...Ionicons.font,
         };
 
         // On web, expo-font uses FontFaceObserver with a hard-coded ~6s timeout. In practice, this

apps/ui/sources/components/qr/QrCodeScannerView.tsx

@@ -10,7 +10,6 @@ import { t } from '@/text';
 import { Typography } from '@/constants/Typography';
 import { isRunningOnMac } from '@/utils/platform/platform';
 import { isWebQrScannerSupported } from '@/utils/platform/qrScannerSupport';
-import { isWebMobileLikeQrScannerHost } from '@/utils/platform/webMobileHeuristics';
 
 const stylesheet = StyleSheet.create((theme) => ({
     root: {
@@ -115,8 +114,7 @@ export const QrCodeScannerView = React.memo(function QrCodeScannerView(props: Qr
     const canUseCamera = React.useMemo(() => {
         if (isRunningOnMac()) return false;
         if (Platform.OS !== 'web') return true;
-        if (!isWebQrScannerSupported()) return false;
-        return isWebMobileLikeQrScannerHost({ width, height });
+        return isWebQrScannerSupported();
     }, [height, width]);
 
     React.useEffect(() => {

apps/ui/sources/hooks/auth/useConnectAccount.ts

@@ -9,7 +9,7 @@ import { Modal } from '@/modal';
 import { t } from '@/text';
 import { parseAccountConnectDeepLink } from '@/auth/pairing/accountConnectUrl';
 import { isRunningOnMac } from '@/utils/platform/platform';
-import { isWebMobileLikeQrScannerHost } from '@/utils/platform/webMobileHeuristics';
+import { isWebQrScannerSupported } from '@/utils/platform/qrScannerSupport';
 
 interface UseConnectAccountOptions {
     onSuccess?: () => void;
@@ -52,8 +52,8 @@ export function useConnectAccount(options?: UseConnectAccountOptions) {
     }, [auth.credentials, options]);
 
     const connectAccount = React.useCallback(async () => {
-        const isPhoneSizedWeb = Platform.OS === 'web' && isWebMobileLikeQrScannerHost({ width, height });
-        const canUseScanner = !isRunningOnMac() && (Platform.OS !== 'web' || isPhoneSizedWeb);
+        const webHasCamera = Platform.OS === 'web' && isWebQrScannerSupported();
+        const canUseScanner = !isRunningOnMac() && (Platform.OS !== 'web' || webHasCamera);
         if (!canUseScanner) {
             await Modal.alertAsync(t('common.error'), t('modals.qrScannerUnavailable'), [{ text: t('common.ok') }]);
             return;

apps/ui/sources/sync/api/capabilities/serverFeaturesClient.test.ts

@@ -471,6 +471,21 @@ describe('serverFeaturesClient', () => {
         expect(String(calls[2]?.[0] ?? '')).toContain('https://other.example.test');
     });
 
+    it('returns error status when relay is completely offline (health probe fails with ECONNREFUSED)', async () => {
+        // Simulate a relay that is not running: every fetch — including the /health probe — throws.
+        // This is the "Choose Relay / can't reach relay" scenario that blocks the Tauri app on first launch.
+        globalThis.fetch = vi.fn().mockRejectedValue(
+            new TypeError('Network request failed'),
+        ) as unknown as typeof fetch;
+
+        const { getServerFeaturesSnapshot, resetServerFeaturesClientForTests } = await import('./serverFeaturesClient');
+        resetServerFeaturesClientForTests();
+
+        // timeoutMs=100 allows the reachability gate to time out quickly in the test.
+        const result = await getServerFeaturesSnapshot({ force: true, timeoutMs: 100 });
+        expect(result.status).toBe('error');
+    });
+
     it('fetches features against the explicit serverId url (not the active server)', async () => {
         const payload = {
             features: {