diff --git a/app/app.json b/app/app.json
index 4ba1384..83b4399 100644
--- a/app/app.json
+++ b/app/app.json
@@ -7,8 +7,14 @@
     "orientation": "portrait",
     "userInterfaceStyle": "automatic",
     "newArchEnabled": true,
+    "icon": "./assets/icon.png",
     "android": {
       "package": "top.mowden.bigbrainparking",
+      "edgeToEdgeEnabled": true,
+      "adaptiveIcon": {
+        "foregroundImage": "./assets/adaptive-icon.png",
+        "backgroundColor": "#0F2A33"
+      },
       "permissions": [
         "ACCESS_COARSE_LOCATION",
         "ACCESS_FINE_LOCATION",
diff --git a/app/assets/adaptive-icon.png b/app/assets/adaptive-icon.png
new file mode 100644
index 0000000..f7e90a2
Binary files /dev/null and b/app/assets/adaptive-icon.png differ
diff --git a/app/assets/icon.png b/app/assets/icon.png
new file mode 100644
index 0000000..c5fabb3
Binary files /dev/null and b/app/assets/icon.png differ
diff --git a/app/src/api/client.ts b/app/src/api/client.ts
index 9b18f61..9ff8659 100644
--- a/app/src/api/client.ts
+++ b/app/src/api/client.ts
@@ -2,16 +2,19 @@ import Constants from 'expo-constants';
 import * as Localization from 'expo-localization';
 import { ParkSmarterClient, type EnvironmentName } from 'parksmarter-client';
 import { secureTokenStore } from './secureTokenStore';
+import { authBus } from '@/auth/authBus';
 
 const env =
   (Constants.expoConfig?.extra?.psEnvironment as EnvironmentName) ?? 'prodv2';
 
 /**
  * The single app-wide API client. React Native ships a global `fetch`, so no
- * fetchImpl override is needed. Tokens persist in the OS keystore.
+ * fetchImpl override is needed. Tokens persist in the OS keystore. On a 401 the
+ * client clears the token and we bounce the user to sign-in via authBus.
  */
 export const ps = new ParkSmarterClient({
   environment: env,
   tokens: secureTokenStore,
   localeCode: (Localization.getLocales()[0]?.languageCode ?? 'en').toLowerCase(),
+  onUnauthorized: () => authBus.onUnauthorized?.(),
 });
diff --git a/app/src/auth/AuthContext.tsx b/app/src/auth/AuthContext.tsx
index 270d824..3b5e098 100644
--- a/app/src/auth/AuthContext.tsx
+++ b/app/src/auth/AuthContext.tsx
@@ -6,6 +6,7 @@ import React, {
   useState,
 } from 'react';
 import { ps } from '@/api/client';
+import { authBus } from '@/auth/authBus';
 import type { ApplicationValidityResponse } from 'parksmarter-client';
 
 type AuthStatus = 'loading' | 'signedOut' | 'signedIn';
@@ -25,6 +26,17 @@ export function AuthProvider({ children }: { children: React.ReactNode }) {
   const [validity, setValidity] = useState<ApplicationValidityResponse | null>(null);
   const [error, setError] = useState<string | null>(null);
 
+  // Any 401 from the API (expired/rotated token) bounces us back to sign-in.
+  useEffect(() => {
+    authBus.onUnauthorized = () => {
+      setError('Your session expired — please sign in again.');
+      setStatus('signedOut');
+    };
+    return () => {
+      authBus.onUnauthorized = undefined;
+    };
+  }, []);
+
   // On launch: bootstrap (seeds SessionId + feature flags) and probe for an
   // existing token by attempting an authenticated read.
   useEffect(() => {
diff --git a/app/src/auth/authBus.ts b/app/src/auth/authBus.ts
new file mode 100644
index 0000000..075d9fd
--- /dev/null
+++ b/app/src/auth/authBus.ts
@@ -0,0 +1,6 @@
+/**
+ * Tiny bridge so the API client (created at module load) can notify the React
+ * auth layer when a 401 happens, without a circular import. AuthProvider
+ * registers a handler; the client calls it via app/src/api/client.ts.
+ */
+export const authBus: { onUnauthorized?: () => void } = {};
diff --git a/app/src/screens/MapScreen.tsx b/app/src/screens/MapScreen.tsx
index 2eecf3d..0603f95 100644
--- a/app/src/screens/MapScreen.tsx
+++ b/app/src/screens/MapScreen.tsx
@@ -9,6 +9,7 @@ import {
 } from '@maplibre/maplibre-react-native';
 import { useNavigation } from '@react-navigation/native';
 import type { NativeStackNavigationProp } from '@react-navigation/native-stack';
+import { useSafeAreaInsets } from 'react-native-safe-area-context';
 import { ps } from '@/api/client';
 import { useLocation, getLastKnownSavedLocation, type Coords } from '@/features/location/useLocation';
 import type { RootStackParamList } from '@/navigation/RootNavigator';
@@ -26,6 +27,7 @@ type Nav = NativeStackNavigationProp<RootStackParamList>;
 
 export function MapScreen() {
   const navigation = useNavigation<Nav>();
+  const insets = useSafeAreaInsets();
   const { coords, refresh } = useLocation();
   const [zones, setZones] = useState<Zone[]>([]);
   const [status, setStatus] = useState<string>('Pan to an area and tap “Search this area”.');
@@ -34,6 +36,9 @@ export function MapScreen() {
 
   const mapRef = useRef<any>(null);
   const cameraRef = useRef<any>(null);
+  // The native UserLocation dot has its own GPS feed — capture it so "My
+  // location" works even when expo-location can't get a fix (e.g. indoors).
+  const nativeFix = useRef<Coords | null>(null);
 
   // Seed the initial camera from a cached location so we don't strand at 0,0.
   useEffect(() => {
@@ -78,17 +83,18 @@ export function MapScreen() {
     if (coords) await searchAt(coords, 'this area');
   };
 
-  // Recenter on the live GPS fix (if available) and search there.
+  // Recenter on the live GPS fix (if available) and search there. Prefer the
+  // native map fix (the blue dot), then expo-location, then a forced refresh.
   const goToMyLocation = async () => {
-    const c = coords ?? (await refresh());
+    const c = nativeFix.current ?? coords ?? (await refresh());
     if (!c) {
-      setStatus('No location available (GPS/location may be off).');
+      setStatus('No location fix yet — GPS may be unavailable (e.g. indoors).');
       return;
     }
     cameraRef.current?.setCamera?.({
       centerCoordinate: [c.longitude, c.latitude],
       zoomLevel: 15,
-      animationDuration: 500,
+      animationDuration: 700,
     });
     await searchAt(c, 'you');
   };
@@ -120,7 +126,18 @@ export function MapScreen() {
           />
         ) : null}
 
-        <UserLocation visible renderMode="native" />
+        <UserLocation
+          visible
+          renderMode="native"
+          onUpdate={(loc: any) => {
+            if (loc?.coords) {
+              nativeFix.current = {
+                latitude: loc.coords.latitude,
+                longitude: loc.coords.longitude,
+              };
+            }
+          }}
+        />
 
         {zones.map((z) => (
           <MarkerView
@@ -139,14 +156,14 @@ export function MapScreen() {
         ))}
       </MapView>
 
-      <View style={styles.statusBar}>
+      <View style={[styles.statusBar, { top: insets.top + 12 }]}>
         {loading ? <ActivityIndicator color="#fff" style={{ marginRight: 8 }} /> : null}
         <Text style={styles.statusText} numberOfLines={1}>
           {status}
         </Text>
       </View>
 
-      <View style={styles.controls}>
+      <View style={[styles.controls, { bottom: insets.bottom + 24 }]}>
         <TouchableOpacity style={styles.pillPrimary} onPress={searchThisArea}>
           <Text style={styles.pillText}>Search this area</Text>
         </TouchableOpacity>
diff --git a/parksmarter-client/src/client.ts b/parksmarter-client/src/client.ts
index 7edab24..ffab6f1 100644
--- a/parksmarter-client/src/client.ts
+++ b/parksmarter-client/src/client.ts
@@ -43,6 +43,8 @@ export interface ParkSmarterClientOptions {
   /** Provide a fetch impl for React Native / Node < 18 / tests. */
   fetchImpl?: typeof fetch;
   uuid?: () => string;
+  /** Called when any authenticated request returns 401 (token cleared automatically). */
+  onUnauthorized?: () => void;
 }
 
 function resolveEnvironment(
@@ -66,6 +68,7 @@ export class ParkSmarterClient {
       timeoutMs: options.timeoutMs,
       fetchImpl: options.fetchImpl,
       uuid: options.uuid,
+      onUnauthorized: options.onUnauthorized,
     });
   }
 
diff --git a/parksmarter-client/src/http.ts b/parksmarter-client/src/http.ts
index ec13e39..7f6377a 100644
--- a/parksmarter-client/src/http.ts
+++ b/parksmarter-client/src/http.ts
@@ -101,6 +101,11 @@ export interface HttpClientConfig {
   fetchImpl?: typeof fetch;
   /** Override UUID generation. Defaults to crypto.randomUUID when available. */
   uuid?: () => string;
+  /**
+   * Called whenever an authenticated request comes back 401. Use it to clear the
+   * stored token and route the user back to sign-in. Fired before the error throws.
+   */
+  onUnauthorized?: () => void;
 }
 
 function defaultUuid(): string {
@@ -135,6 +140,7 @@ export class HttpClient {
       timeoutMs: config.timeoutMs ?? 30000,
       fetchImpl: config.fetchImpl ?? globalThis.fetch?.bind(globalThis),
       uuid: config.uuid ?? defaultUuid,
+      onUnauthorized: config.onUnauthorized ?? (() => {}),
     };
     if (!this.cfg.fetchImpl) {
       throw new Error(
@@ -244,6 +250,11 @@ export class HttpClient {
     }
 
     if (!res.ok) {
+      if (res.status === 401) {
+        // Token invalid/rotated/expired — let the app clear it and re-auth.
+        await this.cfg.tokens.setAuthToken(null);
+        this.cfg.onUnauthorized();
+      }
       throw new ParkSmarterApiError(res.status, data ?? text, requestId);
     }